3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 #define HAVE_AV_CONFIG_H
23 #include "framehook.h"
31 #include <sys/ioctl.h>
34 #include <sys/resource.h>
38 #include <sys/types.h>
39 #include <sys/select.h>
42 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
51 #if !defined(INFINITY) && defined(HUGE_VAL)
52 #define INFINITY HUGE_VAL
55 /* select an input stream for an output stream */
56 typedef struct AVStreamMap {
60 int sync_stream_index;
63 /** select an input file for an output file */
64 typedef struct AVMetaDataMap {
69 extern const OptionDef options[];
71 static void show_help(void);
72 static void show_license(void);
73 static int opt_default(const char *opt, const char *arg);
77 static AVFormatContext *input_files[MAX_FILES];
78 static int64_t input_files_ts_offset[MAX_FILES];
79 static int nb_input_files = 0;
81 static AVFormatContext *output_files[MAX_FILES];
82 static int nb_output_files = 0;
84 static AVStreamMap stream_maps[MAX_FILES];
85 static int nb_stream_maps;
87 static AVMetaDataMap meta_data_maps[MAX_FILES];
88 static int nb_meta_data_maps;
90 static AVInputFormat *file_iformat;
91 static AVOutputFormat *file_oformat;
92 static AVImageFormat *image_format;
93 static int frame_width = 0;
94 static int frame_height = 0;
95 static float frame_aspect_ratio = 0;
96 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
97 static int frame_padtop = 0;
98 static int frame_padbottom = 0;
99 static int frame_padleft = 0;
100 static int frame_padright = 0;
101 static int padcolor[3] = {16,128,128}; /* default to black */
102 static int frame_topBand = 0;
103 static int frame_bottomBand = 0;
104 static int frame_leftBand = 0;
105 static int frame_rightBand = 0;
106 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
107 static int frame_rate = 25;
108 static int frame_rate_base = 1;
109 static float video_qscale = 0;
110 static int video_lmin = 2*FF_QP2LAMBDA;
111 static int video_lmax = 31*FF_QP2LAMBDA;
112 static int video_mb_lmin = 2*FF_QP2LAMBDA;
113 static int video_mb_lmax = 31*FF_QP2LAMBDA;
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 packet_size = 0;
132 static int strict = 0;
133 static int top_field_first = -1;
134 static int me_threshold = 0;
135 static int intra_dc_precision = 8;
136 static int loop_input = 0;
137 static int loop_output = AVFMT_NOOUTPUTLOOP;
138 static int qp_hist = 0;
140 static int intra_only = 0;
141 static int audio_sample_rate = 44100;
142 static int audio_bit_rate = 64000;
143 #define QSCALE_NONE -99999
144 static float audio_qscale = QSCALE_NONE;
145 static int audio_disable = 0;
146 static int audio_channels = 1;
147 static int audio_codec_id = CODEC_ID_NONE;
148 static int audio_codec_tag = 0;
149 static char *audio_language = NULL;
151 static int subtitle_codec_id = CODEC_ID_NONE;
152 static char *subtitle_language = NULL;
154 static float mux_preload= 0.5;
155 static float mux_max_delay= 0.7;
157 static int64_t recording_time = 0;
158 static int64_t start_time = 0;
159 static int64_t rec_timestamp = 0;
160 static int64_t input_ts_offset = 0;
161 static int file_overwrite = 0;
162 static char *str_title = NULL;
163 static char *str_author = NULL;
164 static char *str_copyright = NULL;
165 static char *str_comment = NULL;
166 static char *str_album = NULL;
167 static int do_benchmark = 0;
168 static int do_hex_dump = 0;
169 static int do_pkt_dump = 0;
170 static int do_psnr = 0;
171 static int do_vstats = 0;
172 static int do_pass = 0;
173 static char *pass_logfilename = NULL;
174 static int audio_stream_copy = 0;
175 static int video_stream_copy = 0;
176 static int subtitle_stream_copy = 0;
177 static int video_sync_method= 1;
178 static int audio_sync_method= 0;
179 static int copy_ts= 0;
180 static int opt_shortest = 0; //
181 static int video_global_header = 0;
183 static int rate_emu = 0;
186 static const char *video_grab_format = "bktr";
188 #ifdef CONFIG_VIDEO4LINUX2
189 static const char *video_grab_format = "video4linux2";
191 static const char *video_grab_format = "video4linux";
194 static char *video_device = NULL;
195 static char *grab_device = NULL;
196 static int video_channel = 0;
197 static char *video_standard = "ntsc";
199 static const char *audio_grab_format = "audio_device";
200 static char *audio_device = NULL;
201 static int audio_volume = 256;
203 static int using_stdin = 0;
204 static int using_vhook = 0;
205 static int verbose = 1;
206 static int thread_count= 1;
207 static int q_pressed = 0;
208 static int64_t video_size = 0;
209 static int64_t audio_size = 0;
210 static int64_t extra_size = 0;
211 static int nb_frames_dup = 0;
212 static int nb_frames_drop = 0;
213 static int input_sync;
214 static int limit_filesize = 0; //
216 static int pgmyuv_compatibility_hack=0;
217 static int dts_delta_threshold = 10;
219 static int sws_flags = SWS_BICUBIC;
221 const char **opt_names=NULL;
222 int opt_name_count=0;
223 AVCodecContext *avctx_opts;
224 AVFormatContext *avformat_opts;
226 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
227 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
228 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
230 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
232 struct AVInputStream;
234 typedef struct AVOutputStream {
235 int file_index; /* file index */
236 int index; /* stream index in the output file */
237 int source_index; /* AVInputStream index */
238 AVStream *st; /* stream in the output file */
239 int encoding_needed; /* true if encoding needed for this stream */
241 /* input pts and corresponding output pts
243 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
244 struct AVInputStream *sync_ist; /* input stream to sync against */
245 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
248 AVFrame pict_tmp; /* temporary image for resampling */
249 struct SwsContext *img_resample_ctx; /* for image resampling */
253 int topBand; /* cropping area sizes */
257 int padtop; /* padding area sizes */
264 ReSampleContext *resample; /* for audio resampling */
265 AVFifoBuffer fifo; /* for compression: one audio fifo per codec */
269 typedef struct AVInputStream {
273 int discard; /* true if stream data should be discarded */
274 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
275 int64_t sample_index; /* current sample */
277 int64_t start; /* time when read started */
278 unsigned long frame; /* current frame */
279 int64_t next_pts; /* synthetic pts for cases where pkt.pts
281 int64_t pts; /* current pts */
282 int is_start; /* is 1 at the start and after a discontinuity */
285 typedef struct AVInputFile {
286 int eof_reached; /* true if eof reached */
287 int ist_index; /* index of first stream in ist_table */
288 int buffer_size; /* current total buffer size */
289 int buffer_size_max; /* buffer size at which we consider we can stop
291 int nb_streams; /* nb streams we are aware of */
296 /* init terminal so that we can grab keys */
297 static struct termios oldtty;
299 static void term_exit(void)
301 tcsetattr (0, TCSANOW, &oldtty);
304 static volatile sig_atomic_t received_sigterm = 0;
307 sigterm_handler(int sig)
309 received_sigterm = sig;
313 static void term_init(void)
320 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
321 |INLCR|IGNCR|ICRNL|IXON);
322 tty.c_oflag |= OPOST;
323 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
324 tty.c_cflag &= ~(CSIZE|PARENB);
329 tcsetattr (0, TCSANOW, &tty);
331 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
332 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
333 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
335 register a function to be called at normal program termination
338 #ifdef CONFIG_BEOS_NETSERVER
339 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
343 /* read a key without blocking */
344 static int read_key(void)
348 #ifndef CONFIG_BEOS_NETSERVER
356 n = select(1, &rfds, NULL, NULL, &tv);
368 static int decode_interrupt_cb(void)
370 return q_pressed || (q_pressed = read_key() == 'q');
375 static volatile int received_sigterm = 0;
377 /* no interactive support */
378 static void term_exit(void)
382 static void term_init(void)
386 static int read_key(void)
393 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
398 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
401 /* copy stream format */
402 s->nb_streams = ic->nb_streams;
403 for(i=0;i<ic->nb_streams;i++) {
406 // FIXME: a more elegant solution is needed
407 st = av_mallocz(sizeof(AVStream));
408 memcpy(st, ic->streams[i], sizeof(AVStream));
409 st->codec = avcodec_alloc_context();
410 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
414 av_close_input_file(ic);
419 get_sync_ipts(const AVOutputStream *ost)
421 const AVInputStream *ist = ost->sync_ist;
422 return (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/AV_TIME_BASE;
425 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
427 AVPacket new_pkt= *pkt;
428 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
429 &new_pkt.data, &new_pkt.size,
430 pkt->data, pkt->size,
431 pkt->flags & PKT_FLAG_KEY);
434 new_pkt.destruct= av_destruct_packet;
441 av_interleaved_write_frame(s, pkt);
444 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
446 static void do_audio_out(AVFormatContext *s,
449 unsigned char *buf, int size)
452 static uint8_t *audio_buf = NULL;
453 static uint8_t *audio_out = NULL;
454 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
456 int size_out, frame_bytes, ret;
457 AVCodecContext *enc= ost->st->codec;
459 /* SC: dynamic allocation of buffers */
461 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
463 audio_out = av_malloc(audio_out_size);
464 if (!audio_buf || !audio_out)
465 return; /* Should signal an error ! */
467 if(audio_sync_method){
468 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
469 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
470 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
471 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
473 //FIXME resample delay
474 if(fabs(delta) > 50){
477 byte_delta= FFMAX(byte_delta, -size);
481 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
486 static uint8_t *input_tmp= NULL;
487 input_tmp= av_realloc(input_tmp, byte_delta + size);
489 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
492 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
494 memset(input_tmp, 0, byte_delta);
495 memcpy(input_tmp + byte_delta, buf, size);
499 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
501 }else if(audio_sync_method>1){
502 int comp= clip(delta, -audio_sync_method, audio_sync_method);
503 assert(ost->audio_resample);
505 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
506 // fprintf(stderr, "drift:%f len:%d opts:%lld ipts:%lld 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));
507 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
511 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
512 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
514 if (ost->audio_resample) {
516 size_out = audio_resample(ost->resample,
517 (short *)buftmp, (short *)buf,
518 size / (ist->st->codec->channels * 2));
519 size_out = size_out * enc->channels * 2;
525 /* now encode as many frames as possible */
526 if (enc->frame_size > 1) {
527 /* output resampled raw samples */
528 av_fifo_write(&ost->fifo, buftmp, size_out);
530 frame_bytes = enc->frame_size * 2 * enc->channels;
532 while (av_fifo_read(&ost->fifo, audio_buf, frame_bytes) == 0) {
534 av_init_packet(&pkt);
536 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
539 pkt.stream_index= ost->index;
542 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
543 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
544 pkt.flags |= PKT_FLAG_KEY;
545 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
547 ost->sync_opts += enc->frame_size;
551 av_init_packet(&pkt);
553 ost->sync_opts += size_out / (2 * enc->channels);
555 /* output a pcm frame */
556 /* XXX: change encoding codec API to avoid this ? */
557 switch(enc->codec->id) {
558 case CODEC_ID_PCM_S32LE:
559 case CODEC_ID_PCM_S32BE:
560 case CODEC_ID_PCM_U32LE:
561 case CODEC_ID_PCM_U32BE:
562 size_out = size_out << 1;
564 case CODEC_ID_PCM_S24LE:
565 case CODEC_ID_PCM_S24BE:
566 case CODEC_ID_PCM_U24LE:
567 case CODEC_ID_PCM_U24BE:
568 case CODEC_ID_PCM_S24DAUD:
569 size_out = size_out / 2 * 3;
571 case CODEC_ID_PCM_S16LE:
572 case CODEC_ID_PCM_S16BE:
573 case CODEC_ID_PCM_U16LE:
574 case CODEC_ID_PCM_U16BE:
577 size_out = size_out >> 1;
580 ret = avcodec_encode_audio(enc, audio_out, size_out,
583 pkt.stream_index= ost->index;
586 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
587 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
588 pkt.flags |= PKT_FLAG_KEY;
589 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
593 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
597 AVPicture picture_tmp;
600 dec = ist->st->codec;
602 /* deinterlace : must be done before any resize */
603 if (do_deinterlace || using_vhook) {
606 /* create temporary picture */
607 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
608 buf = av_malloc(size);
612 picture2 = &picture_tmp;
613 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
616 if(avpicture_deinterlace(picture2, picture,
617 dec->pix_fmt, dec->width, dec->height) < 0) {
618 /* if error, do not deinterlace */
624 img_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
630 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
632 if (picture != picture2)
633 *picture = *picture2;
637 /* we begin to correct av delay at this threshold */
638 #define AV_DELAY_MAX 0.100
640 static void do_subtitle_out(AVFormatContext *s,
646 static uint8_t *subtitle_out = NULL;
647 int subtitle_out_max_size = 65536;
648 int subtitle_out_size, nb, i;
652 if (pts == AV_NOPTS_VALUE) {
653 fprintf(stderr, "Subtitle packets must have a pts\n");
657 enc = ost->st->codec;
660 subtitle_out = av_malloc(subtitle_out_max_size);
663 /* Note: DVB subtitle need one packet to draw them and one other
664 packet to clear them */
665 /* XXX: signal it in the codec context ? */
666 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
671 for(i = 0; i < nb; i++) {
672 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
673 subtitle_out_max_size, sub);
675 av_init_packet(&pkt);
676 pkt.stream_index = ost->index;
677 pkt.data = subtitle_out;
678 pkt.size = subtitle_out_size;
679 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);
680 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
681 /* XXX: the pts correction is handled here. Maybe handling
682 it in the codec would be better */
684 pkt.pts += 90 * sub->start_display_time;
686 pkt.pts += 90 * sub->end_display_time;
688 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
692 static int bit_buffer_size= 1024*256;
693 static uint8_t *bit_buffer= NULL;
695 static void do_video_out(AVFormatContext *s,
701 int nb_frames, i, ret;
702 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
703 AVFrame picture_crop_temp, picture_pad_temp;
704 uint8_t *buf = NULL, *buf1 = NULL;
705 AVCodecContext *enc, *dec;
707 avcodec_get_frame_defaults(&picture_crop_temp);
708 avcodec_get_frame_defaults(&picture_pad_temp);
710 enc = ost->st->codec;
711 dec = ist->st->codec;
713 /* by default, we output a single frame */
718 if(video_sync_method){
720 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
721 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
724 else if (vdelta > 1.1)
725 nb_frames = lrintf(vdelta);
726 //fprintf(stderr, "vdelta:%f, ost->sync_opts:%lld, ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, ost->sync_ipts, nb_frames);
730 fprintf(stderr, "*** drop!\n");
731 }else if (nb_frames > 1) {
732 nb_frames_dup += nb_frames;
734 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
737 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
739 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
743 if (ost->video_crop) {
744 if (img_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
745 av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
748 formatted_picture = &picture_crop_temp;
750 formatted_picture = in_picture;
753 final_picture = formatted_picture;
754 padding_src = formatted_picture;
755 resampling_dst = &ost->pict_tmp;
756 if (ost->video_pad) {
757 final_picture = &ost->pict_tmp;
758 if (ost->video_resample) {
759 if (img_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
760 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
763 resampling_dst = &picture_pad_temp;
767 if (ost->video_resample) {
769 final_picture = &ost->pict_tmp;
770 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
771 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
774 if (ost->video_pad) {
775 img_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
776 enc->height, enc->width, enc->pix_fmt,
777 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
780 /* duplicates frame if needed */
781 for(i=0;i<nb_frames;i++) {
783 av_init_packet(&pkt);
784 pkt.stream_index= ost->index;
786 if (s->oformat->flags & AVFMT_RAWPICTURE) {
787 /* raw pictures are written as AVPicture structure to
788 avoid any copies. We support temorarily the older
790 AVFrame* old_frame = enc->coded_frame;
791 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
792 pkt.data= (uint8_t *)final_picture;
793 pkt.size= sizeof(AVPicture);
794 if(dec->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
795 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
796 if(dec->coded_frame && dec->coded_frame->key_frame)
797 pkt.flags |= PKT_FLAG_KEY;
799 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
800 enc->coded_frame = old_frame;
804 big_picture= *final_picture;
805 /* better than nothing: use input picture interlaced
807 big_picture.interlaced_frame = in_picture->interlaced_frame;
808 if(avctx_opts->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
809 if(top_field_first == -1)
810 big_picture.top_field_first = in_picture->top_field_first;
812 big_picture.top_field_first = top_field_first;
815 /* handles sameq here. This is not correct because it may
816 not be a global option */
818 big_picture.quality = ist->st->quality;
820 big_picture.quality = ost->st->quality;
822 big_picture.pict_type = 0;
823 // big_picture.pts = AV_NOPTS_VALUE;
824 big_picture.pts= ost->sync_opts;
825 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
826 //av_log(NULL, AV_LOG_DEBUG, "%lld -> encoder\n", ost->sync_opts);
827 ret = avcodec_encode_video(enc,
828 bit_buffer, bit_buffer_size,
831 fprintf(stderr, "Video encoding failed\n");
834 //enc->frame_number = enc->real_pict_num;
836 pkt.data= bit_buffer;
838 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
839 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
840 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %lld/%lld\n",
841 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
842 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
844 if(enc->coded_frame && enc->coded_frame->key_frame)
845 pkt.flags |= PKT_FLAG_KEY;
846 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
848 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
849 // enc->frame_number-1, enc->real_pict_num, ret,
851 /* if two pass, output log */
852 if (ost->logfile && enc->stats_out) {
853 fprintf(ost->logfile, "%s", enc->stats_out);
865 static double psnr(double d){
866 if(d==0) return INFINITY;
867 return -10.0*log(d)/log(10.0);
870 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
873 static FILE *fvstats=NULL;
880 double ti1, bitrate, avg_bitrate;
884 today = localtime(&today2);
885 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
888 fvstats = fopen(filename,"w");
896 enc = ost->st->codec;
897 if (enc->codec_type == CODEC_TYPE_VIDEO) {
898 frame_number = ost->frame_number;
899 fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
900 if (enc->flags&CODEC_FLAG_PSNR)
901 fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
903 fprintf(fvstats,"f_size= %6d ", frame_size);
904 /* compute pts value */
905 ti1 = ost->sync_opts * av_q2d(enc->time_base);
909 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
910 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
911 fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
912 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
913 fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
917 static void print_report(AVFormatContext **output_files,
918 AVOutputStream **ost_table, int nb_ostreams,
923 AVFormatContext *oc, *os;
926 int frame_number, vid, i;
927 double bitrate, ti1, pts;
928 static int64_t last_time = -1;
929 static int qp_histogram[52];
931 if (!is_last_report) {
933 /* display the report every 0.5 seconds */
934 cur_time = av_gettime();
935 if (last_time == -1) {
936 last_time = cur_time;
939 if ((cur_time - last_time) < 500000)
941 last_time = cur_time;
945 oc = output_files[0];
947 total_size = url_ftell(&oc->pb);
952 for(i=0;i<nb_ostreams;i++) {
954 os = output_files[ost->file_index];
955 enc = ost->st->codec;
956 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
957 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
958 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
960 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
961 frame_number = ost->frame_number;
962 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d q=%3.1f ",
963 frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
965 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
966 if(qp_hist && enc->coded_frame){
968 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
969 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
972 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
974 if (enc->flags&CODEC_FLAG_PSNR){
976 double error, error_sum=0;
977 double scale, scale_sum=0;
978 char type[3]= {'Y','U','V'};
979 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
982 error= enc->error[j];
983 scale= enc->width*enc->height*255.0*255.0*frame_number;
985 error= enc->coded_frame->error[j];
986 scale= enc->width*enc->height*255.0*255.0;
991 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
993 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
997 /* compute min output value */
998 pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
999 if ((pts < ti1) && (pts > 0))
1005 if (verbose || is_last_report) {
1006 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1008 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1009 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1010 (double)total_size / 1024, ti1, bitrate);
1013 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1014 nb_frames_dup, nb_frames_drop);
1017 fprintf(stderr, "%s \r", buf);
1022 if (is_last_report && verbose >= 0){
1023 int64_t raw= audio_size + video_size + extra_size;
1024 fprintf(stderr, "\n");
1025 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1029 100.0*(total_size - raw)/raw
1034 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1035 static int output_packet(AVInputStream *ist, int ist_index,
1036 AVOutputStream **ost_table, int nb_ostreams,
1037 const AVPacket *pkt)
1039 AVFormatContext *os;
1040 AVOutputStream *ost;
1044 int data_size, got_picture;
1046 void *buffer_to_free;
1047 static unsigned int samples_size= 0;
1048 static short *samples= NULL;
1049 AVSubtitle subtitle, *subtitle_to_free;
1053 ist->pts= ist->next_pts; // needed for last packet if vsync=0
1054 } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1055 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1057 // assert(ist->pts == ist->next_pts);
1071 /* decode the packet if needed */
1072 data_buf = NULL; /* fail safe */
1074 subtitle_to_free = NULL;
1075 if (ist->decoding_needed) {
1076 switch(ist->st->codec->codec_type) {
1077 case CODEC_TYPE_AUDIO:{
1079 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
1080 /* XXX: could avoid copy if PCM 16 bits with same
1081 endianness as CPU */
1082 ret = avcodec_decode_audio(ist->st->codec, samples, &data_size,
1088 /* Some bug in mpeg audio decoder gives */
1089 /* data_size < 0, it seems they are overflows */
1090 if (data_size <= 0) {
1091 /* no audio frame */
1094 data_buf = (uint8_t *)samples;
1095 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1096 (ist->st->codec->sample_rate * ist->st->codec->channels);
1098 case CODEC_TYPE_VIDEO:
1099 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1100 /* XXX: allocate picture correctly */
1101 avcodec_get_frame_defaults(&picture);
1103 ret = avcodec_decode_video(ist->st->codec,
1104 &picture, &got_picture, ptr, len);
1105 ist->st->quality= picture.quality;
1109 /* no picture yet */
1110 goto discard_packet;
1112 if (ist->st->codec->time_base.num != 0) {
1113 ist->next_pts += ((int64_t)AV_TIME_BASE *
1114 ist->st->codec->time_base.num) /
1115 ist->st->codec->time_base.den;
1119 case CODEC_TYPE_SUBTITLE:
1120 ret = avcodec_decode_subtitle(ist->st->codec,
1121 &subtitle, &got_subtitle, ptr, len);
1124 if (!got_subtitle) {
1125 goto discard_packet;
1127 subtitle_to_free = &subtitle;
1134 switch(ist->st->codec->codec_type) {
1135 case CODEC_TYPE_AUDIO:
1136 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1137 (ist->st->codec->sample_rate * ist->st->codec->channels);
1139 case CODEC_TYPE_VIDEO:
1140 if (ist->st->codec->time_base.num != 0) {
1141 ist->next_pts += ((int64_t)AV_TIME_BASE *
1142 ist->st->codec->time_base.num) /
1143 ist->st->codec->time_base.den;
1153 buffer_to_free = NULL;
1154 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1155 pre_process_video_frame(ist, (AVPicture *)&picture,
1159 // preprocess audio (volume)
1160 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1161 if (audio_volume != 256) {
1164 for(i=0;i<(data_size / sizeof(short));i++) {
1165 int v = ((*volp) * audio_volume + 128) >> 8;
1166 if (v < -32768) v = -32768;
1167 if (v > 32767) v = 32767;
1173 /* frame rate emulation */
1174 if (ist->st->codec->rate_emu) {
1175 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1176 int64_t now = av_gettime() - ist->start;
1184 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1185 is the one of the next displayed one */
1186 /* XXX: add mpeg4 too ? */
1187 if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1188 if (ist->st->codec->pict_type != B_TYPE) {
1190 tmp = ist->last_ip_pts;
1191 ist->last_ip_pts = ist->frac_pts.val;
1192 ist->frac_pts.val = tmp;
1196 /* if output time reached then transcode raw format,
1197 encode packets and output them */
1198 if (start_time == 0 || ist->pts >= start_time)
1199 for(i=0;i<nb_ostreams;i++) {
1203 if (ost->source_index == ist_index) {
1204 os = output_files[ost->file_index];
1207 printf("%d: got pts=%0.3f %0.3f\n", i,
1208 (double)pkt->pts / AV_TIME_BASE,
1209 ((double)ist->pts / AV_TIME_BASE) -
1210 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1212 /* set the input output pts pairs */
1213 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1215 if (ost->encoding_needed) {
1216 switch(ost->st->codec->codec_type) {
1217 case CODEC_TYPE_AUDIO:
1218 do_audio_out(os, ost, ist, data_buf, data_size);
1220 case CODEC_TYPE_VIDEO:
1221 do_video_out(os, ost, ist, &picture, &frame_size);
1222 video_size += frame_size;
1223 if (do_vstats && frame_size)
1224 do_video_stats(os, ost, frame_size);
1226 case CODEC_TYPE_SUBTITLE:
1227 do_subtitle_out(os, ost, ist, &subtitle,
1234 AVFrame avframe; //FIXME/XXX remove this
1236 av_init_packet(&opkt);
1238 /* no reencoding needed : output the packet directly */
1239 /* force the input stream PTS */
1241 avcodec_get_frame_defaults(&avframe);
1242 ost->st->codec->coded_frame= &avframe;
1243 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1245 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1246 audio_size += data_size;
1247 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1248 video_size += data_size;
1252 opkt.stream_index= ost->index;
1253 if(pkt->pts != AV_NOPTS_VALUE)
1254 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);
1256 opkt.pts= AV_NOPTS_VALUE;
1260 if (pkt->dts == AV_NOPTS_VALUE)
1261 dts = ist->next_pts;
1263 dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1264 opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
1266 opkt.flags= pkt->flags;
1268 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1269 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1270 opkt.destruct= av_destruct_packet;
1272 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
1273 ost->st->codec->frame_number++;
1274 ost->frame_number++;
1275 av_free_packet(&opkt);
1279 av_free(buffer_to_free);
1280 /* XXX: allocate the subtitles in the codec ? */
1281 if (subtitle_to_free) {
1282 if (subtitle_to_free->rects != NULL) {
1283 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1284 av_free(subtitle_to_free->rects[i].bitmap);
1285 av_free(subtitle_to_free->rects[i].rgba_palette);
1287 av_freep(&subtitle_to_free->rects);
1289 subtitle_to_free->num_rects = 0;
1290 subtitle_to_free = NULL;
1297 for(i=0;i<nb_ostreams;i++) {
1299 if (ost->source_index == ist_index) {
1300 AVCodecContext *enc= ost->st->codec;
1301 os = output_files[ost->file_index];
1303 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1305 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1308 if (ost->encoding_needed) {
1312 av_init_packet(&pkt);
1313 pkt.stream_index= ost->index;
1315 switch(ost->st->codec->codec_type) {
1316 case CODEC_TYPE_AUDIO:
1317 fifo_bytes = av_fifo_size(&ost->fifo);
1319 /* encode any samples remaining in fifo */
1320 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1321 int fs_tmp = enc->frame_size;
1322 enc->frame_size = fifo_bytes / (2 * enc->channels);
1323 if(av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes) == 0) {
1324 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1326 enc->frame_size = fs_tmp;
1329 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1332 pkt.flags |= PKT_FLAG_KEY;
1334 case CODEC_TYPE_VIDEO:
1335 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1337 if(enc->coded_frame && enc->coded_frame->key_frame)
1338 pkt.flags |= PKT_FLAG_KEY;
1339 if (ost->logfile && enc->stats_out) {
1340 fprintf(ost->logfile, "%s", enc->stats_out);
1349 pkt.data= bit_buffer;
1351 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1352 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1353 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1367 * The following code is the main loop of the file converter
1369 static int av_encode(AVFormatContext **output_files,
1370 int nb_output_files,
1371 AVFormatContext **input_files,
1373 AVStreamMap *stream_maps, int nb_stream_maps)
1375 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1376 AVFormatContext *is, *os;
1377 AVCodecContext *codec, *icodec;
1378 AVOutputStream *ost, **ost_table = NULL;
1379 AVInputStream *ist, **ist_table = NULL;
1380 AVInputFile *file_table;
1381 AVFormatContext *stream_no_data;
1384 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1388 /* input stream init */
1390 for(i=0;i<nb_input_files;i++) {
1391 is = input_files[i];
1392 file_table[i].ist_index = j;
1393 file_table[i].nb_streams = is->nb_streams;
1394 j += is->nb_streams;
1398 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1402 for(i=0;i<nb_istreams;i++) {
1403 ist = av_mallocz(sizeof(AVInputStream));
1409 for(i=0;i<nb_input_files;i++) {
1410 is = input_files[i];
1411 for(k=0;k<is->nb_streams;k++) {
1412 ist = ist_table[j++];
1413 ist->st = is->streams[k];
1414 ist->file_index = i;
1416 ist->discard = 1; /* the stream is discarded by default
1419 if (ist->st->codec->rate_emu) {
1420 ist->start = av_gettime();
1426 /* output stream init */
1428 for(i=0;i<nb_output_files;i++) {
1429 os = output_files[i];
1430 nb_ostreams += os->nb_streams;
1432 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1433 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1437 /* Sanity check the mapping args -- do the input files & streams exist? */
1438 for(i=0;i<nb_stream_maps;i++) {
1439 int fi = stream_maps[i].file_index;
1440 int si = stream_maps[i].stream_index;
1442 if (fi < 0 || fi > nb_input_files - 1 ||
1443 si < 0 || si > file_table[fi].nb_streams - 1) {
1444 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1447 fi = stream_maps[i].sync_file_index;
1448 si = stream_maps[i].sync_stream_index;
1449 if (fi < 0 || fi > nb_input_files - 1 ||
1450 si < 0 || si > file_table[fi].nb_streams - 1) {
1451 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1456 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1459 for(i=0;i<nb_ostreams;i++) {
1460 ost = av_mallocz(sizeof(AVOutputStream));
1467 for(k=0;k<nb_output_files;k++) {
1468 os = output_files[k];
1469 for(i=0;i<os->nb_streams;i++) {
1471 ost = ost_table[n++];
1472 ost->file_index = k;
1474 ost->st = os->streams[i];
1475 if (nb_stream_maps > 0) {
1476 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1477 stream_maps[n-1].stream_index;
1479 /* Sanity check that the stream types match */
1480 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1481 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1482 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1483 ost->file_index, ost->index);
1488 /* get corresponding input stream index : we select the first one with the right type */
1490 for(j=0;j<nb_istreams;j++) {
1493 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1494 ost->source_index = j;
1501 /* try again and reuse existing stream */
1502 for(j=0;j<nb_istreams;j++) {
1504 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1505 ost->source_index = j;
1510 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1511 ost->file_index, ost->index);
1516 ist = ist_table[ost->source_index];
1518 ost->sync_ist = (nb_stream_maps > 0) ?
1519 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1520 stream_maps[n-1].sync_stream_index] : ist;
1524 /* for each output stream, we compute the right encoding parameters */
1525 for(i=0;i<nb_ostreams;i++) {
1527 ist = ist_table[ost->source_index];
1529 codec = ost->st->codec;
1530 icodec = ist->st->codec;
1532 if (ost->st->stream_copy) {
1533 /* if stream_copy is selected, no need to decode or encode */
1534 codec->codec_id = icodec->codec_id;
1535 codec->codec_type = icodec->codec_type;
1536 if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1537 codec->bit_rate = icodec->bit_rate;
1538 codec->extradata= icodec->extradata;
1539 codec->extradata_size= icodec->extradata_size;
1540 codec->time_base = icodec->time_base;
1541 switch(codec->codec_type) {
1542 case CODEC_TYPE_AUDIO:
1543 codec->sample_rate = icodec->sample_rate;
1544 codec->channels = icodec->channels;
1545 codec->frame_size = icodec->frame_size;
1546 codec->block_align= icodec->block_align;
1548 case CODEC_TYPE_VIDEO:
1549 codec->pix_fmt = icodec->pix_fmt;
1550 codec->width = icodec->width;
1551 codec->height = icodec->height;
1552 codec->has_b_frames = icodec->has_b_frames;
1554 case CODEC_TYPE_SUBTITLE:
1560 switch(codec->codec_type) {
1561 case CODEC_TYPE_AUDIO:
1562 if (av_fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1565 if (codec->channels == icodec->channels &&
1566 codec->sample_rate == icodec->sample_rate) {
1567 ost->audio_resample = 0;
1569 if (codec->channels != icodec->channels &&
1570 (icodec->codec_id == CODEC_ID_AC3 ||
1571 icodec->codec_id == CODEC_ID_DTS)) {
1572 /* Special case for 5:1 AC3 and DTS input */
1573 /* and mono or stereo output */
1574 /* Request specific number of channels */
1575 icodec->channels = codec->channels;
1576 if (codec->sample_rate == icodec->sample_rate)
1577 ost->audio_resample = 0;
1579 ost->audio_resample = 1;
1582 ost->audio_resample = 1;
1585 if(audio_sync_method>1)
1586 ost->audio_resample = 1;
1588 if(ost->audio_resample){
1589 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1590 codec->sample_rate, icodec->sample_rate);
1592 printf("Can't resample. Aborting.\n");
1596 ist->decoding_needed = 1;
1597 ost->encoding_needed = 1;
1599 case CODEC_TYPE_VIDEO:
1600 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1601 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1602 ost->video_resample = ((codec->width != icodec->width -
1603 (frame_leftBand + frame_rightBand) +
1604 (frame_padleft + frame_padright)) ||
1605 (codec->height != icodec->height -
1606 (frame_topBand + frame_bottomBand) +
1607 (frame_padtop + frame_padbottom)) ||
1608 (codec->pix_fmt != icodec->pix_fmt));
1609 if (ost->video_crop) {
1610 ost->topBand = frame_topBand;
1611 ost->leftBand = frame_leftBand;
1613 if (ost->video_pad) {
1614 ost->padtop = frame_padtop;
1615 ost->padleft = frame_padleft;
1616 ost->padbottom = frame_padbottom;
1617 ost->padright = frame_padright;
1618 if (!ost->video_resample) {
1619 avcodec_get_frame_defaults(&ost->pict_tmp);
1620 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1621 codec->width, codec->height ) )
1625 if (ost->video_resample) {
1626 avcodec_get_frame_defaults(&ost->pict_tmp);
1627 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1628 codec->width, codec->height ) )
1631 ost->img_resample_ctx = sws_getContext(
1632 icodec->width - (frame_leftBand + frame_rightBand),
1633 icodec->height - (frame_topBand + frame_bottomBand),
1635 codec->width - (frame_padleft + frame_padright),
1636 codec->height - (frame_padtop + frame_padbottom),
1638 sws_flags, NULL, NULL, NULL);
1639 if (ost->img_resample_ctx == NULL) {
1640 fprintf(stderr, "Cannot get resampling context\n");
1643 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1645 ost->encoding_needed = 1;
1646 ist->decoding_needed = 1;
1648 case CODEC_TYPE_SUBTITLE:
1649 ost->encoding_needed = 1;
1650 ist->decoding_needed = 1;
1657 if (ost->encoding_needed &&
1658 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1659 char logfilename[1024];
1664 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1666 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1667 if (codec->flags & CODEC_FLAG_PASS1) {
1668 f = fopen(logfilename, "w");
1670 perror(logfilename);
1675 /* read the log file */
1676 f = fopen(logfilename, "r");
1678 perror(logfilename);
1681 fseek(f, 0, SEEK_END);
1683 fseek(f, 0, SEEK_SET);
1684 logbuffer = av_malloc(size + 1);
1686 fprintf(stderr, "Could not allocate log buffer\n");
1689 size = fread(logbuffer, 1, size, f);
1691 logbuffer[size] = '\0';
1692 codec->stats_in = logbuffer;
1696 if(codec->codec_type == CODEC_TYPE_VIDEO){
1697 int size= codec->width * codec->height;
1698 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1703 bit_buffer = av_malloc(bit_buffer_size);
1707 /* dump the file output parameters - cannot be done before in case
1709 for(i=0;i<nb_output_files;i++) {
1710 dump_format(output_files[i], i, output_files[i]->filename, 1);
1713 /* dump the stream mapping */
1715 fprintf(stderr, "Stream mapping:\n");
1716 for(i=0;i<nb_ostreams;i++) {
1718 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1719 ist_table[ost->source_index]->file_index,
1720 ist_table[ost->source_index]->index,
1723 if (ost->sync_ist != ist_table[ost->source_index])
1724 fprintf(stderr, " [sync #%d.%d]",
1725 ost->sync_ist->file_index,
1726 ost->sync_ist->index);
1727 fprintf(stderr, "\n");
1731 /* open each encoder */
1732 for(i=0;i<nb_ostreams;i++) {
1734 if (ost->encoding_needed) {
1736 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1738 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1739 ost->file_index, ost->index);
1742 if (avcodec_open(ost->st->codec, codec) < 0) {
1743 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1744 ost->file_index, ost->index);
1747 extra_size += ost->st->codec->extradata_size;
1751 /* open each decoder */
1752 for(i=0;i<nb_istreams;i++) {
1754 if (ist->decoding_needed) {
1756 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1758 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1759 ist->st->codec->codec_id, ist->file_index, ist->index);
1762 if (avcodec_open(ist->st->codec, codec) < 0) {
1763 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1764 ist->file_index, ist->index);
1767 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1768 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1773 for(i=0;i<nb_istreams;i++) {
1775 is = input_files[ist->file_index];
1777 ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1778 if(ist->st->start_time == AV_NOPTS_VALUE)
1780 if(input_files_ts_offset[ist->file_index])
1781 ist->next_pts= AV_NOPTS_VALUE;
1785 /* compute buffer size max (should use a complete heuristic) */
1786 for(i=0;i<nb_input_files;i++) {
1787 file_table[i].buffer_size_max = 2048;
1790 /* set meta data information from input file if required */
1791 for (i=0;i<nb_meta_data_maps;i++) {
1792 AVFormatContext *out_file;
1793 AVFormatContext *in_file;
1795 int out_file_index = meta_data_maps[i].out_file;
1796 int in_file_index = meta_data_maps[i].in_file;
1797 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1798 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1802 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1803 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1808 out_file = output_files[out_file_index];
1809 in_file = input_files[in_file_index];
1811 strcpy(out_file->title, in_file->title);
1812 strcpy(out_file->author, in_file->author);
1813 strcpy(out_file->copyright, in_file->copyright);
1814 strcpy(out_file->comment, in_file->comment);
1815 strcpy(out_file->album, in_file->album);
1816 out_file->year = in_file->year;
1817 out_file->track = in_file->track;
1818 strcpy(out_file->genre, in_file->genre);
1821 /* open files and write file headers */
1822 for(i=0;i<nb_output_files;i++) {
1823 os = output_files[i];
1824 if (av_write_header(os) < 0) {
1825 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1832 if ( !using_stdin && verbose >= 0) {
1833 fprintf(stderr, "Press [q] to stop encoding\n");
1834 url_set_interrupt_cb(decode_interrupt_cb);
1842 for(; received_sigterm == 0;) {
1843 int file_index, ist_index;
1851 /* if 'q' pressed, exits */
1855 /* read_key() returns 0 on EOF */
1861 /* select the stream that we must read now by looking at the
1862 smallest output pts */
1864 for(i=0;i<nb_ostreams;i++) {
1867 os = output_files[ost->file_index];
1868 ist = ist_table[ost->source_index];
1869 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1870 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1872 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1873 ipts = (double)ist->pts;
1874 if (!file_table[ist->file_index].eof_reached){
1875 if(ipts < ipts_min) {
1877 if(input_sync ) file_index = ist->file_index;
1879 if(opts < opts_min) {
1881 if(!input_sync) file_index = ist->file_index;
1884 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1889 /* if none, if is finished */
1890 if (file_index < 0) {
1894 /* finish if recording time exhausted */
1895 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1898 /* finish if limit size exhausted */
1899 if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
1902 /* read a frame from it and output it in the fifo */
1903 is = input_files[file_index];
1904 if (av_read_frame(is, &pkt) < 0) {
1905 file_table[file_index].eof_reached = 1;
1906 if (opt_shortest) break; else continue; //
1910 stream_no_data = is;
1915 av_pkt_dump(stdout, &pkt, do_hex_dump);
1917 /* the following test is needed in case new streams appear
1918 dynamically in stream : we ignore them */
1919 if (pkt.stream_index >= file_table[file_index].nb_streams)
1920 goto discard_packet;
1921 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1922 ist = ist_table[ist_index];
1924 goto discard_packet;
1926 // fprintf(stderr, "next:%lld dts:%lld off:%lld %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec->codec_type);
1927 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1928 int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
1929 if(ABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
1930 input_files_ts_offset[ist->file_index]-= delta;
1932 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1933 for(i=0; i<file_table[file_index].nb_streams; i++){
1934 int index= file_table[file_index].ist_index + i;
1935 ist_table[index]->next_pts += delta;
1936 ist_table[index]->is_start=1;
1941 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1942 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1945 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1946 ist->file_index, ist->index);
1948 av_free_packet(&pkt);
1953 av_free_packet(&pkt);
1955 /* dump report by using the output first video and audio streams */
1956 print_report(output_files, ost_table, nb_ostreams, 0);
1959 /* at the end of stream, we must flush the decoder buffers */
1960 for(i=0;i<nb_istreams;i++) {
1962 if (ist->decoding_needed) {
1963 output_packet(ist, i, ost_table, nb_ostreams, NULL);
1969 /* write the trailer if needed and close file */
1970 for(i=0;i<nb_output_files;i++) {
1971 os = output_files[i];
1972 av_write_trailer(os);
1975 /* dump report by using the first video and audio streams */
1976 print_report(output_files, ost_table, nb_ostreams, 1);
1978 /* close each encoder */
1979 for(i=0;i<nb_ostreams;i++) {
1981 if (ost->encoding_needed) {
1982 av_freep(&ost->st->codec->stats_in);
1983 avcodec_close(ost->st->codec);
1987 /* close each decoder */
1988 for(i=0;i<nb_istreams;i++) {
1990 if (ist->decoding_needed) {
1991 avcodec_close(ist->st->codec);
1999 av_freep(&bit_buffer);
2000 av_free(file_table);
2003 for(i=0;i<nb_istreams;i++) {
2010 for(i=0;i<nb_ostreams;i++) {
2014 fclose(ost->logfile);
2015 ost->logfile = NULL;
2017 av_fifo_free(&ost->fifo); /* works even if fifo is not
2018 initialized but set to zero */
2019 av_free(ost->pict_tmp.data[0]);
2020 if (ost->video_resample)
2021 sws_freeContext(ost->img_resample_ctx);
2022 if (ost->audio_resample)
2023 audio_resample_close(ost->resample);
2036 int file_read(const char *filename)
2039 unsigned char buffer[1024];
2042 if (url_open(&h, filename, O_RDONLY) < 0) {
2043 printf("could not open '%s'\n", filename);
2047 len = url_read(h, buffer, sizeof(buffer));
2050 for(i=0;i<len;i++) putchar(buffer[i]);
2057 static void opt_image_format(const char *arg)
2061 for(f = first_image_format; f != NULL; f = f->next) {
2062 if (!strcmp(arg, f->name))
2066 fprintf(stderr, "Unknown image format: '%s'\n", arg);
2072 static void opt_format(const char *arg)
2074 /* compatibility stuff for pgmyuv */
2075 if (!strcmp(arg, "pgmyuv")) {
2076 pgmyuv_compatibility_hack=1;
2077 // opt_image_format(arg);
2081 file_iformat = av_find_input_format(arg);
2082 file_oformat = guess_format(arg, NULL, NULL);
2083 if (!file_iformat && !file_oformat) {
2084 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2089 static void opt_video_rc_eq(char *arg)
2094 static void opt_video_rc_override_string(char *arg)
2096 video_rc_override_string = arg;
2099 static void opt_me_threshold(const char *arg)
2101 me_threshold = atoi(arg);
2104 static void opt_verbose(const char *arg)
2106 verbose = atoi(arg);
2107 av_log_set_level(atoi(arg));
2110 static void opt_frame_rate(const char *arg)
2112 if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2113 fprintf(stderr, "Incorrect frame rate\n");
2118 static void opt_frame_crop_top(const char *arg)
2120 frame_topBand = atoi(arg);
2121 if (frame_topBand < 0) {
2122 fprintf(stderr, "Incorrect top crop size\n");
2125 if ((frame_topBand % 2) != 0) {
2126 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2129 if ((frame_topBand) >= frame_height){
2130 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2133 frame_height -= frame_topBand;
2136 static void opt_frame_crop_bottom(const char *arg)
2138 frame_bottomBand = atoi(arg);
2139 if (frame_bottomBand < 0) {
2140 fprintf(stderr, "Incorrect bottom crop size\n");
2143 if ((frame_bottomBand % 2) != 0) {
2144 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2147 if ((frame_bottomBand) >= frame_height){
2148 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2151 frame_height -= frame_bottomBand;
2154 static void opt_frame_crop_left(const char *arg)
2156 frame_leftBand = atoi(arg);
2157 if (frame_leftBand < 0) {
2158 fprintf(stderr, "Incorrect left crop size\n");
2161 if ((frame_leftBand % 2) != 0) {
2162 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2165 if ((frame_leftBand) >= frame_width){
2166 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2169 frame_width -= frame_leftBand;
2172 static void opt_frame_crop_right(const char *arg)
2174 frame_rightBand = atoi(arg);
2175 if (frame_rightBand < 0) {
2176 fprintf(stderr, "Incorrect right crop size\n");
2179 if ((frame_rightBand % 2) != 0) {
2180 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2183 if ((frame_rightBand) >= frame_width){
2184 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2187 frame_width -= frame_rightBand;
2190 static void opt_frame_size(const char *arg)
2192 if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2193 fprintf(stderr, "Incorrect frame size\n");
2196 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2197 fprintf(stderr, "Frame size must be a multiple of 2\n");
2203 #define SCALEBITS 10
2204 #define ONE_HALF (1 << (SCALEBITS - 1))
2205 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2207 #define RGB_TO_Y(r, g, b) \
2208 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2209 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2211 #define RGB_TO_U(r1, g1, b1, shift)\
2212 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2213 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2215 #define RGB_TO_V(r1, g1, b1, shift)\
2216 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2217 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2219 static void opt_pad_color(const char *arg) {
2220 /* Input is expected to be six hex digits similar to
2221 how colors are expressed in html tags (but without the #) */
2222 int rgb = strtol(arg, NULL, 16);
2226 g = ((rgb >> 8) & 255);
2229 padcolor[0] = RGB_TO_Y(r,g,b);
2230 padcolor[1] = RGB_TO_U(r,g,b,0);
2231 padcolor[2] = RGB_TO_V(r,g,b,0);
2234 static void opt_frame_pad_top(const char *arg)
2236 frame_padtop = atoi(arg);
2237 if (frame_padtop < 0) {
2238 fprintf(stderr, "Incorrect top pad size\n");
2241 if ((frame_padtop % 2) != 0) {
2242 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2247 static void opt_frame_pad_bottom(const char *arg)
2249 frame_padbottom = atoi(arg);
2250 if (frame_padbottom < 0) {
2251 fprintf(stderr, "Incorrect bottom pad size\n");
2254 if ((frame_padbottom % 2) != 0) {
2255 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2261 static void opt_frame_pad_left(const char *arg)
2263 frame_padleft = atoi(arg);
2264 if (frame_padleft < 0) {
2265 fprintf(stderr, "Incorrect left pad size\n");
2268 if ((frame_padleft % 2) != 0) {
2269 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2275 static void opt_frame_pad_right(const char *arg)
2277 frame_padright = atoi(arg);
2278 if (frame_padright < 0) {
2279 fprintf(stderr, "Incorrect right pad size\n");
2282 if ((frame_padright % 2) != 0) {
2283 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2289 static void opt_frame_pix_fmt(const char *arg)
2291 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2294 static void opt_frame_aspect_ratio(const char *arg)
2300 p = strchr(arg, ':');
2302 x = strtol(arg, (char **)&arg, 10);
2304 y = strtol(arg+1, (char **)&arg, 10);
2306 ar = (double)x / (double)y;
2308 ar = strtod(arg, (char **)&arg);
2311 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2314 frame_aspect_ratio = ar;
2317 static void opt_qscale(const char *arg)
2319 video_qscale = atof(arg);
2320 if (video_qscale <= 0 ||
2321 video_qscale > 255) {
2322 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2327 static void opt_lmax(const char *arg)
2329 video_lmax = atof(arg)*FF_QP2LAMBDA;
2332 static void opt_lmin(const char *arg)
2334 video_lmin = atof(arg)*FF_QP2LAMBDA;
2337 static void opt_mb_lmin(const char *arg)
2339 video_mb_lmin = atof(arg)*FF_QP2LAMBDA;
2340 if (video_mb_lmin < 1 ||
2341 video_mb_lmin > FF_LAMBDA_MAX) {
2342 fprintf(stderr, "mblmin must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2347 static void opt_mb_lmax(const char *arg)
2349 video_mb_lmax = atof(arg)*FF_QP2LAMBDA;
2350 if (video_mb_lmax < 1 ||
2351 video_mb_lmax > FF_LAMBDA_MAX) {
2352 fprintf(stderr, "mblmax must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2357 static void opt_qdiff(const char *arg)
2359 video_qdiff = atoi(arg);
2360 if (video_qdiff < 0 ||
2362 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2367 static void opt_packet_size(const char *arg)
2369 packet_size= atoi(arg);
2372 static void opt_strict(const char *arg)
2377 static void opt_top_field_first(const char *arg)
2379 top_field_first= atoi(arg);
2382 static void opt_thread_count(const char *arg)
2384 thread_count= atoi(arg);
2385 #if !defined(HAVE_THREADS)
2387 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2391 static void opt_audio_bitrate(const char *arg)
2393 audio_bit_rate = atoi(arg) * 1000;
2396 static void opt_audio_rate(const char *arg)
2398 audio_sample_rate = atoi(arg);
2401 static void opt_audio_channels(const char *arg)
2403 audio_channels = atoi(arg);
2406 static void opt_video_device(const char *arg)
2408 video_device = av_strdup(arg);
2411 static void opt_grab_device(const char *arg)
2413 grab_device = av_strdup(arg);
2416 static void opt_video_channel(const char *arg)
2418 video_channel = strtol(arg, NULL, 0);
2421 static void opt_video_standard(const char *arg)
2423 video_standard = av_strdup(arg);
2426 static void opt_audio_device(const char *arg)
2428 audio_device = av_strdup(arg);
2431 static void opt_codec(int *pstream_copy, int *pcodec_id,
2432 int codec_type, const char *arg)
2436 if (!strcmp(arg, "copy")) {
2441 if (!strcmp(p->name, arg) && p->type == codec_type)
2446 fprintf(stderr, "Unknown codec '%s'\n", arg);
2454 static void opt_audio_codec(const char *arg)
2456 opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2459 static void opt_audio_tag(const char *arg)
2462 audio_codec_tag= strtol(arg, &tail, 0);
2465 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2468 static void opt_video_tag(const char *arg)
2471 video_codec_tag= strtol(arg, &tail, 0);
2474 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2477 static void add_frame_hooker(const char *arg)
2482 char *args = av_strdup(arg);
2486 argv[0] = strtok(args, " ");
2487 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2490 i = frame_hook_add(argc, argv);
2493 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2498 const char *motion_str[] = {
2511 static void opt_motion_estimation(const char *arg)
2517 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2520 if (!strcmp(*p, arg))
2524 me_method = (p - motion_str) + 1;
2527 static void opt_video_codec(const char *arg)
2529 opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2532 static void opt_subtitle_codec(const char *arg)
2534 opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2537 static void opt_map(const char *arg)
2543 m = &stream_maps[nb_stream_maps++];
2545 m->file_index = strtol(arg, (char **)&p, 0);
2549 m->stream_index = strtol(p, (char **)&p, 0);
2552 m->sync_file_index = strtol(p, (char **)&p, 0);
2555 m->sync_stream_index = strtol(p, (char **)&p, 0);
2557 m->sync_file_index = m->file_index;
2558 m->sync_stream_index = m->stream_index;
2562 static void opt_map_meta_data(const char *arg)
2568 m = &meta_data_maps[nb_meta_data_maps++];
2570 m->out_file = strtol(arg, (char **)&p, 0);
2574 m->in_file = strtol(p, (char **)&p, 0);
2577 static void opt_recording_time(const char *arg)
2579 recording_time = parse_date(arg, 1);
2582 static void opt_start_time(const char *arg)
2584 start_time = parse_date(arg, 1);
2587 static void opt_rec_timestamp(const char *arg)
2589 rec_timestamp = parse_date(arg, 0) / 1000000;
2592 static void opt_input_ts_offset(const char *arg)
2594 input_ts_offset = parse_date(arg, 1);
2597 static void opt_input_file(const char *filename)
2599 AVFormatContext *ic;
2600 AVFormatParameters params, *ap = ¶ms;
2601 int err, i, ret, rfps, rfps_base;
2604 if (!strcmp(filename, "-"))
2607 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2608 !strcmp( filename, "/dev/stdin" );
2610 /* get default parameters from command line */
2611 ic = av_alloc_format_context();
2613 memset(ap, 0, sizeof(*ap));
2614 ap->prealloced_context = 1;
2615 ap->sample_rate = audio_sample_rate;
2616 ap->channels = audio_channels;
2617 ap->time_base.den = frame_rate;
2618 ap->time_base.num = frame_rate_base;
2619 ap->width = frame_width + frame_padleft + frame_padright;
2620 ap->height = frame_height + frame_padtop + frame_padbottom;
2621 ap->image_format = image_format;
2622 ap->pix_fmt = frame_pix_fmt;
2623 ap->device = grab_device;
2624 ap->channel = video_channel;
2625 ap->standard = video_standard;
2626 ap->video_codec_id = video_codec_id;
2627 ap->audio_codec_id = audio_codec_id;
2628 if(pgmyuv_compatibility_hack)
2629 ap->video_codec_id= CODEC_ID_PGMYUV;
2631 for(i=0; i<opt_name_count; i++){
2633 double d= av_get_double(avformat_opts, opt_names[i], &opt);
2634 if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2635 av_set_double(ic, opt_names[i], d);
2637 /* open the input file with generic libav function */
2638 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2640 print_error(filename, err);
2644 ic->loop_input = loop_input;
2646 /* If not enough info to get the stream parameters, we decode the
2647 first frames to get it. (used in mpeg case for example) */
2648 ret = av_find_stream_info(ic);
2649 if (ret < 0 && verbose >= 0) {
2650 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2654 timestamp = start_time;
2655 /* add the stream start time */
2656 if (ic->start_time != AV_NOPTS_VALUE)
2657 timestamp += ic->start_time;
2659 /* if seeking requested, we execute it */
2660 if (start_time != 0) {
2661 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2663 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2664 filename, (double)timestamp / AV_TIME_BASE);
2666 /* reset seek info */
2670 /* update the current parameters so that they match the one of the input stream */
2671 for(i=0;i<ic->nb_streams;i++) {
2673 AVCodecContext *enc = ic->streams[i]->codec;
2674 #if defined(HAVE_THREADS)
2676 avcodec_thread_init(enc, thread_count);
2678 enc->thread_count= thread_count;
2679 switch(enc->codec_type) {
2680 case CODEC_TYPE_AUDIO:
2681 for(j=0; j<opt_name_count; j++){
2683 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2684 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2685 av_set_double(enc, opt_names[j], d);
2687 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2688 audio_channels = enc->channels;
2689 audio_sample_rate = enc->sample_rate;
2691 ic->streams[i]->discard= AVDISCARD_ALL;
2693 case CODEC_TYPE_VIDEO:
2694 for(j=0; j<opt_name_count; j++){
2696 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2697 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2698 av_set_double(enc, opt_names[j], d);
2700 frame_height = enc->height;
2701 frame_width = enc->width;
2702 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2703 frame_pix_fmt = enc->pix_fmt;
2704 rfps = ic->streams[i]->r_frame_rate.num;
2705 rfps_base = ic->streams[i]->r_frame_rate.den;
2706 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2708 enc->debug |= FF_DEBUG_MV;
2710 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2713 fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2714 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2716 (float)rfps / rfps_base, rfps, rfps_base);
2718 /* update the current frame rate to match the stream frame rate */
2720 frame_rate_base = rfps_base;
2722 enc->rate_emu = rate_emu;
2724 ic->streams[i]->discard= AVDISCARD_ALL;
2725 else if(video_discard)
2726 ic->streams[i]->discard= video_discard;
2728 case CODEC_TYPE_DATA:
2730 case CODEC_TYPE_SUBTITLE:
2732 case CODEC_TYPE_UNKNOWN:
2739 input_files[nb_input_files] = ic;
2740 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2741 /* dump the file content */
2743 dump_format(ic, nb_input_files, filename, 0);
2746 file_iformat = NULL;
2747 file_oformat = NULL;
2748 image_format = NULL;
2756 static void opt_grab(const char *arg)
2758 file_iformat = av_find_input_format(arg);
2762 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2764 int has_video, has_audio, i, j;
2765 AVFormatContext *ic;
2769 for(j=0;j<nb_input_files;j++) {
2770 ic = input_files[j];
2771 for(i=0;i<ic->nb_streams;i++) {
2772 AVCodecContext *enc = ic->streams[i]->codec;
2773 switch(enc->codec_type) {
2774 case CODEC_TYPE_AUDIO:
2777 case CODEC_TYPE_VIDEO:
2780 case CODEC_TYPE_DATA:
2781 case CODEC_TYPE_UNKNOWN:
2782 case CODEC_TYPE_SUBTITLE:
2789 *has_video_ptr = has_video;
2790 *has_audio_ptr = has_audio;
2793 static void new_video_stream(AVFormatContext *oc)
2796 AVCodecContext *video_enc;
2799 st = av_new_stream(oc, oc->nb_streams);
2801 fprintf(stderr, "Could not alloc stream\n");
2804 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2805 video_bitstream_filters= NULL;
2807 #if defined(HAVE_THREADS)
2809 avcodec_thread_init(st->codec, thread_count);
2812 video_enc = st->codec;
2815 video_enc->codec_tag= video_codec_tag;
2817 if( (video_global_header&1)
2818 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2819 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2820 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2822 if(video_global_header&2){
2823 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2824 avctx_opts->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2827 if (video_stream_copy) {
2828 st->stream_copy = 1;
2829 video_enc->codec_type = CODEC_TYPE_VIDEO;
2835 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2836 if (video_codec_id != CODEC_ID_NONE)
2837 codec_id = video_codec_id;
2839 video_enc->codec_id = codec_id;
2840 codec = avcodec_find_encoder(codec_id);
2842 for(i=0; i<opt_name_count; i++){
2844 double d= av_get_double(avctx_opts, opt_names[i], &opt);
2845 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2846 av_set_double(video_enc, opt_names[i], d);
2849 video_enc->time_base.den = frame_rate;
2850 video_enc->time_base.num = frame_rate_base;
2851 if(codec && codec->supported_framerates){
2852 const AVRational *p= codec->supported_framerates;
2853 AVRational req= (AVRational){frame_rate, frame_rate_base};
2854 const AVRational *best=NULL;
2855 AVRational best_error= (AVRational){INT_MAX, 1};
2856 for(; p->den!=0; p++){
2857 AVRational error= av_sub_q(req, *p);
2858 if(error.num <0) error.num *= -1;
2859 if(av_cmp_q(error, best_error) < 0){
2864 video_enc->time_base.den= best->num;
2865 video_enc->time_base.num= best->den;
2868 video_enc->width = frame_width + frame_padright + frame_padleft;
2869 video_enc->height = frame_height + frame_padtop + frame_padbottom;
2870 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2871 video_enc->pix_fmt = frame_pix_fmt;
2873 if(codec && codec->pix_fmts){
2874 const enum PixelFormat *p= codec->pix_fmts;
2876 if(*p == video_enc->pix_fmt)
2880 video_enc->pix_fmt = codec->pix_fmts[0];
2884 video_enc->gop_size = 0;
2885 if (video_qscale || same_quality) {
2886 video_enc->flags |= CODEC_FLAG_QSCALE;
2887 video_enc->global_quality=
2888 st->quality = FF_QP2LAMBDA * video_qscale;
2892 video_enc->intra_matrix = intra_matrix;
2894 video_enc->inter_matrix = inter_matrix;
2896 video_enc->lmin = video_lmin;
2897 video_enc->lmax = video_lmax;
2898 video_enc->mb_lmin = video_mb_lmin;
2899 video_enc->mb_lmax = video_mb_lmax;
2900 video_enc->max_qdiff = video_qdiff;
2901 video_enc->rc_eq = video_rc_eq;
2902 video_enc->thread_count = thread_count;
2903 p= video_rc_override_string;
2906 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2908 fprintf(stderr, "error parsing rc_override\n");
2911 video_enc->rc_override=
2912 av_realloc(video_enc->rc_override,
2913 sizeof(RcOverride)*(i+1));
2914 video_enc->rc_override[i].start_frame= start;
2915 video_enc->rc_override[i].end_frame = end;
2917 video_enc->rc_override[i].qscale= q;
2918 video_enc->rc_override[i].quality_factor= 1.0;
2921 video_enc->rc_override[i].qscale= 0;
2922 video_enc->rc_override[i].quality_factor= -q/100.0;
2927 video_enc->rc_override_count=i;
2928 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2929 video_enc->me_threshold= me_threshold;
2930 video_enc->intra_dc_precision= intra_dc_precision - 8;
2931 video_enc->strict_std_compliance = strict;
2934 video_enc->rtp_mode= 1;
2935 video_enc->rtp_payload_size= packet_size;
2939 video_enc->flags|= CODEC_FLAG_PSNR;
2941 video_enc->me_method = me_method;
2946 video_enc->flags |= CODEC_FLAG_PASS1;
2948 video_enc->flags |= CODEC_FLAG_PASS2;
2953 /* reset some key parameters */
2955 video_codec_id = CODEC_ID_NONE;
2956 video_stream_copy = 0;
2959 static void new_audio_stream(AVFormatContext *oc)
2962 AVCodecContext *audio_enc;
2965 st = av_new_stream(oc, oc->nb_streams);
2967 fprintf(stderr, "Could not alloc stream\n");
2971 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2972 audio_bitstream_filters= NULL;
2974 #if defined(HAVE_THREADS)
2976 avcodec_thread_init(st->codec, thread_count);
2979 audio_enc = st->codec;
2980 audio_enc->codec_type = CODEC_TYPE_AUDIO;
2983 audio_enc->codec_tag= audio_codec_tag;
2985 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
2986 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2987 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2989 if (audio_stream_copy) {
2990 st->stream_copy = 1;
2991 audio_enc->channels = audio_channels;
2993 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
2995 for(i=0; i<opt_name_count; i++){
2997 double d= av_get_double(avctx_opts, opt_names[i], &opt);
2998 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2999 av_set_double(audio_enc, opt_names[i], d);
3002 if (audio_codec_id != CODEC_ID_NONE)
3003 codec_id = audio_codec_id;
3004 audio_enc->codec_id = codec_id;
3006 audio_enc->bit_rate = audio_bit_rate;
3007 if (audio_qscale > QSCALE_NONE) {
3008 audio_enc->flags |= CODEC_FLAG_QSCALE;
3009 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3011 audio_enc->strict_std_compliance = strict;
3012 audio_enc->thread_count = thread_count;
3013 /* For audio codecs other than AC3 or DTS we limit */
3014 /* the number of coded channels to stereo */
3015 if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3016 && codec_id != CODEC_ID_DTS) {
3017 audio_enc->channels = 2;
3019 audio_enc->channels = audio_channels;
3021 audio_enc->sample_rate = audio_sample_rate;
3022 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3023 if (audio_language) {
3024 pstrcpy(st->language, sizeof(st->language), audio_language);
3025 av_free(audio_language);
3026 audio_language = NULL;
3029 /* reset some key parameters */
3031 audio_codec_id = CODEC_ID_NONE;
3032 audio_stream_copy = 0;
3035 static void opt_new_subtitle_stream(void)
3037 AVFormatContext *oc;
3039 AVCodecContext *subtitle_enc;
3042 if (nb_output_files <= 0) {
3043 fprintf(stderr, "At least one output file must be specified\n");
3046 oc = output_files[nb_output_files - 1];
3048 st = av_new_stream(oc, oc->nb_streams);
3050 fprintf(stderr, "Could not alloc stream\n");
3054 subtitle_enc = st->codec;
3055 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3056 if (subtitle_stream_copy) {
3057 st->stream_copy = 1;
3059 for(i=0; i<opt_name_count; i++){
3061 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3062 if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3063 av_set_double(subtitle_enc, opt_names[i], d);
3065 subtitle_enc->codec_id = subtitle_codec_id;
3068 if (subtitle_language) {
3069 pstrcpy(st->language, sizeof(st->language), subtitle_language);
3070 av_free(subtitle_language);
3071 subtitle_language = NULL;
3074 subtitle_codec_id = CODEC_ID_NONE;
3075 subtitle_stream_copy = 0;
3078 static void opt_new_audio_stream(void)
3080 AVFormatContext *oc;
3081 if (nb_output_files <= 0) {
3082 fprintf(stderr, "At least one output file must be specified\n");
3085 oc = output_files[nb_output_files - 1];
3086 new_audio_stream(oc);
3089 static void opt_new_video_stream(void)
3091 AVFormatContext *oc;
3092 if (nb_output_files <= 0) {
3093 fprintf(stderr, "At least one output file must be specified\n");
3096 oc = output_files[nb_output_files - 1];
3097 new_video_stream(oc);
3100 static void opt_output_file(const char *filename)
3102 AVFormatContext *oc;
3103 int use_video, use_audio, input_has_video, input_has_audio, i;
3104 AVFormatParameters params, *ap = ¶ms;
3106 if (!strcmp(filename, "-"))
3109 oc = av_alloc_format_context();
3111 if (!file_oformat) {
3112 file_oformat = guess_format(NULL, filename, NULL);
3113 if (!file_oformat) {
3114 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3120 oc->oformat = file_oformat;
3121 pstrcpy(oc->filename, sizeof(oc->filename), filename);
3123 if (!strcmp(file_oformat->name, "ffm") &&
3124 strstart(filename, "http:", NULL)) {
3125 /* special case for files sent to ffserver: we get the stream
3126 parameters from ffserver */
3127 if (read_ffserver_streams(oc, filename) < 0) {
3128 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3132 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3133 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3135 /* disable if no corresponding type found and at least one
3137 if (nb_input_files > 0) {
3138 check_audio_video_inputs(&input_has_video, &input_has_audio);
3139 if (!input_has_video)
3141 if (!input_has_audio)
3145 /* manual disable */
3146 if (audio_disable) {
3149 if (video_disable) {
3154 new_video_stream(oc);
3158 new_audio_stream(oc);
3161 if (!oc->nb_streams) {
3162 fprintf(stderr, "No audio or video streams available\n");
3166 oc->timestamp = rec_timestamp;
3169 pstrcpy(oc->title, sizeof(oc->title), str_title);
3171 pstrcpy(oc->author, sizeof(oc->author), str_author);
3173 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3175 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3177 pstrcpy(oc->album, sizeof(oc->album), str_album);
3180 output_files[nb_output_files++] = oc;
3182 /* check filename in case of an image number is expected */
3183 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3184 if (!av_filename_number_test(oc->filename)) {
3185 print_error(oc->filename, AVERROR_NUMEXPECTED);
3190 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3191 /* test if it already exists to avoid loosing precious files */
3192 if (!file_overwrite &&
3193 (strchr(filename, ':') == NULL ||
3194 strstart(filename, "file:", NULL))) {
3195 if (url_exist(filename)) {
3198 if ( !using_stdin ) {
3199 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3202 if (toupper(c) != 'Y') {
3203 fprintf(stderr, "Not overwriting - exiting\n");
3208 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3215 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3216 fprintf(stderr, "Could not open '%s'\n", filename);
3221 memset(ap, 0, sizeof(*ap));
3222 ap->image_format = image_format;
3223 if (av_set_parameters(oc, ap) < 0) {
3224 fprintf(stderr, "%s: Invalid encoding parameters\n",
3229 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3230 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3231 oc->loop_output = loop_output;
3233 for(i=0; i<opt_name_count; i++){
3235 double d = av_get_double(avformat_opts, opt_names[i], &opt);
3236 if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3237 av_set_double(oc, opt_names[i], d);
3240 /* reset some options */
3241 file_oformat = NULL;
3242 file_iformat = NULL;
3243 image_format = NULL;
3246 /* prepare dummy protocols for grab */
3247 static void prepare_grab(void)
3249 int has_video, has_audio, i, j;
3250 AVFormatContext *oc;
3251 AVFormatContext *ic;
3252 AVFormatParameters vp1, *vp = &vp1;
3253 AVFormatParameters ap1, *ap = &ap1;
3255 /* see if audio/video inputs are needed */
3258 memset(ap, 0, sizeof(*ap));
3259 memset(vp, 0, sizeof(*vp));
3260 vp->time_base.num= 1;
3261 for(j=0;j<nb_output_files;j++) {
3262 oc = output_files[j];
3263 for(i=0;i<oc->nb_streams;i++) {
3264 AVCodecContext *enc = oc->streams[i]->codec;
3265 switch(enc->codec_type) {
3266 case CODEC_TYPE_AUDIO:
3267 if (enc->sample_rate > ap->sample_rate)
3268 ap->sample_rate = enc->sample_rate;
3269 if (enc->channels > ap->channels)
3270 ap->channels = enc->channels;
3273 case CODEC_TYPE_VIDEO:
3274 if (enc->width > vp->width)
3275 vp->width = enc->width;
3276 if (enc->height > vp->height)
3277 vp->height = enc->height;
3279 if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
3280 vp->time_base = enc->time_base;
3281 vp->width += frame_leftBand + frame_rightBand;
3282 vp->width -= (frame_padleft + frame_padright);
3283 vp->height += frame_topBand + frame_bottomBand;
3284 vp->height -= (frame_padtop + frame_padbottom);
3294 if (has_video == 0 && has_audio == 0) {
3295 fprintf(stderr, "Output file must have at least one audio or video stream\n");
3300 AVInputFormat *fmt1;
3301 fmt1 = av_find_input_format(video_grab_format);
3302 vp->device = video_device;
3303 vp->channel = video_channel;
3304 vp->standard = video_standard;
3305 vp->pix_fmt = frame_pix_fmt;
3306 if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3307 fprintf(stderr, "Could not find video grab device\n");
3310 /* If not enough info to get the stream parameters, we decode the
3311 first frames to get it. */
3312 if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3313 fprintf(stderr, "Could not find video grab parameters\n");
3316 /* by now video grab has one stream */
3317 ic->streams[0]->r_frame_rate.num = vp->time_base.den;
3318 ic->streams[0]->r_frame_rate.den = vp->time_base.num;
3319 input_files[nb_input_files] = ic;
3322 dump_format(ic, nb_input_files, "", 0);
3326 if (has_audio && audio_grab_format) {
3327 AVInputFormat *fmt1;
3328 fmt1 = av_find_input_format(audio_grab_format);
3329 ap->device = audio_device;
3330 if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3331 fprintf(stderr, "Could not find audio grab device\n");
3334 input_files[nb_input_files] = ic;
3337 dump_format(ic, nb_input_files, "", 0);
3343 /* same option as mencoder */
3344 static void opt_pass(const char *pass_str)
3347 pass = atoi(pass_str);
3348 if (pass != 1 && pass != 2) {
3349 fprintf(stderr, "pass number can be only 1 or 2\n");
3355 #if defined(__MINGW32__) || defined(CONFIG_OS2)
3356 static int64_t getutime(void)
3358 return av_gettime();
3361 static int64_t getutime(void)
3363 struct rusage rusage;
3365 getrusage(RUSAGE_SELF, &rusage);
3366 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3370 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3371 extern int ffm_nopts;
3374 static void show_formats(void)
3376 AVInputFormat *ifmt;
3377 AVOutputFormat *ofmt;
3378 AVImageFormat *image_fmt;
3381 const char **pp, *last_name;
3383 printf("File formats:\n");
3388 const char *name=NULL;
3389 const char *long_name=NULL;
3391 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3392 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3393 strcmp(ofmt->name, last_name)>0){
3395 long_name= ofmt->long_name;
3399 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3400 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3401 strcmp(ifmt->name, last_name)>0){
3403 long_name= ifmt->long_name;
3406 if(name && strcmp(ifmt->name, name)==0)
3418 long_name ? long_name:" ");
3422 printf("Image formats (filename extensions, if any, follow):\n");
3423 for(image_fmt = first_image_format; image_fmt != NULL;
3424 image_fmt = image_fmt->next) {
3427 image_fmt->img_read ? "D":" ",
3428 image_fmt->img_write ? "E":" ",
3430 image_fmt->extensions ? image_fmt->extensions:" ");
3434 printf("Codecs:\n");
3440 const char *type_str;
3443 for(p = first_avcodec; p != NULL; p = p->next) {
3444 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3445 strcmp(p->name, last_name)>0){
3447 decode= encode= cap=0;
3449 if(p2 && strcmp(p->name, p2->name)==0){
3450 if(p->decode) decode=1;
3451 if(p->encode) encode=1;
3452 cap |= p->capabilities;
3457 last_name= p2->name;
3460 case CODEC_TYPE_VIDEO:
3463 case CODEC_TYPE_AUDIO:
3466 case CODEC_TYPE_SUBTITLE:
3475 decode ? "D": (/*p2->decoder ? "d":*/" "),
3478 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3479 cap & CODEC_CAP_DR1 ? "D":" ",
3480 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3482 /* if(p2->decoder && decode==0)
3483 printf(" use %s for decoding", p2->decoder->name);*/
3488 printf("Supported file protocols:\n");
3489 for(up = first_protocol; up != NULL; up = up->next)
3490 printf(" %s:", up->name);
3493 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3494 printf("Motion estimation methods:\n");
3498 if ((pp - motion_str + 1) == ME_ZERO)
3499 printf("(fastest)");
3500 else if ((pp - motion_str + 1) == ME_FULL)
3501 printf("(slowest)");
3502 else if ((pp - motion_str + 1) == ME_EPZS)
3503 printf("(default)");
3508 "Note, the names of encoders and decoders dont always match, so there are\n"
3509 "several cases where the above table shows encoder only or decoder only entries\n"
3510 "even though both encoding and decoding are supported for example, the h263\n"
3511 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3516 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3519 const char *p = str;
3526 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3533 static void opt_inter_matrix(const char *arg)
3535 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3536 parse_matrix_coeffs(inter_matrix, arg);
3539 static void opt_intra_matrix(const char *arg)
3541 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3542 parse_matrix_coeffs(intra_matrix, arg);
3545 static void opt_target(const char *arg)
3548 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3550 if(!strncmp(arg, "pal-", 4)) {
3553 } else if(!strncmp(arg, "ntsc-", 5)) {
3556 } else if(!strncmp(arg, "film-", 5)) {
3561 /* Calculate FR via float to avoid int overflow */
3562 fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3565 } else if((fr == 29970) || (fr == 23976)) {
3568 /* Try to determine PAL/NTSC by peeking in the input files */
3569 if(nb_input_files) {
3571 for(j = 0; j < nb_input_files; j++) {
3572 for(i = 0; i < input_files[j]->nb_streams; i++) {
3573 AVCodecContext *c = input_files[j]->streams[i]->codec;
3574 if(c->codec_type != CODEC_TYPE_VIDEO)
3576 fr = c->time_base.den * 1000 / c->time_base.num;
3580 } else if((fr == 29970) || (fr == 23976)) {
3590 if(verbose && norm >= 0)
3591 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3595 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3596 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3597 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3601 if(!strcmp(arg, "vcd")) {
3603 opt_video_codec("mpeg1video");
3604 opt_audio_codec("mp2");
3607 opt_frame_size(norm ? "352x240" : "352x288");
3608 opt_frame_rate(frame_rates[norm]);
3609 opt_default("gop", norm ? "18" : "15");
3611 opt_default("b", "1150000");
3612 opt_default("maxrate", "1150000");
3613 opt_default("minrate", "1150000");
3614 opt_default("bufsize", "327680"); // 40*1024*8;
3616 audio_bit_rate = 224000;
3617 audio_sample_rate = 44100;
3619 opt_default("packetsize", "2324");
3620 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3622 /* We have to offset the PTS, so that it is consistent with the SCR.
3623 SCR starts at 36000, but the first two packs contain only padding
3624 and the first pack from the other stream, respectively, may also have
3625 been written before.
3626 So the real data starts at SCR 36000+3*1200. */
3627 mux_preload= (36000+3*1200) / 90000.0; //0.44
3628 } else if(!strcmp(arg, "svcd")) {
3630 opt_video_codec("mpeg2video");
3631 opt_audio_codec("mp2");
3634 opt_frame_size(norm ? "480x480" : "480x576");
3635 opt_frame_rate(frame_rates[norm]);
3636 opt_default("gop", norm ? "18" : "15");
3638 opt_default("b", "2040000");
3639 opt_default("maxrate", "2516000");
3640 opt_default("minrate", "0"); //1145000;
3641 opt_default("bufsize", "1835008"); //224*1024*8;
3642 opt_default("flags", "+SCAN_OFFSET");
3645 audio_bit_rate = 224000;
3646 audio_sample_rate = 44100;
3648 opt_default("packetsize", "2324");
3650 } else if(!strcmp(arg, "dvd")) {
3652 opt_video_codec("mpeg2video");
3653 opt_audio_codec("ac3");
3656 opt_frame_size(norm ? "720x480" : "720x576");
3657 opt_frame_rate(frame_rates[norm]);
3658 opt_default("gop", norm ? "18" : "15");
3660 opt_default("b", "6000000");
3661 opt_default("maxrate", "9000000");
3662 opt_default("minrate", "0"); //1500000;
3663 opt_default("bufsize", "1835008"); //224*1024*8;
3665 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3666 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3668 audio_bit_rate = 448000;
3669 audio_sample_rate = 48000;
3671 } else if(!strncmp(arg, "dv", 2)) {
3675 opt_frame_size(norm ? "720x480" : "720x576");
3676 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3677 (norm ? "yuv411p" : "yuv420p"));
3678 opt_frame_rate(frame_rates[norm]);
3680 audio_sample_rate = 48000;
3684 fprintf(stderr, "Unknown target: %s\n", arg);
3689 static void opt_video_bsf(const char *arg)
3691 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3692 AVBitStreamFilterContext **bsfp;
3695 fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3699 bsfp= &video_bitstream_filters;
3701 bsfp= &(*bsfp)->next;
3706 //FIXME avoid audio - video code duplication
3707 static void opt_audio_bsf(const char *arg)
3709 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3710 AVBitStreamFilterContext **bsfp;
3713 fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3717 bsfp= &audio_bitstream_filters;
3719 bsfp= &(*bsfp)->next;
3724 static void show_version(void)
3726 /* TODO: add function interface to avutil and avformat */
3727 fprintf(stderr, "ffmpeg " FFMPEG_VERSION "\n"
3731 LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3735 static int opt_default(const char *opt, const char *arg){
3736 AVOption *o= av_set_string(avctx_opts, opt, arg);
3738 o = av_set_string(avformat_opts, opt, arg);
3742 // 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));
3744 //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
3745 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
3746 opt_names[opt_name_count++]= o->name;
3748 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3749 /* disable generate of real time pts in ffm (need to be supressed anyway) */
3750 if(avctx_opts->flags & CODEC_FLAG_BITEXACT)
3754 if(avctx_opts->debug)
3755 av_log_set_level(AV_LOG_DEBUG);
3759 const OptionDef options[] = {
3761 { "L", 0, {(void*)show_license}, "show license" },
3762 { "h", 0, {(void*)show_help}, "show help" },
3763 { "version", 0, {(void*)show_version}, "show version" },
3764 { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3765 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3766 { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
3767 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3768 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3769 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3770 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3771 { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3772 { "fs", HAS_ARG | OPT_INT, {(void*)&limit_filesize}, "set the limit file size", "limit_size" }, //
3773 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3774 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3775 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3776 { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3777 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3778 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3779 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3780 { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3781 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3782 "add timings for benchmarking" },
3783 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3784 "dump each input packet" },
3785 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3786 "when dumping packets, also dump the payload" },
3787 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3788 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3789 { "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)", "" },
3790 { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3791 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3792 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3793 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3794 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3795 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3796 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3797 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3798 { "dts_delta_threshold", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
3801 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3802 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3803 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3804 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3805 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3806 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3807 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3808 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3809 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3810 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3811 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3812 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3813 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3814 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3815 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3816 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3817 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3818 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3819 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3820 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
3821 { "lmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmin}, "min video lagrange factor (VBR)", "lambda" },
3822 { "lmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmax}, "max video lagrange factor (VBR)", "lambda" },
3823 { "mblmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmin}, "min macroblock quantiser scale (VBR)", "q" },
3824 { "mblmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmax}, "max macroblock quantiser scale (VBR)", "q" },
3825 { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
3826 { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3827 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3828 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3829 { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
3831 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "" },
3832 { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
3833 { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3834 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3835 "use same video quality as source (implies VBR)" },
3836 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3837 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3838 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3839 "deinterlace pictures" },
3840 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3841 { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
3842 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3843 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3844 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3845 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3846 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3847 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3848 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3849 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3852 { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
3853 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3854 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3855 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3856 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3857 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3858 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3859 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3860 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3861 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3863 /* subtitle options */
3864 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3865 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3866 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3869 { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
3870 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3871 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3872 { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
3874 /* G.2 grab options */
3875 { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
3876 { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
3879 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3880 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3882 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
3883 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
3885 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3889 static void show_banner(void)
3891 fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2004 Fabrice Bellard\n");
3892 fprintf(stderr, " configuration: " FFMPEG_CONFIGURATION "\n");
3893 fprintf(stderr, " libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
3894 fprintf(stderr, " libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
3895 fprintf(stderr, " libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
3896 fprintf(stderr, " built on " __DATE__ " " __TIME__);
3898 fprintf(stderr, ", gcc: " __VERSION__ "\n");
3900 fprintf(stderr, ", using a non-gcc compiler\n");
3904 static void show_license(void)
3909 "This program is free software; you can redistribute it and/or modify\n"
3910 "it under the terms of the GNU General Public License as published by\n"
3911 "the Free Software Foundation; either version 2 of the License, or\n"
3912 "(at your option) any later version.\n"
3914 "This program is distributed in the hope that it will be useful,\n"
3915 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3916 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
3917 "GNU General Public License for more details.\n"
3919 "You should have received a copy of the GNU General Public License\n"
3920 "along with this program; if not, write to the Free Software\n"
3921 "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n"
3925 "This library is free software; you can redistribute it and/or\n"
3926 "modify it under the terms of the GNU Lesser General Public\n"
3927 "License as published by the Free Software Foundation; either\n"
3928 "version 2 of the License, or (at your option) any later version.\n"
3930 "This library is distributed in the hope that it will be useful,\n"
3931 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3932 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
3933 "Lesser General Public License for more details.\n"
3935 "You should have received a copy of the GNU Lesser General Public\n"
3936 "License along with this library; if not, write to the Free Software\n"
3937 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
3943 static void show_help(void)
3946 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3947 "Hyper fast Audio and Video encoder\n");
3949 show_help_options(options, "Main options:\n",
3950 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3951 show_help_options(options, "\nVideo options:\n",
3952 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3954 show_help_options(options, "\nAdvanced Video options:\n",
3955 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3956 OPT_VIDEO | OPT_EXPERT);
3957 show_help_options(options, "\nAudio options:\n",
3958 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3960 show_help_options(options, "\nAdvanced Audio options:\n",
3961 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3962 OPT_AUDIO | OPT_EXPERT);
3963 show_help_options(options, "\nSubtitle options:\n",
3964 OPT_SUBTITLE | OPT_GRAB,
3966 show_help_options(options, "\nAudio/Video grab options:\n",
3969 show_help_options(options, "\nAdvanced options:\n",
3970 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3972 av_opt_show(avctx_opts, NULL);
3973 av_opt_show(avformat_opts, NULL);
3978 void parse_arg_file(const char *filename)
3980 opt_output_file(filename);
3983 int main(int argc, char **argv)
3990 avctx_opts= avcodec_alloc_context();
3991 avformat_opts = av_alloc_format_context();
3999 parse_options(argc, argv, options);
4001 /* file converter / grab */
4002 if (nb_output_files <= 0) {
4003 fprintf(stderr, "Must supply at least one output file\n");
4007 if (nb_input_files == 0) {
4013 av_encode(output_files, nb_output_files, input_files, nb_input_files,
4014 stream_maps, nb_stream_maps);
4015 ti = getutime() - ti;
4017 printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4021 for(i=0;i<nb_output_files;i++) {
4022 /* maybe av_close_output_file ??? */
4023 AVFormatContext *s = output_files[i];
4025 if (!(s->oformat->flags & AVFMT_NOFILE))
4027 for(j=0;j<s->nb_streams;j++)
4028 av_free(s->streams[j]);
4031 for(i=0;i<nb_input_files;i++)
4032 av_close_input_file(input_files[i]);
4037 av_free(intra_matrix);
4039 av_free(inter_matrix);
4041 #ifdef POWERPC_PERFORMANCE_REPORT
4042 extern void powerpc_display_perf_report(void);
4043 powerpc_display_perf_report();
4044 #endif /* POWERPC_PERFORMANCE_REPORT */
4047 if (received_sigterm) {
4049 "Received signal %d: terminating.\n",
4050 (int) received_sigterm);
4054 exit(0); /* not all OS-es handle main() return value */