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 error_rate = 0;
133 static int strict = 0;
134 static int top_field_first = -1;
135 static int me_threshold = 0;
136 static int intra_dc_precision = 8;
137 static int me_penalty_compensation= 256;
138 static int frame_skip_threshold= 0;
139 static int frame_skip_factor= 0;
140 static int frame_skip_exp= 0;
141 static int loop_input = 0;
142 static int loop_output = AVFMT_NOOUTPUTLOOP;
143 static int qp_hist = 0;
145 static int intra_only = 0;
146 static int audio_sample_rate = 44100;
147 static int audio_bit_rate = 64000;
148 #define QSCALE_NONE -99999
149 static float audio_qscale = QSCALE_NONE;
150 static int audio_disable = 0;
151 static int audio_channels = 1;
152 static int audio_codec_id = CODEC_ID_NONE;
153 static int audio_codec_tag = 0;
154 static char *audio_language = NULL;
156 static int subtitle_codec_id = CODEC_ID_NONE;
157 static char *subtitle_language = NULL;
159 static float mux_preload= 0.5;
160 static float mux_max_delay= 0.7;
162 static int64_t recording_time = 0;
163 static int64_t start_time = 0;
164 static int64_t rec_timestamp = 0;
165 static int64_t input_ts_offset = 0;
166 static int file_overwrite = 0;
167 static char *str_title = NULL;
168 static char *str_author = NULL;
169 static char *str_copyright = NULL;
170 static char *str_comment = NULL;
171 static char *str_album = NULL;
172 static int do_benchmark = 0;
173 static int do_hex_dump = 0;
174 static int do_pkt_dump = 0;
175 static int do_psnr = 0;
176 static int do_vstats = 0;
177 static int do_pass = 0;
178 static char *pass_logfilename = NULL;
179 static int audio_stream_copy = 0;
180 static int video_stream_copy = 0;
181 static int subtitle_stream_copy = 0;
182 static int video_sync_method= 1;
183 static int audio_sync_method= 0;
184 static int copy_ts= 0;
185 static int opt_shortest = 0; //
186 static int video_global_header = 0;
188 static int rate_emu = 0;
191 static const char *video_grab_format = "bktr";
193 #ifdef CONFIG_VIDEO4LINUX2
194 static const char *video_grab_format = "video4linux2";
196 static const char *video_grab_format = "video4linux";
199 static char *video_device = NULL;
200 static char *grab_device = NULL;
201 static int video_channel = 0;
202 static char *video_standard = "ntsc";
204 static const char *audio_grab_format = "audio_device";
205 static char *audio_device = NULL;
206 static int audio_volume = 256;
208 static int using_stdin = 0;
209 static int using_vhook = 0;
210 static int verbose = 1;
211 static int thread_count= 1;
212 static int q_pressed = 0;
213 static int64_t video_size = 0;
214 static int64_t audio_size = 0;
215 static int64_t extra_size = 0;
216 static int nb_frames_dup = 0;
217 static int nb_frames_drop = 0;
218 static int input_sync;
219 static int limit_filesize = 0; //
221 static int pgmyuv_compatibility_hack=0;
222 static int dts_delta_threshold = 10;
224 static int sws_flags = SWS_BICUBIC;
226 const char **opt_names=NULL;
227 int opt_name_count=0;
228 AVCodecContext *avctx_opts;
229 AVFormatContext *avformat_opts;
231 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
232 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
233 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
235 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
237 struct AVInputStream;
239 typedef struct AVOutputStream {
240 int file_index; /* file index */
241 int index; /* stream index in the output file */
242 int source_index; /* AVInputStream index */
243 AVStream *st; /* stream in the output file */
244 int encoding_needed; /* true if encoding needed for this stream */
246 /* input pts and corresponding output pts
248 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
249 struct AVInputStream *sync_ist; /* input stream to sync against */
250 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
253 AVFrame pict_tmp; /* temporary image for resampling */
254 struct SwsContext *img_resample_ctx; /* for image resampling */
258 int topBand; /* cropping area sizes */
262 int padtop; /* padding area sizes */
269 ReSampleContext *resample; /* for audio resampling */
270 AVFifoBuffer fifo; /* for compression: one audio fifo per codec */
274 typedef struct AVInputStream {
278 int discard; /* true if stream data should be discarded */
279 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
280 int64_t sample_index; /* current sample */
282 int64_t start; /* time when read started */
283 unsigned long frame; /* current frame */
284 int64_t next_pts; /* synthetic pts for cases where pkt.pts
286 int64_t pts; /* current pts */
287 int is_start; /* is 1 at the start and after a discontinuity */
290 typedef struct AVInputFile {
291 int eof_reached; /* true if eof reached */
292 int ist_index; /* index of first stream in ist_table */
293 int buffer_size; /* current total buffer size */
294 int buffer_size_max; /* buffer size at which we consider we can stop
296 int nb_streams; /* nb streams we are aware of */
301 /* init terminal so that we can grab keys */
302 static struct termios oldtty;
304 static void term_exit(void)
306 tcsetattr (0, TCSANOW, &oldtty);
309 static volatile sig_atomic_t received_sigterm = 0;
312 sigterm_handler(int sig)
314 received_sigterm = sig;
318 static void term_init(void)
325 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
326 |INLCR|IGNCR|ICRNL|IXON);
327 tty.c_oflag |= OPOST;
328 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
329 tty.c_cflag &= ~(CSIZE|PARENB);
334 tcsetattr (0, TCSANOW, &tty);
336 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
337 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
338 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
340 register a function to be called at normal program termination
343 #ifdef CONFIG_BEOS_NETSERVER
344 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
348 /* read a key without blocking */
349 static int read_key(void)
353 #ifndef CONFIG_BEOS_NETSERVER
361 n = select(1, &rfds, NULL, NULL, &tv);
373 static int decode_interrupt_cb(void)
375 return q_pressed || (q_pressed = read_key() == 'q');
380 static volatile int received_sigterm = 0;
382 /* no interactive support */
383 static void term_exit(void)
387 static void term_init(void)
391 static int read_key(void)
398 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
403 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
406 /* copy stream format */
407 s->nb_streams = ic->nb_streams;
408 for(i=0;i<ic->nb_streams;i++) {
411 // FIXME: a more elegant solution is needed
412 st = av_mallocz(sizeof(AVStream));
413 memcpy(st, ic->streams[i], sizeof(AVStream));
414 st->codec = avcodec_alloc_context();
415 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
419 av_close_input_file(ic);
424 get_sync_ipts(const AVOutputStream *ost)
426 const AVInputStream *ist = ost->sync_ist;
427 return (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/AV_TIME_BASE;
430 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
432 AVPacket new_pkt= *pkt;
433 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
434 &new_pkt.data, &new_pkt.size,
435 pkt->data, pkt->size,
436 pkt->flags & PKT_FLAG_KEY);
439 new_pkt.destruct= av_destruct_packet;
446 av_interleaved_write_frame(s, pkt);
449 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
451 static void do_audio_out(AVFormatContext *s,
454 unsigned char *buf, int size)
457 static uint8_t *audio_buf = NULL;
458 static uint8_t *audio_out = NULL;
459 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
461 int size_out, frame_bytes, ret;
462 AVCodecContext *enc= ost->st->codec;
464 /* SC: dynamic allocation of buffers */
466 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
468 audio_out = av_malloc(audio_out_size);
469 if (!audio_buf || !audio_out)
470 return; /* Should signal an error ! */
472 if(audio_sync_method){
473 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
474 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
475 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
476 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
478 //FIXME resample delay
479 if(fabs(delta) > 50){
482 byte_delta= FFMAX(byte_delta, -size);
486 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
491 static uint8_t *input_tmp= NULL;
492 input_tmp= av_realloc(input_tmp, byte_delta + size);
494 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
497 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
499 memset(input_tmp, 0, byte_delta);
500 memcpy(input_tmp + byte_delta, buf, size);
504 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
506 }else if(audio_sync_method>1){
507 int comp= clip(delta, -audio_sync_method, audio_sync_method);
508 assert(ost->audio_resample);
510 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
511 // 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));
512 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
516 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
517 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
519 if (ost->audio_resample) {
521 size_out = audio_resample(ost->resample,
522 (short *)buftmp, (short *)buf,
523 size / (ist->st->codec->channels * 2));
524 size_out = size_out * enc->channels * 2;
530 /* now encode as many frames as possible */
531 if (enc->frame_size > 1) {
532 /* output resampled raw samples */
533 av_fifo_write(&ost->fifo, buftmp, size_out);
535 frame_bytes = enc->frame_size * 2 * enc->channels;
537 while (av_fifo_read(&ost->fifo, audio_buf, frame_bytes) == 0) {
539 av_init_packet(&pkt);
541 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
544 pkt.stream_index= ost->index;
547 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
548 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
549 pkt.flags |= PKT_FLAG_KEY;
550 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
552 ost->sync_opts += enc->frame_size;
556 av_init_packet(&pkt);
558 ost->sync_opts += size_out / (2 * enc->channels);
560 /* output a pcm frame */
561 /* XXX: change encoding codec API to avoid this ? */
562 switch(enc->codec->id) {
563 case CODEC_ID_PCM_S32LE:
564 case CODEC_ID_PCM_S32BE:
565 case CODEC_ID_PCM_U32LE:
566 case CODEC_ID_PCM_U32BE:
567 size_out = size_out << 1;
569 case CODEC_ID_PCM_S24LE:
570 case CODEC_ID_PCM_S24BE:
571 case CODEC_ID_PCM_U24LE:
572 case CODEC_ID_PCM_U24BE:
573 case CODEC_ID_PCM_S24DAUD:
574 size_out = size_out / 2 * 3;
576 case CODEC_ID_PCM_S16LE:
577 case CODEC_ID_PCM_S16BE:
578 case CODEC_ID_PCM_U16LE:
579 case CODEC_ID_PCM_U16BE:
582 size_out = size_out >> 1;
585 ret = avcodec_encode_audio(enc, audio_out, size_out,
588 pkt.stream_index= ost->index;
591 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
592 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
593 pkt.flags |= PKT_FLAG_KEY;
594 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
598 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
602 AVPicture picture_tmp;
605 dec = ist->st->codec;
607 /* deinterlace : must be done before any resize */
608 if (do_deinterlace || using_vhook) {
611 /* create temporary picture */
612 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
613 buf = av_malloc(size);
617 picture2 = &picture_tmp;
618 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
621 if(avpicture_deinterlace(picture2, picture,
622 dec->pix_fmt, dec->width, dec->height) < 0) {
623 /* if error, do not deinterlace */
629 img_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
635 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
637 if (picture != picture2)
638 *picture = *picture2;
642 /* we begin to correct av delay at this threshold */
643 #define AV_DELAY_MAX 0.100
645 static void do_subtitle_out(AVFormatContext *s,
651 static uint8_t *subtitle_out = NULL;
652 int subtitle_out_max_size = 65536;
653 int subtitle_out_size, nb, i;
657 if (pts == AV_NOPTS_VALUE) {
658 fprintf(stderr, "Subtitle packets must have a pts\n");
662 enc = ost->st->codec;
665 subtitle_out = av_malloc(subtitle_out_max_size);
668 /* Note: DVB subtitle need one packet to draw them and one other
669 packet to clear them */
670 /* XXX: signal it in the codec context ? */
671 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
676 for(i = 0; i < nb; i++) {
677 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
678 subtitle_out_max_size, sub);
680 av_init_packet(&pkt);
681 pkt.stream_index = ost->index;
682 pkt.data = subtitle_out;
683 pkt.size = subtitle_out_size;
684 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);
685 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
686 /* XXX: the pts correction is handled here. Maybe handling
687 it in the codec would be better */
689 pkt.pts += 90 * sub->start_display_time;
691 pkt.pts += 90 * sub->end_display_time;
693 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
697 static int bit_buffer_size= 1024*256;
698 static uint8_t *bit_buffer= NULL;
700 static void do_video_out(AVFormatContext *s,
706 int nb_frames, i, ret;
707 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
708 AVFrame picture_crop_temp, picture_pad_temp;
709 uint8_t *buf = NULL, *buf1 = NULL;
710 AVCodecContext *enc, *dec;
712 avcodec_get_frame_defaults(&picture_crop_temp);
713 avcodec_get_frame_defaults(&picture_pad_temp);
715 enc = ost->st->codec;
716 dec = ist->st->codec;
718 /* by default, we output a single frame */
723 if(video_sync_method){
725 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
726 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
729 else if (vdelta > 1.1)
730 nb_frames = lrintf(vdelta);
731 //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);
735 fprintf(stderr, "*** drop!\n");
736 }else if (nb_frames > 1) {
737 nb_frames_dup += nb_frames;
739 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
742 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
744 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
748 if (ost->video_crop) {
749 if (img_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
750 av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
753 formatted_picture = &picture_crop_temp;
755 formatted_picture = in_picture;
758 final_picture = formatted_picture;
759 padding_src = formatted_picture;
760 resampling_dst = &ost->pict_tmp;
761 if (ost->video_pad) {
762 final_picture = &ost->pict_tmp;
763 if (ost->video_resample) {
764 if (img_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
765 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
768 resampling_dst = &picture_pad_temp;
772 if (ost->video_resample) {
774 final_picture = &ost->pict_tmp;
775 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
776 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
779 if (ost->video_pad) {
780 img_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
781 enc->height, enc->width, enc->pix_fmt,
782 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
785 /* duplicates frame if needed */
786 for(i=0;i<nb_frames;i++) {
788 av_init_packet(&pkt);
789 pkt.stream_index= ost->index;
791 if (s->oformat->flags & AVFMT_RAWPICTURE) {
792 /* raw pictures are written as AVPicture structure to
793 avoid any copies. We support temorarily the older
795 AVFrame* old_frame = enc->coded_frame;
796 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
797 pkt.data= (uint8_t *)final_picture;
798 pkt.size= sizeof(AVPicture);
799 if(dec->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
800 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
801 if(dec->coded_frame && dec->coded_frame->key_frame)
802 pkt.flags |= PKT_FLAG_KEY;
804 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
805 enc->coded_frame = old_frame;
809 big_picture= *final_picture;
810 /* better than nothing: use input picture interlaced
812 big_picture.interlaced_frame = in_picture->interlaced_frame;
813 if(avctx_opts->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
814 if(top_field_first == -1)
815 big_picture.top_field_first = in_picture->top_field_first;
817 big_picture.top_field_first = top_field_first;
820 /* handles sameq here. This is not correct because it may
821 not be a global option */
823 big_picture.quality = ist->st->quality;
825 big_picture.quality = ost->st->quality;
827 big_picture.pict_type = 0;
828 // big_picture.pts = AV_NOPTS_VALUE;
829 big_picture.pts= ost->sync_opts;
830 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
831 //av_log(NULL, AV_LOG_DEBUG, "%lld -> encoder\n", ost->sync_opts);
832 ret = avcodec_encode_video(enc,
833 bit_buffer, bit_buffer_size,
835 //enc->frame_number = enc->real_pict_num;
837 pkt.data= bit_buffer;
839 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
840 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
841 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %lld/%lld\n",
842 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
843 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
845 if(enc->coded_frame && enc->coded_frame->key_frame)
846 pkt.flags |= PKT_FLAG_KEY;
847 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
849 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
850 // enc->frame_number-1, enc->real_pict_num, ret,
852 /* if two pass, output log */
853 if (ost->logfile && enc->stats_out) {
854 fprintf(ost->logfile, "%s", enc->stats_out);
866 static double psnr(double d){
867 if(d==0) return INFINITY;
868 return -10.0*log(d)/log(10.0);
871 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
874 static FILE *fvstats=NULL;
881 double ti1, bitrate, avg_bitrate;
885 today = localtime(&today2);
886 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
889 fvstats = fopen(filename,"w");
897 enc = ost->st->codec;
898 if (enc->codec_type == CODEC_TYPE_VIDEO) {
899 frame_number = ost->frame_number;
900 fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
901 if (enc->flags&CODEC_FLAG_PSNR)
902 fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
904 fprintf(fvstats,"f_size= %6d ", frame_size);
905 /* compute pts value */
906 ti1 = ost->sync_opts * av_q2d(enc->time_base);
910 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
911 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
912 fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
913 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
914 fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
918 static void print_report(AVFormatContext **output_files,
919 AVOutputStream **ost_table, int nb_ostreams,
924 AVFormatContext *oc, *os;
927 int frame_number, vid, i;
928 double bitrate, ti1, pts;
929 static int64_t last_time = -1;
930 static int qp_histogram[52];
932 if (!is_last_report) {
934 /* display the report every 0.5 seconds */
935 cur_time = av_gettime();
936 if (last_time == -1) {
937 last_time = cur_time;
940 if ((cur_time - last_time) < 500000)
942 last_time = cur_time;
946 oc = output_files[0];
948 total_size = url_ftell(&oc->pb);
953 for(i=0;i<nb_ostreams;i++) {
955 os = output_files[ost->file_index];
956 enc = ost->st->codec;
957 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
958 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
959 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
961 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
962 frame_number = ost->frame_number;
963 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d q=%3.1f ",
964 frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
966 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
967 if(qp_hist && enc->coded_frame){
969 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
970 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
973 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
975 if (enc->flags&CODEC_FLAG_PSNR){
977 double error, error_sum=0;
978 double scale, scale_sum=0;
979 char type[3]= {'Y','U','V'};
980 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
983 error= enc->error[j];
984 scale= enc->width*enc->height*255.0*255.0*frame_number;
986 error= enc->coded_frame->error[j];
987 scale= enc->width*enc->height*255.0*255.0;
992 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
994 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
998 /* compute min output value */
999 pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1000 if ((pts < ti1) && (pts > 0))
1006 if (verbose || is_last_report) {
1007 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1009 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1010 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1011 (double)total_size / 1024, ti1, bitrate);
1014 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1015 nb_frames_dup, nb_frames_drop);
1018 fprintf(stderr, "%s \r", buf);
1023 if (is_last_report && verbose >= 0){
1024 int64_t raw= audio_size + video_size + extra_size;
1025 fprintf(stderr, "\n");
1026 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1030 100.0*(total_size - raw)/raw
1035 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1036 static int output_packet(AVInputStream *ist, int ist_index,
1037 AVOutputStream **ost_table, int nb_ostreams,
1038 const AVPacket *pkt)
1040 AVFormatContext *os;
1041 AVOutputStream *ost;
1045 int data_size, got_picture;
1047 void *buffer_to_free;
1048 static unsigned int samples_size= 0;
1049 static short *samples= NULL;
1050 AVSubtitle subtitle, *subtitle_to_free;
1054 ist->pts= ist->next_pts; // needed for last packet if vsync=0
1055 } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1056 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1058 // assert(ist->pts == ist->next_pts);
1072 /* decode the packet if needed */
1073 data_buf = NULL; /* fail safe */
1075 subtitle_to_free = NULL;
1076 if (ist->decoding_needed) {
1077 switch(ist->st->codec->codec_type) {
1078 case CODEC_TYPE_AUDIO:{
1080 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
1081 /* XXX: could avoid copy if PCM 16 bits with same
1082 endianness as CPU */
1083 ret = avcodec_decode_audio(ist->st->codec, samples, &data_size,
1089 /* Some bug in mpeg audio decoder gives */
1090 /* data_size < 0, it seems they are overflows */
1091 if (data_size <= 0) {
1092 /* no audio frame */
1095 data_buf = (uint8_t *)samples;
1096 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1097 (ist->st->codec->sample_rate * ist->st->codec->channels);
1099 case CODEC_TYPE_VIDEO:
1100 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1101 /* XXX: allocate picture correctly */
1102 avcodec_get_frame_defaults(&picture);
1104 ret = avcodec_decode_video(ist->st->codec,
1105 &picture, &got_picture, ptr, len);
1106 ist->st->quality= picture.quality;
1110 /* no picture yet */
1111 goto discard_packet;
1113 if (ist->st->codec->time_base.num != 0) {
1114 ist->next_pts += ((int64_t)AV_TIME_BASE *
1115 ist->st->codec->time_base.num) /
1116 ist->st->codec->time_base.den;
1120 case CODEC_TYPE_SUBTITLE:
1121 ret = avcodec_decode_subtitle(ist->st->codec,
1122 &subtitle, &got_subtitle, ptr, len);
1125 if (!got_subtitle) {
1126 goto discard_packet;
1128 subtitle_to_free = &subtitle;
1135 switch(ist->st->codec->codec_type) {
1136 case CODEC_TYPE_AUDIO:
1137 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1138 (ist->st->codec->sample_rate * ist->st->codec->channels);
1140 case CODEC_TYPE_VIDEO:
1141 if (ist->st->codec->time_base.num != 0) {
1142 ist->next_pts += ((int64_t)AV_TIME_BASE *
1143 ist->st->codec->time_base.num) /
1144 ist->st->codec->time_base.den;
1154 buffer_to_free = NULL;
1155 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1156 pre_process_video_frame(ist, (AVPicture *)&picture,
1160 // preprocess audio (volume)
1161 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1162 if (audio_volume != 256) {
1165 for(i=0;i<(data_size / sizeof(short));i++) {
1166 int v = ((*volp) * audio_volume + 128) >> 8;
1167 if (v < -32768) v = -32768;
1168 if (v > 32767) v = 32767;
1174 /* frame rate emulation */
1175 if (ist->st->codec->rate_emu) {
1176 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1177 int64_t now = av_gettime() - ist->start;
1185 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1186 is the one of the next displayed one */
1187 /* XXX: add mpeg4 too ? */
1188 if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1189 if (ist->st->codec->pict_type != B_TYPE) {
1191 tmp = ist->last_ip_pts;
1192 ist->last_ip_pts = ist->frac_pts.val;
1193 ist->frac_pts.val = tmp;
1197 /* if output time reached then transcode raw format,
1198 encode packets and output them */
1199 if (start_time == 0 || ist->pts >= start_time)
1200 for(i=0;i<nb_ostreams;i++) {
1204 if (ost->source_index == ist_index) {
1205 os = output_files[ost->file_index];
1208 printf("%d: got pts=%0.3f %0.3f\n", i,
1209 (double)pkt->pts / AV_TIME_BASE,
1210 ((double)ist->pts / AV_TIME_BASE) -
1211 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1213 /* set the input output pts pairs */
1214 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1216 if (ost->encoding_needed) {
1217 switch(ost->st->codec->codec_type) {
1218 case CODEC_TYPE_AUDIO:
1219 do_audio_out(os, ost, ist, data_buf, data_size);
1221 case CODEC_TYPE_VIDEO:
1222 do_video_out(os, ost, ist, &picture, &frame_size);
1223 video_size += frame_size;
1224 if (do_vstats && frame_size)
1225 do_video_stats(os, ost, frame_size);
1227 case CODEC_TYPE_SUBTITLE:
1228 do_subtitle_out(os, ost, ist, &subtitle,
1235 AVFrame avframe; //FIXME/XXX remove this
1237 av_init_packet(&opkt);
1239 /* no reencoding needed : output the packet directly */
1240 /* force the input stream PTS */
1242 avcodec_get_frame_defaults(&avframe);
1243 ost->st->codec->coded_frame= &avframe;
1244 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1246 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1247 audio_size += data_size;
1248 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1249 video_size += data_size;
1253 opkt.stream_index= ost->index;
1254 if(pkt->pts != AV_NOPTS_VALUE)
1255 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);
1257 opkt.pts= AV_NOPTS_VALUE;
1261 if (pkt->dts == AV_NOPTS_VALUE)
1262 dts = ist->next_pts;
1264 dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1265 opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
1267 opkt.flags= pkt->flags;
1269 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1270 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1271 opkt.destruct= av_destruct_packet;
1273 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
1274 ost->st->codec->frame_number++;
1275 ost->frame_number++;
1276 av_free_packet(&opkt);
1280 av_free(buffer_to_free);
1281 /* XXX: allocate the subtitles in the codec ? */
1282 if (subtitle_to_free) {
1283 if (subtitle_to_free->rects != NULL) {
1284 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1285 av_free(subtitle_to_free->rects[i].bitmap);
1286 av_free(subtitle_to_free->rects[i].rgba_palette);
1288 av_freep(&subtitle_to_free->rects);
1290 subtitle_to_free->num_rects = 0;
1291 subtitle_to_free = NULL;
1298 for(i=0;i<nb_ostreams;i++) {
1300 if (ost->source_index == ist_index) {
1301 AVCodecContext *enc= ost->st->codec;
1302 os = output_files[ost->file_index];
1304 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1306 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1309 if (ost->encoding_needed) {
1313 av_init_packet(&pkt);
1314 pkt.stream_index= ost->index;
1316 switch(ost->st->codec->codec_type) {
1317 case CODEC_TYPE_AUDIO:
1318 fifo_bytes = av_fifo_size(&ost->fifo);
1320 /* encode any samples remaining in fifo */
1321 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1322 int fs_tmp = enc->frame_size;
1323 enc->frame_size = fifo_bytes / (2 * enc->channels);
1324 if(av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes) == 0) {
1325 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1327 enc->frame_size = fs_tmp;
1330 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1333 pkt.flags |= PKT_FLAG_KEY;
1335 case CODEC_TYPE_VIDEO:
1336 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1338 if(enc->coded_frame && enc->coded_frame->key_frame)
1339 pkt.flags |= PKT_FLAG_KEY;
1340 if (ost->logfile && enc->stats_out) {
1341 fprintf(ost->logfile, "%s", enc->stats_out);
1350 pkt.data= bit_buffer;
1352 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1353 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1354 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1368 * The following code is the main loop of the file converter
1370 static int av_encode(AVFormatContext **output_files,
1371 int nb_output_files,
1372 AVFormatContext **input_files,
1374 AVStreamMap *stream_maps, int nb_stream_maps)
1376 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1377 AVFormatContext *is, *os;
1378 AVCodecContext *codec, *icodec;
1379 AVOutputStream *ost, **ost_table = NULL;
1380 AVInputStream *ist, **ist_table = NULL;
1381 AVInputFile *file_table;
1382 AVFormatContext *stream_no_data;
1385 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1389 /* input stream init */
1391 for(i=0;i<nb_input_files;i++) {
1392 is = input_files[i];
1393 file_table[i].ist_index = j;
1394 file_table[i].nb_streams = is->nb_streams;
1395 j += is->nb_streams;
1399 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1403 for(i=0;i<nb_istreams;i++) {
1404 ist = av_mallocz(sizeof(AVInputStream));
1410 for(i=0;i<nb_input_files;i++) {
1411 is = input_files[i];
1412 for(k=0;k<is->nb_streams;k++) {
1413 ist = ist_table[j++];
1414 ist->st = is->streams[k];
1415 ist->file_index = i;
1417 ist->discard = 1; /* the stream is discarded by default
1420 if (ist->st->codec->rate_emu) {
1421 ist->start = av_gettime();
1427 /* output stream init */
1429 for(i=0;i<nb_output_files;i++) {
1430 os = output_files[i];
1431 nb_ostreams += os->nb_streams;
1433 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1434 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1438 /* Sanity check the mapping args -- do the input files & streams exist? */
1439 for(i=0;i<nb_stream_maps;i++) {
1440 int fi = stream_maps[i].file_index;
1441 int si = stream_maps[i].stream_index;
1443 if (fi < 0 || fi > nb_input_files - 1 ||
1444 si < 0 || si > file_table[fi].nb_streams - 1) {
1445 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1448 fi = stream_maps[i].sync_file_index;
1449 si = stream_maps[i].sync_stream_index;
1450 if (fi < 0 || fi > nb_input_files - 1 ||
1451 si < 0 || si > file_table[fi].nb_streams - 1) {
1452 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1457 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1460 for(i=0;i<nb_ostreams;i++) {
1461 ost = av_mallocz(sizeof(AVOutputStream));
1468 for(k=0;k<nb_output_files;k++) {
1469 os = output_files[k];
1470 for(i=0;i<os->nb_streams;i++) {
1472 ost = ost_table[n++];
1473 ost->file_index = k;
1475 ost->st = os->streams[i];
1476 if (nb_stream_maps > 0) {
1477 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1478 stream_maps[n-1].stream_index;
1480 /* Sanity check that the stream types match */
1481 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1482 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1483 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1484 ost->file_index, ost->index);
1489 /* get corresponding input stream index : we select the first one with the right type */
1491 for(j=0;j<nb_istreams;j++) {
1494 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1495 ost->source_index = j;
1502 /* try again and reuse existing stream */
1503 for(j=0;j<nb_istreams;j++) {
1505 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1506 ost->source_index = j;
1511 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1512 ost->file_index, ost->index);
1517 ist = ist_table[ost->source_index];
1519 ost->sync_ist = (nb_stream_maps > 0) ?
1520 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1521 stream_maps[n-1].sync_stream_index] : ist;
1525 /* for each output stream, we compute the right encoding parameters */
1526 for(i=0;i<nb_ostreams;i++) {
1528 ist = ist_table[ost->source_index];
1530 codec = ost->st->codec;
1531 icodec = ist->st->codec;
1533 if (ost->st->stream_copy) {
1534 /* if stream_copy is selected, no need to decode or encode */
1535 codec->codec_id = icodec->codec_id;
1536 codec->codec_type = icodec->codec_type;
1537 if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1538 codec->bit_rate = icodec->bit_rate;
1539 codec->extradata= icodec->extradata;
1540 codec->extradata_size= icodec->extradata_size;
1541 codec->time_base = icodec->time_base;
1542 switch(codec->codec_type) {
1543 case CODEC_TYPE_AUDIO:
1544 codec->sample_rate = icodec->sample_rate;
1545 codec->channels = icodec->channels;
1546 codec->frame_size = icodec->frame_size;
1547 codec->block_align= icodec->block_align;
1549 case CODEC_TYPE_VIDEO:
1550 codec->pix_fmt = icodec->pix_fmt;
1551 codec->width = icodec->width;
1552 codec->height = icodec->height;
1553 codec->has_b_frames = icodec->has_b_frames;
1555 case CODEC_TYPE_SUBTITLE:
1561 switch(codec->codec_type) {
1562 case CODEC_TYPE_AUDIO:
1563 if (av_fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1566 if (codec->channels == icodec->channels &&
1567 codec->sample_rate == icodec->sample_rate) {
1568 ost->audio_resample = 0;
1570 if (codec->channels != icodec->channels &&
1571 (icodec->codec_id == CODEC_ID_AC3 ||
1572 icodec->codec_id == CODEC_ID_DTS)) {
1573 /* Special case for 5:1 AC3 and DTS input */
1574 /* and mono or stereo output */
1575 /* Request specific number of channels */
1576 icodec->channels = codec->channels;
1577 if (codec->sample_rate == icodec->sample_rate)
1578 ost->audio_resample = 0;
1580 ost->audio_resample = 1;
1583 ost->audio_resample = 1;
1586 if(audio_sync_method>1)
1587 ost->audio_resample = 1;
1589 if(ost->audio_resample){
1590 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1591 codec->sample_rate, icodec->sample_rate);
1593 printf("Can't resample. Aborting.\n");
1597 ist->decoding_needed = 1;
1598 ost->encoding_needed = 1;
1600 case CODEC_TYPE_VIDEO:
1601 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1602 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1603 ost->video_resample = ((codec->width != icodec->width -
1604 (frame_leftBand + frame_rightBand) +
1605 (frame_padleft + frame_padright)) ||
1606 (codec->height != icodec->height -
1607 (frame_topBand + frame_bottomBand) +
1608 (frame_padtop + frame_padbottom)) ||
1609 (codec->pix_fmt != icodec->pix_fmt));
1610 if (ost->video_crop) {
1611 ost->topBand = frame_topBand;
1612 ost->leftBand = frame_leftBand;
1614 if (ost->video_pad) {
1615 ost->padtop = frame_padtop;
1616 ost->padleft = frame_padleft;
1617 ost->padbottom = frame_padbottom;
1618 ost->padright = frame_padright;
1619 if (!ost->video_resample) {
1620 avcodec_get_frame_defaults(&ost->pict_tmp);
1621 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1622 codec->width, codec->height ) )
1626 if (ost->video_resample) {
1627 avcodec_get_frame_defaults(&ost->pict_tmp);
1628 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1629 codec->width, codec->height ) )
1632 ost->img_resample_ctx = sws_getContext(
1633 icodec->width - (frame_leftBand + frame_rightBand),
1634 icodec->height - (frame_topBand + frame_bottomBand),
1636 codec->width - (frame_padleft + frame_padright),
1637 codec->height - (frame_padtop + frame_padbottom),
1639 sws_flags, NULL, NULL, NULL);
1640 if (ost->img_resample_ctx == NULL) {
1641 fprintf(stderr, "Cannot get resampling context\n");
1644 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1646 ost->encoding_needed = 1;
1647 ist->decoding_needed = 1;
1649 case CODEC_TYPE_SUBTITLE:
1650 ost->encoding_needed = 1;
1651 ist->decoding_needed = 1;
1658 if (ost->encoding_needed &&
1659 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1660 char logfilename[1024];
1665 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1667 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1668 if (codec->flags & CODEC_FLAG_PASS1) {
1669 f = fopen(logfilename, "w");
1671 perror(logfilename);
1676 /* read the log file */
1677 f = fopen(logfilename, "r");
1679 perror(logfilename);
1682 fseek(f, 0, SEEK_END);
1684 fseek(f, 0, SEEK_SET);
1685 logbuffer = av_malloc(size + 1);
1687 fprintf(stderr, "Could not allocate log buffer\n");
1690 size = fread(logbuffer, 1, size, f);
1692 logbuffer[size] = '\0';
1693 codec->stats_in = logbuffer;
1697 if(codec->codec_type == CODEC_TYPE_VIDEO){
1698 int size= codec->width * codec->height;
1699 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1704 bit_buffer = av_malloc(bit_buffer_size);
1708 /* dump the file output parameters - cannot be done before in case
1710 for(i=0;i<nb_output_files;i++) {
1711 dump_format(output_files[i], i, output_files[i]->filename, 1);
1714 /* dump the stream mapping */
1716 fprintf(stderr, "Stream mapping:\n");
1717 for(i=0;i<nb_ostreams;i++) {
1719 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1720 ist_table[ost->source_index]->file_index,
1721 ist_table[ost->source_index]->index,
1724 if (ost->sync_ist != ist_table[ost->source_index])
1725 fprintf(stderr, " [sync #%d.%d]",
1726 ost->sync_ist->file_index,
1727 ost->sync_ist->index);
1728 fprintf(stderr, "\n");
1732 /* open each encoder */
1733 for(i=0;i<nb_ostreams;i++) {
1735 if (ost->encoding_needed) {
1737 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1739 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1740 ost->file_index, ost->index);
1743 if (avcodec_open(ost->st->codec, codec) < 0) {
1744 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1745 ost->file_index, ost->index);
1748 extra_size += ost->st->codec->extradata_size;
1752 /* open each decoder */
1753 for(i=0;i<nb_istreams;i++) {
1755 if (ist->decoding_needed) {
1757 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1759 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1760 ist->st->codec->codec_id, ist->file_index, ist->index);
1763 if (avcodec_open(ist->st->codec, codec) < 0) {
1764 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1765 ist->file_index, ist->index);
1768 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1769 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1774 for(i=0;i<nb_istreams;i++) {
1776 is = input_files[ist->file_index];
1778 ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1779 if(ist->st->start_time == AV_NOPTS_VALUE)
1781 if(input_files_ts_offset[ist->file_index])
1782 ist->next_pts= AV_NOPTS_VALUE;
1786 /* compute buffer size max (should use a complete heuristic) */
1787 for(i=0;i<nb_input_files;i++) {
1788 file_table[i].buffer_size_max = 2048;
1791 /* set meta data information from input file if required */
1792 for (i=0;i<nb_meta_data_maps;i++) {
1793 AVFormatContext *out_file;
1794 AVFormatContext *in_file;
1796 int out_file_index = meta_data_maps[i].out_file;
1797 int in_file_index = meta_data_maps[i].in_file;
1798 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1799 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1803 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1804 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1809 out_file = output_files[out_file_index];
1810 in_file = input_files[in_file_index];
1812 strcpy(out_file->title, in_file->title);
1813 strcpy(out_file->author, in_file->author);
1814 strcpy(out_file->copyright, in_file->copyright);
1815 strcpy(out_file->comment, in_file->comment);
1816 strcpy(out_file->album, in_file->album);
1817 out_file->year = in_file->year;
1818 out_file->track = in_file->track;
1819 strcpy(out_file->genre, in_file->genre);
1822 /* open files and write file headers */
1823 for(i=0;i<nb_output_files;i++) {
1824 os = output_files[i];
1825 if (av_write_header(os) < 0) {
1826 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1833 if ( !using_stdin && verbose >= 0) {
1834 fprintf(stderr, "Press [q] to stop encoding\n");
1835 url_set_interrupt_cb(decode_interrupt_cb);
1843 for(; received_sigterm == 0;) {
1844 int file_index, ist_index;
1852 /* if 'q' pressed, exits */
1856 /* read_key() returns 0 on EOF */
1862 /* select the stream that we must read now by looking at the
1863 smallest output pts */
1865 for(i=0;i<nb_ostreams;i++) {
1868 os = output_files[ost->file_index];
1869 ist = ist_table[ost->source_index];
1870 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1871 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1873 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1874 ipts = (double)ist->pts;
1875 if (!file_table[ist->file_index].eof_reached){
1876 if(ipts < ipts_min) {
1878 if(input_sync ) file_index = ist->file_index;
1880 if(opts < opts_min) {
1882 if(!input_sync) file_index = ist->file_index;
1885 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1890 /* if none, if is finished */
1891 if (file_index < 0) {
1895 /* finish if recording time exhausted */
1896 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1899 /* finish if limit size exhausted */
1900 if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
1903 /* read a frame from it and output it in the fifo */
1904 is = input_files[file_index];
1905 if (av_read_frame(is, &pkt) < 0) {
1906 file_table[file_index].eof_reached = 1;
1907 if (opt_shortest) break; else continue; //
1911 stream_no_data = is;
1916 av_pkt_dump(stdout, &pkt, do_hex_dump);
1918 /* the following test is needed in case new streams appear
1919 dynamically in stream : we ignore them */
1920 if (pkt.stream_index >= file_table[file_index].nb_streams)
1921 goto discard_packet;
1922 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1923 ist = ist_table[ist_index];
1925 goto discard_packet;
1927 // 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);
1928 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1929 int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
1930 if(ABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
1931 input_files_ts_offset[ist->file_index]-= delta;
1933 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1934 for(i=0; i<file_table[file_index].nb_streams; i++){
1935 int index= file_table[file_index].ist_index + i;
1936 ist_table[index]->next_pts += delta;
1937 ist_table[index]->is_start=1;
1942 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1943 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1946 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1947 ist->file_index, ist->index);
1949 av_free_packet(&pkt);
1954 av_free_packet(&pkt);
1956 /* dump report by using the output first video and audio streams */
1957 print_report(output_files, ost_table, nb_ostreams, 0);
1960 /* at the end of stream, we must flush the decoder buffers */
1961 for(i=0;i<nb_istreams;i++) {
1963 if (ist->decoding_needed) {
1964 output_packet(ist, i, ost_table, nb_ostreams, NULL);
1970 /* write the trailer if needed and close file */
1971 for(i=0;i<nb_output_files;i++) {
1972 os = output_files[i];
1973 av_write_trailer(os);
1976 /* dump report by using the first video and audio streams */
1977 print_report(output_files, ost_table, nb_ostreams, 1);
1979 /* close each encoder */
1980 for(i=0;i<nb_ostreams;i++) {
1982 if (ost->encoding_needed) {
1983 av_freep(&ost->st->codec->stats_in);
1984 avcodec_close(ost->st->codec);
1988 /* close each decoder */
1989 for(i=0;i<nb_istreams;i++) {
1991 if (ist->decoding_needed) {
1992 avcodec_close(ist->st->codec);
2000 av_freep(&bit_buffer);
2001 av_free(file_table);
2004 for(i=0;i<nb_istreams;i++) {
2011 for(i=0;i<nb_ostreams;i++) {
2015 fclose(ost->logfile);
2016 ost->logfile = NULL;
2018 av_fifo_free(&ost->fifo); /* works even if fifo is not
2019 initialized but set to zero */
2020 av_free(ost->pict_tmp.data[0]);
2021 if (ost->video_resample)
2022 sws_freeContext(ost->img_resample_ctx);
2023 if (ost->audio_resample)
2024 audio_resample_close(ost->resample);
2037 int file_read(const char *filename)
2040 unsigned char buffer[1024];
2043 if (url_open(&h, filename, O_RDONLY) < 0) {
2044 printf("could not open '%s'\n", filename);
2048 len = url_read(h, buffer, sizeof(buffer));
2051 for(i=0;i<len;i++) putchar(buffer[i]);
2058 static void opt_image_format(const char *arg)
2062 for(f = first_image_format; f != NULL; f = f->next) {
2063 if (!strcmp(arg, f->name))
2067 fprintf(stderr, "Unknown image format: '%s'\n", arg);
2073 static void opt_format(const char *arg)
2075 /* compatibility stuff for pgmyuv */
2076 if (!strcmp(arg, "pgmyuv")) {
2077 pgmyuv_compatibility_hack=1;
2078 // opt_image_format(arg);
2082 file_iformat = av_find_input_format(arg);
2083 file_oformat = guess_format(arg, NULL, NULL);
2084 if (!file_iformat && !file_oformat) {
2085 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2090 static void opt_video_rc_eq(char *arg)
2095 static void opt_video_rc_override_string(char *arg)
2097 video_rc_override_string = arg;
2100 static void opt_me_threshold(const char *arg)
2102 me_threshold = atoi(arg);
2105 static void opt_verbose(const char *arg)
2107 verbose = atoi(arg);
2108 av_log_set_level(atoi(arg));
2111 static void opt_frame_rate(const char *arg)
2113 if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2114 fprintf(stderr, "Incorrect frame rate\n");
2119 static void opt_frame_crop_top(const char *arg)
2121 frame_topBand = atoi(arg);
2122 if (frame_topBand < 0) {
2123 fprintf(stderr, "Incorrect top crop size\n");
2126 if ((frame_topBand % 2) != 0) {
2127 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2130 if ((frame_topBand) >= frame_height){
2131 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2134 frame_height -= frame_topBand;
2137 static void opt_frame_crop_bottom(const char *arg)
2139 frame_bottomBand = atoi(arg);
2140 if (frame_bottomBand < 0) {
2141 fprintf(stderr, "Incorrect bottom crop size\n");
2144 if ((frame_bottomBand % 2) != 0) {
2145 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2148 if ((frame_bottomBand) >= frame_height){
2149 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2152 frame_height -= frame_bottomBand;
2155 static void opt_frame_crop_left(const char *arg)
2157 frame_leftBand = atoi(arg);
2158 if (frame_leftBand < 0) {
2159 fprintf(stderr, "Incorrect left crop size\n");
2162 if ((frame_leftBand % 2) != 0) {
2163 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2166 if ((frame_leftBand) >= frame_width){
2167 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2170 frame_width -= frame_leftBand;
2173 static void opt_frame_crop_right(const char *arg)
2175 frame_rightBand = atoi(arg);
2176 if (frame_rightBand < 0) {
2177 fprintf(stderr, "Incorrect right crop size\n");
2180 if ((frame_rightBand % 2) != 0) {
2181 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2184 if ((frame_rightBand) >= frame_width){
2185 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2188 frame_width -= frame_rightBand;
2191 static void opt_frame_size(const char *arg)
2193 if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2194 fprintf(stderr, "Incorrect frame size\n");
2197 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2198 fprintf(stderr, "Frame size must be a multiple of 2\n");
2204 #define SCALEBITS 10
2205 #define ONE_HALF (1 << (SCALEBITS - 1))
2206 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2208 #define RGB_TO_Y(r, g, b) \
2209 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2210 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2212 #define RGB_TO_U(r1, g1, b1, shift)\
2213 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2214 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2216 #define RGB_TO_V(r1, g1, b1, shift)\
2217 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2218 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2220 static void opt_pad_color(const char *arg) {
2221 /* Input is expected to be six hex digits similar to
2222 how colors are expressed in html tags (but without the #) */
2223 int rgb = strtol(arg, NULL, 16);
2227 g = ((rgb >> 8) & 255);
2230 padcolor[0] = RGB_TO_Y(r,g,b);
2231 padcolor[1] = RGB_TO_U(r,g,b,0);
2232 padcolor[2] = RGB_TO_V(r,g,b,0);
2235 static void opt_frame_pad_top(const char *arg)
2237 frame_padtop = atoi(arg);
2238 if (frame_padtop < 0) {
2239 fprintf(stderr, "Incorrect top pad size\n");
2242 if ((frame_padtop % 2) != 0) {
2243 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2248 static void opt_frame_pad_bottom(const char *arg)
2250 frame_padbottom = atoi(arg);
2251 if (frame_padbottom < 0) {
2252 fprintf(stderr, "Incorrect bottom pad size\n");
2255 if ((frame_padbottom % 2) != 0) {
2256 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2262 static void opt_frame_pad_left(const char *arg)
2264 frame_padleft = atoi(arg);
2265 if (frame_padleft < 0) {
2266 fprintf(stderr, "Incorrect left pad size\n");
2269 if ((frame_padleft % 2) != 0) {
2270 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2276 static void opt_frame_pad_right(const char *arg)
2278 frame_padright = atoi(arg);
2279 if (frame_padright < 0) {
2280 fprintf(stderr, "Incorrect right pad size\n");
2283 if ((frame_padright % 2) != 0) {
2284 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2290 static void opt_frame_pix_fmt(const char *arg)
2292 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2295 static void opt_frame_aspect_ratio(const char *arg)
2301 p = strchr(arg, ':');
2303 x = strtol(arg, (char **)&arg, 10);
2305 y = strtol(arg+1, (char **)&arg, 10);
2307 ar = (double)x / (double)y;
2309 ar = strtod(arg, (char **)&arg);
2312 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2315 frame_aspect_ratio = ar;
2318 static void opt_qscale(const char *arg)
2320 video_qscale = atof(arg);
2321 if (video_qscale <= 0 ||
2322 video_qscale > 255) {
2323 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2328 static void opt_lmax(const char *arg)
2330 video_lmax = atof(arg)*FF_QP2LAMBDA;
2333 static void opt_lmin(const char *arg)
2335 video_lmin = atof(arg)*FF_QP2LAMBDA;
2338 static void opt_mb_lmin(const char *arg)
2340 video_mb_lmin = atof(arg)*FF_QP2LAMBDA;
2341 if (video_mb_lmin < 1 ||
2342 video_mb_lmin > FF_LAMBDA_MAX) {
2343 fprintf(stderr, "mblmin must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2348 static void opt_mb_lmax(const char *arg)
2350 video_mb_lmax = atof(arg)*FF_QP2LAMBDA;
2351 if (video_mb_lmax < 1 ||
2352 video_mb_lmax > FF_LAMBDA_MAX) {
2353 fprintf(stderr, "mblmax must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2358 static void opt_qdiff(const char *arg)
2360 video_qdiff = atoi(arg);
2361 if (video_qdiff < 0 ||
2363 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2368 static void opt_packet_size(const char *arg)
2370 packet_size= atoi(arg);
2373 static void opt_error_rate(const char *arg)
2375 error_rate= atoi(arg);
2378 static void opt_strict(const char *arg)
2383 static void opt_top_field_first(const char *arg)
2385 top_field_first= atoi(arg);
2388 static void opt_thread_count(const char *arg)
2390 thread_count= atoi(arg);
2391 #if !defined(HAVE_THREADS)
2393 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2397 static void opt_audio_bitrate(const char *arg)
2399 audio_bit_rate = atoi(arg) * 1000;
2402 static void opt_audio_rate(const char *arg)
2404 audio_sample_rate = atoi(arg);
2407 static void opt_audio_channels(const char *arg)
2409 audio_channels = atoi(arg);
2412 static void opt_video_device(const char *arg)
2414 video_device = av_strdup(arg);
2417 static void opt_grab_device(const char *arg)
2419 grab_device = av_strdup(arg);
2422 static void opt_video_channel(const char *arg)
2424 video_channel = strtol(arg, NULL, 0);
2427 static void opt_video_standard(const char *arg)
2429 video_standard = av_strdup(arg);
2432 static void opt_audio_device(const char *arg)
2434 audio_device = av_strdup(arg);
2437 static void opt_codec(int *pstream_copy, int *pcodec_id,
2438 int codec_type, const char *arg)
2442 if (!strcmp(arg, "copy")) {
2447 if (!strcmp(p->name, arg) && p->type == codec_type)
2452 fprintf(stderr, "Unknown codec '%s'\n", arg);
2460 static void opt_audio_codec(const char *arg)
2462 opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2465 static void opt_audio_tag(const char *arg)
2468 audio_codec_tag= strtol(arg, &tail, 0);
2471 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2474 static void opt_video_tag(const char *arg)
2477 video_codec_tag= strtol(arg, &tail, 0);
2480 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2483 static void add_frame_hooker(const char *arg)
2488 char *args = av_strdup(arg);
2492 argv[0] = strtok(args, " ");
2493 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2496 i = frame_hook_add(argc, argv);
2499 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2504 const char *motion_str[] = {
2517 static void opt_motion_estimation(const char *arg)
2523 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2526 if (!strcmp(*p, arg))
2530 me_method = (p - motion_str) + 1;
2533 static void opt_video_codec(const char *arg)
2535 opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2538 static void opt_subtitle_codec(const char *arg)
2540 opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2543 static void opt_map(const char *arg)
2549 m = &stream_maps[nb_stream_maps++];
2551 m->file_index = strtol(arg, (char **)&p, 0);
2555 m->stream_index = strtol(p, (char **)&p, 0);
2558 m->sync_file_index = strtol(p, (char **)&p, 0);
2561 m->sync_stream_index = strtol(p, (char **)&p, 0);
2563 m->sync_file_index = m->file_index;
2564 m->sync_stream_index = m->stream_index;
2568 static void opt_map_meta_data(const char *arg)
2574 m = &meta_data_maps[nb_meta_data_maps++];
2576 m->out_file = strtol(arg, (char **)&p, 0);
2580 m->in_file = strtol(p, (char **)&p, 0);
2583 static void opt_recording_time(const char *arg)
2585 recording_time = parse_date(arg, 1);
2588 static void opt_start_time(const char *arg)
2590 start_time = parse_date(arg, 1);
2593 static void opt_rec_timestamp(const char *arg)
2595 rec_timestamp = parse_date(arg, 0) / 1000000;
2598 static void opt_input_ts_offset(const char *arg)
2600 input_ts_offset = parse_date(arg, 1);
2603 static void opt_input_file(const char *filename)
2605 AVFormatContext *ic;
2606 AVFormatParameters params, *ap = ¶ms;
2607 int err, i, ret, rfps, rfps_base;
2610 if (!strcmp(filename, "-"))
2613 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2614 !strcmp( filename, "/dev/stdin" );
2616 /* get default parameters from command line */
2617 ic = av_alloc_format_context();
2619 memset(ap, 0, sizeof(*ap));
2620 ap->prealloced_context = 1;
2621 ap->sample_rate = audio_sample_rate;
2622 ap->channels = audio_channels;
2623 ap->time_base.den = frame_rate;
2624 ap->time_base.num = frame_rate_base;
2625 ap->width = frame_width + frame_padleft + frame_padright;
2626 ap->height = frame_height + frame_padtop + frame_padbottom;
2627 ap->image_format = image_format;
2628 ap->pix_fmt = frame_pix_fmt;
2629 ap->device = grab_device;
2630 ap->channel = video_channel;
2631 ap->standard = video_standard;
2632 ap->video_codec_id = video_codec_id;
2633 ap->audio_codec_id = audio_codec_id;
2634 if(pgmyuv_compatibility_hack)
2635 ap->video_codec_id= CODEC_ID_PGMYUV;
2637 for(i=0; i<opt_name_count; i++){
2639 double d= av_get_double(avformat_opts, opt_names[i], &opt);
2640 if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2641 av_set_double(ic, opt_names[i], d);
2643 /* open the input file with generic libav function */
2644 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2646 print_error(filename, err);
2650 ic->loop_input = loop_input;
2652 /* If not enough info to get the stream parameters, we decode the
2653 first frames to get it. (used in mpeg case for example) */
2654 ret = av_find_stream_info(ic);
2655 if (ret < 0 && verbose >= 0) {
2656 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2660 timestamp = start_time;
2661 /* add the stream start time */
2662 if (ic->start_time != AV_NOPTS_VALUE)
2663 timestamp += ic->start_time;
2665 /* if seeking requested, we execute it */
2666 if (start_time != 0) {
2667 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2669 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2670 filename, (double)timestamp / AV_TIME_BASE);
2672 /* reset seek info */
2676 /* update the current parameters so that they match the one of the input stream */
2677 for(i=0;i<ic->nb_streams;i++) {
2679 AVCodecContext *enc = ic->streams[i]->codec;
2680 #if defined(HAVE_THREADS)
2682 avcodec_thread_init(enc, thread_count);
2684 enc->thread_count= thread_count;
2685 switch(enc->codec_type) {
2686 case CODEC_TYPE_AUDIO:
2687 for(j=0; j<opt_name_count; j++){
2689 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2690 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2691 av_set_double(enc, opt_names[j], d);
2693 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2694 audio_channels = enc->channels;
2695 audio_sample_rate = enc->sample_rate;
2697 ic->streams[i]->discard= AVDISCARD_ALL;
2699 case CODEC_TYPE_VIDEO:
2700 for(j=0; j<opt_name_count; j++){
2702 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2703 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2704 av_set_double(enc, opt_names[j], d);
2706 frame_height = enc->height;
2707 frame_width = enc->width;
2708 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2709 frame_pix_fmt = enc->pix_fmt;
2710 rfps = ic->streams[i]->r_frame_rate.num;
2711 rfps_base = ic->streams[i]->r_frame_rate.den;
2712 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2714 enc->debug |= FF_DEBUG_MV;
2716 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2719 fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2720 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2722 (float)rfps / rfps_base, rfps, rfps_base);
2724 /* update the current frame rate to match the stream frame rate */
2726 frame_rate_base = rfps_base;
2728 enc->rate_emu = rate_emu;
2730 ic->streams[i]->discard= AVDISCARD_ALL;
2731 else if(video_discard)
2732 ic->streams[i]->discard= video_discard;
2734 case CODEC_TYPE_DATA:
2736 case CODEC_TYPE_SUBTITLE:
2738 case CODEC_TYPE_UNKNOWN:
2745 input_files[nb_input_files] = ic;
2746 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2747 /* dump the file content */
2749 dump_format(ic, nb_input_files, filename, 0);
2752 file_iformat = NULL;
2753 file_oformat = NULL;
2754 image_format = NULL;
2762 static void opt_grab(const char *arg)
2764 file_iformat = av_find_input_format(arg);
2768 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2770 int has_video, has_audio, i, j;
2771 AVFormatContext *ic;
2775 for(j=0;j<nb_input_files;j++) {
2776 ic = input_files[j];
2777 for(i=0;i<ic->nb_streams;i++) {
2778 AVCodecContext *enc = ic->streams[i]->codec;
2779 switch(enc->codec_type) {
2780 case CODEC_TYPE_AUDIO:
2783 case CODEC_TYPE_VIDEO:
2786 case CODEC_TYPE_DATA:
2787 case CODEC_TYPE_UNKNOWN:
2788 case CODEC_TYPE_SUBTITLE:
2795 *has_video_ptr = has_video;
2796 *has_audio_ptr = has_audio;
2799 static void new_video_stream(AVFormatContext *oc)
2802 AVCodecContext *video_enc;
2805 st = av_new_stream(oc, oc->nb_streams);
2807 fprintf(stderr, "Could not alloc stream\n");
2810 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2811 video_bitstream_filters= NULL;
2813 #if defined(HAVE_THREADS)
2815 avcodec_thread_init(st->codec, thread_count);
2818 video_enc = st->codec;
2821 video_enc->codec_tag= video_codec_tag;
2823 if( (video_global_header&1)
2824 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2825 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2826 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2828 if(video_global_header&2){
2829 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2830 avctx_opts->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2833 if (video_stream_copy) {
2834 st->stream_copy = 1;
2835 video_enc->codec_type = CODEC_TYPE_VIDEO;
2841 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2842 if (video_codec_id != CODEC_ID_NONE)
2843 codec_id = video_codec_id;
2845 video_enc->codec_id = codec_id;
2846 codec = avcodec_find_encoder(codec_id);
2848 for(i=0; i<opt_name_count; i++){
2850 double d= av_get_double(avctx_opts, opt_names[i], &opt);
2851 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2852 av_set_double(video_enc, opt_names[i], d);
2855 video_enc->time_base.den = frame_rate;
2856 video_enc->time_base.num = frame_rate_base;
2857 if(codec && codec->supported_framerates){
2858 const AVRational *p= codec->supported_framerates;
2859 AVRational req= (AVRational){frame_rate, frame_rate_base};
2860 const AVRational *best=NULL;
2861 AVRational best_error= (AVRational){INT_MAX, 1};
2862 for(; p->den!=0; p++){
2863 AVRational error= av_sub_q(req, *p);
2864 if(error.num <0) error.num *= -1;
2865 if(av_cmp_q(error, best_error) < 0){
2870 video_enc->time_base.den= best->num;
2871 video_enc->time_base.num= best->den;
2874 video_enc->width = frame_width + frame_padright + frame_padleft;
2875 video_enc->height = frame_height + frame_padtop + frame_padbottom;
2876 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2877 video_enc->pix_fmt = frame_pix_fmt;
2879 if(codec && codec->pix_fmts){
2880 const enum PixelFormat *p= codec->pix_fmts;
2882 if(*p == video_enc->pix_fmt)
2886 video_enc->pix_fmt = codec->pix_fmts[0];
2890 video_enc->gop_size = 0;
2891 if (video_qscale || same_quality) {
2892 video_enc->flags |= CODEC_FLAG_QSCALE;
2893 video_enc->global_quality=
2894 st->quality = FF_QP2LAMBDA * video_qscale;
2898 video_enc->intra_matrix = intra_matrix;
2900 video_enc->inter_matrix = inter_matrix;
2902 video_enc->lmin = video_lmin;
2903 video_enc->lmax = video_lmax;
2904 video_enc->mb_lmin = video_mb_lmin;
2905 video_enc->mb_lmax = video_mb_lmax;
2906 video_enc->max_qdiff = video_qdiff;
2907 video_enc->rc_eq = video_rc_eq;
2908 video_enc->thread_count = thread_count;
2909 p= video_rc_override_string;
2912 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2914 fprintf(stderr, "error parsing rc_override\n");
2917 video_enc->rc_override=
2918 av_realloc(video_enc->rc_override,
2919 sizeof(RcOverride)*(i+1));
2920 video_enc->rc_override[i].start_frame= start;
2921 video_enc->rc_override[i].end_frame = end;
2923 video_enc->rc_override[i].qscale= q;
2924 video_enc->rc_override[i].quality_factor= 1.0;
2927 video_enc->rc_override[i].qscale= 0;
2928 video_enc->rc_override[i].quality_factor= -q/100.0;
2933 video_enc->rc_override_count=i;
2934 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2935 video_enc->me_threshold= me_threshold;
2936 video_enc->intra_dc_precision= intra_dc_precision - 8;
2937 video_enc->strict_std_compliance = strict;
2938 video_enc->error_rate = error_rate;
2939 video_enc->me_penalty_compensation= me_penalty_compensation;
2940 video_enc->frame_skip_threshold= frame_skip_threshold;
2941 video_enc->frame_skip_factor= frame_skip_factor;
2942 video_enc->frame_skip_exp= frame_skip_exp;
2945 video_enc->rtp_mode= 1;
2946 video_enc->rtp_payload_size= packet_size;
2950 video_enc->flags|= CODEC_FLAG_PSNR;
2952 video_enc->me_method = me_method;
2957 video_enc->flags |= CODEC_FLAG_PASS1;
2959 video_enc->flags |= CODEC_FLAG_PASS2;
2964 /* reset some key parameters */
2966 video_codec_id = CODEC_ID_NONE;
2967 video_stream_copy = 0;
2970 static void new_audio_stream(AVFormatContext *oc)
2973 AVCodecContext *audio_enc;
2976 st = av_new_stream(oc, oc->nb_streams);
2978 fprintf(stderr, "Could not alloc stream\n");
2982 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2983 audio_bitstream_filters= NULL;
2985 #if defined(HAVE_THREADS)
2987 avcodec_thread_init(st->codec, thread_count);
2990 audio_enc = st->codec;
2991 audio_enc->codec_type = CODEC_TYPE_AUDIO;
2994 audio_enc->codec_tag= audio_codec_tag;
2996 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
2997 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2998 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
3000 if (audio_stream_copy) {
3001 st->stream_copy = 1;
3002 audio_enc->channels = audio_channels;
3004 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3006 for(i=0; i<opt_name_count; i++){
3008 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3009 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3010 av_set_double(audio_enc, opt_names[i], d);
3013 if (audio_codec_id != CODEC_ID_NONE)
3014 codec_id = audio_codec_id;
3015 audio_enc->codec_id = codec_id;
3017 audio_enc->bit_rate = audio_bit_rate;
3018 if (audio_qscale > QSCALE_NONE) {
3019 audio_enc->flags |= CODEC_FLAG_QSCALE;
3020 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3022 audio_enc->strict_std_compliance = strict;
3023 audio_enc->thread_count = thread_count;
3024 /* For audio codecs other than AC3 or DTS we limit */
3025 /* the number of coded channels to stereo */
3026 if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3027 && codec_id != CODEC_ID_DTS) {
3028 audio_enc->channels = 2;
3030 audio_enc->channels = audio_channels;
3032 audio_enc->sample_rate = audio_sample_rate;
3033 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3034 if (audio_language) {
3035 pstrcpy(st->language, sizeof(st->language), audio_language);
3036 av_free(audio_language);
3037 audio_language = NULL;
3040 /* reset some key parameters */
3042 audio_codec_id = CODEC_ID_NONE;
3043 audio_stream_copy = 0;
3046 static void opt_new_subtitle_stream(void)
3048 AVFormatContext *oc;
3050 AVCodecContext *subtitle_enc;
3053 if (nb_output_files <= 0) {
3054 fprintf(stderr, "At least one output file must be specified\n");
3057 oc = output_files[nb_output_files - 1];
3059 st = av_new_stream(oc, oc->nb_streams);
3061 fprintf(stderr, "Could not alloc stream\n");
3065 subtitle_enc = st->codec;
3066 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3067 if (subtitle_stream_copy) {
3068 st->stream_copy = 1;
3070 for(i=0; i<opt_name_count; i++){
3072 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3073 if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3074 av_set_double(subtitle_enc, opt_names[i], d);
3076 subtitle_enc->codec_id = subtitle_codec_id;
3079 if (subtitle_language) {
3080 pstrcpy(st->language, sizeof(st->language), subtitle_language);
3081 av_free(subtitle_language);
3082 subtitle_language = NULL;
3085 subtitle_codec_id = CODEC_ID_NONE;
3086 subtitle_stream_copy = 0;
3089 static void opt_new_audio_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_audio_stream(oc);
3100 static void opt_new_video_stream(void)
3102 AVFormatContext *oc;
3103 if (nb_output_files <= 0) {
3104 fprintf(stderr, "At least one output file must be specified\n");
3107 oc = output_files[nb_output_files - 1];
3108 new_video_stream(oc);
3111 static void opt_output_file(const char *filename)
3113 AVFormatContext *oc;
3114 int use_video, use_audio, input_has_video, input_has_audio, i;
3115 AVFormatParameters params, *ap = ¶ms;
3117 if (!strcmp(filename, "-"))
3120 oc = av_alloc_format_context();
3122 if (!file_oformat) {
3123 file_oformat = guess_format(NULL, filename, NULL);
3124 if (!file_oformat) {
3125 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3131 oc->oformat = file_oformat;
3132 pstrcpy(oc->filename, sizeof(oc->filename), filename);
3134 if (!strcmp(file_oformat->name, "ffm") &&
3135 strstart(filename, "http:", NULL)) {
3136 /* special case for files sent to ffserver: we get the stream
3137 parameters from ffserver */
3138 if (read_ffserver_streams(oc, filename) < 0) {
3139 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3143 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3144 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3146 /* disable if no corresponding type found and at least one
3148 if (nb_input_files > 0) {
3149 check_audio_video_inputs(&input_has_video, &input_has_audio);
3150 if (!input_has_video)
3152 if (!input_has_audio)
3156 /* manual disable */
3157 if (audio_disable) {
3160 if (video_disable) {
3165 new_video_stream(oc);
3169 new_audio_stream(oc);
3172 if (!oc->nb_streams) {
3173 fprintf(stderr, "No audio or video streams available\n");
3177 oc->timestamp = rec_timestamp;
3180 pstrcpy(oc->title, sizeof(oc->title), str_title);
3182 pstrcpy(oc->author, sizeof(oc->author), str_author);
3184 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3186 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3188 pstrcpy(oc->album, sizeof(oc->album), str_album);
3191 output_files[nb_output_files++] = oc;
3193 /* check filename in case of an image number is expected */
3194 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3195 if (!av_filename_number_test(oc->filename)) {
3196 print_error(oc->filename, AVERROR_NUMEXPECTED);
3201 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3202 /* test if it already exists to avoid loosing precious files */
3203 if (!file_overwrite &&
3204 (strchr(filename, ':') == NULL ||
3205 strstart(filename, "file:", NULL))) {
3206 if (url_exist(filename)) {
3209 if ( !using_stdin ) {
3210 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3213 if (toupper(c) != 'Y') {
3214 fprintf(stderr, "Not overwriting - exiting\n");
3219 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3226 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3227 fprintf(stderr, "Could not open '%s'\n", filename);
3232 memset(ap, 0, sizeof(*ap));
3233 ap->image_format = image_format;
3234 if (av_set_parameters(oc, ap) < 0) {
3235 fprintf(stderr, "%s: Invalid encoding parameters\n",
3240 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3241 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3242 oc->loop_output = loop_output;
3244 for(i=0; i<opt_name_count; i++){
3246 double d = av_get_double(avformat_opts, opt_names[i], &opt);
3247 if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3248 av_set_double(oc, opt_names[i], d);
3251 /* reset some options */
3252 file_oformat = NULL;
3253 file_iformat = NULL;
3254 image_format = NULL;
3257 /* prepare dummy protocols for grab */
3258 static void prepare_grab(void)
3260 int has_video, has_audio, i, j;
3261 AVFormatContext *oc;
3262 AVFormatContext *ic;
3263 AVFormatParameters vp1, *vp = &vp1;
3264 AVFormatParameters ap1, *ap = &ap1;
3266 /* see if audio/video inputs are needed */
3269 memset(ap, 0, sizeof(*ap));
3270 memset(vp, 0, sizeof(*vp));
3271 vp->time_base.num= 1;
3272 for(j=0;j<nb_output_files;j++) {
3273 oc = output_files[j];
3274 for(i=0;i<oc->nb_streams;i++) {
3275 AVCodecContext *enc = oc->streams[i]->codec;
3276 switch(enc->codec_type) {
3277 case CODEC_TYPE_AUDIO:
3278 if (enc->sample_rate > ap->sample_rate)
3279 ap->sample_rate = enc->sample_rate;
3280 if (enc->channels > ap->channels)
3281 ap->channels = enc->channels;
3284 case CODEC_TYPE_VIDEO:
3285 if (enc->width > vp->width)
3286 vp->width = enc->width;
3287 if (enc->height > vp->height)
3288 vp->height = enc->height;
3290 if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
3291 vp->time_base = enc->time_base;
3292 vp->width += frame_leftBand + frame_rightBand;
3293 vp->width -= (frame_padleft + frame_padright);
3294 vp->height += frame_topBand + frame_bottomBand;
3295 vp->height -= (frame_padtop + frame_padbottom);
3305 if (has_video == 0 && has_audio == 0) {
3306 fprintf(stderr, "Output file must have at least one audio or video stream\n");
3311 AVInputFormat *fmt1;
3312 fmt1 = av_find_input_format(video_grab_format);
3313 vp->device = video_device;
3314 vp->channel = video_channel;
3315 vp->standard = video_standard;
3316 vp->pix_fmt = frame_pix_fmt;
3317 if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3318 fprintf(stderr, "Could not find video grab device\n");
3321 /* If not enough info to get the stream parameters, we decode the
3322 first frames to get it. */
3323 if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3324 fprintf(stderr, "Could not find video grab parameters\n");
3327 /* by now video grab has one stream */
3328 ic->streams[0]->r_frame_rate.num = vp->time_base.den;
3329 ic->streams[0]->r_frame_rate.den = vp->time_base.num;
3330 input_files[nb_input_files] = ic;
3333 dump_format(ic, nb_input_files, "", 0);
3337 if (has_audio && audio_grab_format) {
3338 AVInputFormat *fmt1;
3339 fmt1 = av_find_input_format(audio_grab_format);
3340 ap->device = audio_device;
3341 if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3342 fprintf(stderr, "Could not find audio grab device\n");
3345 input_files[nb_input_files] = ic;
3348 dump_format(ic, nb_input_files, "", 0);
3354 /* same option as mencoder */
3355 static void opt_pass(const char *pass_str)
3358 pass = atoi(pass_str);
3359 if (pass != 1 && pass != 2) {
3360 fprintf(stderr, "pass number can be only 1 or 2\n");
3366 #if defined(__MINGW32__) || defined(CONFIG_OS2)
3367 static int64_t getutime(void)
3369 return av_gettime();
3372 static int64_t getutime(void)
3374 struct rusage rusage;
3376 getrusage(RUSAGE_SELF, &rusage);
3377 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3381 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3382 extern int ffm_nopts;
3385 static void show_formats(void)
3387 AVInputFormat *ifmt;
3388 AVOutputFormat *ofmt;
3389 AVImageFormat *image_fmt;
3392 const char **pp, *last_name;
3394 printf("File formats:\n");
3399 const char *name=NULL;
3400 const char *long_name=NULL;
3402 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3403 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3404 strcmp(ofmt->name, last_name)>0){
3406 long_name= ofmt->long_name;
3410 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3411 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3412 strcmp(ifmt->name, last_name)>0){
3414 long_name= ifmt->long_name;
3417 if(name && strcmp(ifmt->name, name)==0)
3429 long_name ? long_name:" ");
3433 printf("Image formats (filename extensions, if any, follow):\n");
3434 for(image_fmt = first_image_format; image_fmt != NULL;
3435 image_fmt = image_fmt->next) {
3438 image_fmt->img_read ? "D":" ",
3439 image_fmt->img_write ? "E":" ",
3441 image_fmt->extensions ? image_fmt->extensions:" ");
3445 printf("Codecs:\n");
3451 const char *type_str;
3454 for(p = first_avcodec; p != NULL; p = p->next) {
3455 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3456 strcmp(p->name, last_name)>0){
3458 decode= encode= cap=0;
3460 if(p2 && strcmp(p->name, p2->name)==0){
3461 if(p->decode) decode=1;
3462 if(p->encode) encode=1;
3463 cap |= p->capabilities;
3468 last_name= p2->name;
3471 case CODEC_TYPE_VIDEO:
3474 case CODEC_TYPE_AUDIO:
3477 case CODEC_TYPE_SUBTITLE:
3486 decode ? "D": (/*p2->decoder ? "d":*/" "),
3489 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3490 cap & CODEC_CAP_DR1 ? "D":" ",
3491 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3493 /* if(p2->decoder && decode==0)
3494 printf(" use %s for decoding", p2->decoder->name);*/
3499 printf("Supported file protocols:\n");
3500 for(up = first_protocol; up != NULL; up = up->next)
3501 printf(" %s:", up->name);
3504 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3505 printf("Motion estimation methods:\n");
3509 if ((pp - motion_str + 1) == ME_ZERO)
3510 printf("(fastest)");
3511 else if ((pp - motion_str + 1) == ME_FULL)
3512 printf("(slowest)");
3513 else if ((pp - motion_str + 1) == ME_EPZS)
3514 printf("(default)");
3519 "Note, the names of encoders and decoders dont always match, so there are\n"
3520 "several cases where the above table shows encoder only or decoder only entries\n"
3521 "even though both encoding and decoding are supported for example, the h263\n"
3522 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3527 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3530 const char *p = str;
3537 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3544 static void opt_inter_matrix(const char *arg)
3546 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3547 parse_matrix_coeffs(inter_matrix, arg);
3550 static void opt_intra_matrix(const char *arg)
3552 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3553 parse_matrix_coeffs(intra_matrix, arg);
3556 static void opt_target(const char *arg)
3559 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3561 if(!strncmp(arg, "pal-", 4)) {
3564 } else if(!strncmp(arg, "ntsc-", 5)) {
3567 } else if(!strncmp(arg, "film-", 5)) {
3572 /* Calculate FR via float to avoid int overflow */
3573 fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3576 } else if((fr == 29970) || (fr == 23976)) {
3579 /* Try to determine PAL/NTSC by peeking in the input files */
3580 if(nb_input_files) {
3582 for(j = 0; j < nb_input_files; j++) {
3583 for(i = 0; i < input_files[j]->nb_streams; i++) {
3584 AVCodecContext *c = input_files[j]->streams[i]->codec;
3585 if(c->codec_type != CODEC_TYPE_VIDEO)
3587 fr = c->time_base.den * 1000 / c->time_base.num;
3591 } else if((fr == 29970) || (fr == 23976)) {
3601 if(verbose && norm >= 0)
3602 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3606 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3607 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3608 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3612 if(!strcmp(arg, "vcd")) {
3614 opt_video_codec("mpeg1video");
3615 opt_audio_codec("mp2");
3618 opt_frame_size(norm ? "352x240" : "352x288");
3619 opt_frame_rate(frame_rates[norm]);
3620 opt_default("gop", norm ? "18" : "15");
3622 opt_default("b", "1150000");
3623 opt_default("maxrate", "1150000");
3624 opt_default("minrate", "1150000");
3625 opt_default("bufsize", "327680"); // 40*1024*8;
3627 audio_bit_rate = 224000;
3628 audio_sample_rate = 44100;
3630 opt_default("packetsize", "2324");
3631 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3633 /* We have to offset the PTS, so that it is consistent with the SCR.
3634 SCR starts at 36000, but the first two packs contain only padding
3635 and the first pack from the other stream, respectively, may also have
3636 been written before.
3637 So the real data starts at SCR 36000+3*1200. */
3638 mux_preload= (36000+3*1200) / 90000.0; //0.44
3639 } else if(!strcmp(arg, "svcd")) {
3641 opt_video_codec("mpeg2video");
3642 opt_audio_codec("mp2");
3645 opt_frame_size(norm ? "480x480" : "480x576");
3646 opt_frame_rate(frame_rates[norm]);
3647 opt_default("gop", norm ? "18" : "15");
3649 opt_default("b", "2040000");
3650 opt_default("maxrate", "2516000");
3651 opt_default("minrate", "0"); //1145000;
3652 opt_default("bufsize", "1835008"); //224*1024*8;
3653 opt_default("flags", "+SCAN_OFFSET");
3656 audio_bit_rate = 224000;
3657 audio_sample_rate = 44100;
3659 opt_default("packetsize", "2324");
3661 } else if(!strcmp(arg, "dvd")) {
3663 opt_video_codec("mpeg2video");
3664 opt_audio_codec("ac3");
3667 opt_frame_size(norm ? "720x480" : "720x576");
3668 opt_frame_rate(frame_rates[norm]);
3669 opt_default("gop", norm ? "18" : "15");
3671 opt_default("b", "6000000");
3672 opt_default("maxrate", "9000000");
3673 opt_default("minrate", "0"); //1500000;
3674 opt_default("bufsize", "1835008"); //224*1024*8;
3676 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3677 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3679 audio_bit_rate = 448000;
3680 audio_sample_rate = 48000;
3682 } else if(!strncmp(arg, "dv", 2)) {
3686 opt_frame_size(norm ? "720x480" : "720x576");
3687 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3688 (norm ? "yuv411p" : "yuv420p"));
3689 opt_frame_rate(frame_rates[norm]);
3691 audio_sample_rate = 48000;
3695 fprintf(stderr, "Unknown target: %s\n", arg);
3700 static void opt_video_bsf(const char *arg)
3702 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3703 AVBitStreamFilterContext **bsfp;
3706 fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3710 bsfp= &video_bitstream_filters;
3712 bsfp= &(*bsfp)->next;
3717 //FIXME avoid audio - video code duplication
3718 static void opt_audio_bsf(const char *arg)
3720 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3721 AVBitStreamFilterContext **bsfp;
3724 fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3728 bsfp= &audio_bitstream_filters;
3730 bsfp= &(*bsfp)->next;
3735 static void show_version(void)
3737 /* TODO: add function interface to avutil and avformat */
3738 fprintf(stderr, "ffmpeg " FFMPEG_VERSION "\n"
3742 LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3746 static int opt_default(const char *opt, const char *arg){
3747 AVOption *o= av_set_string(avctx_opts, opt, arg);
3749 o = av_set_string(avformat_opts, opt, arg);
3753 // 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));
3755 //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
3756 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
3757 opt_names[opt_name_count++]= o->name;
3759 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3760 /* disable generate of real time pts in ffm (need to be supressed anyway) */
3761 if(avctx_opts->flags & CODEC_FLAG_BITEXACT)
3765 if(avctx_opts->debug)
3766 av_log_set_level(AV_LOG_DEBUG);
3770 const OptionDef options[] = {
3772 { "L", 0, {(void*)show_license}, "show license" },
3773 { "h", 0, {(void*)show_help}, "show help" },
3774 { "version", 0, {(void*)show_version}, "show version" },
3775 { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3776 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3777 { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
3778 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3779 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3780 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3781 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3782 { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3783 { "fs", HAS_ARG | OPT_INT, {(void*)&limit_filesize}, "set the limit file size", "limit_size" }, //
3784 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3785 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3786 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3787 { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3788 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3789 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3790 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3791 { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3792 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3793 "add timings for benchmarking" },
3794 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3795 "dump each input packet" },
3796 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3797 "when dumping packets, also dump the payload" },
3798 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3799 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3800 { "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)", "" },
3801 { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3802 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3803 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3804 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3805 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3806 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3807 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3808 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3809 { "dts_delta_threshold", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
3812 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3813 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3814 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3815 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3816 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3817 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3818 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3819 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3820 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3821 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3822 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3823 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3824 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3825 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3826 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3827 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3828 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3829 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3830 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3831 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
3832 { "lmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmin}, "min video lagrange factor (VBR)", "lambda" },
3833 { "lmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmax}, "max video lagrange factor (VBR)", "lambda" },
3834 { "mblmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmin}, "min macroblock quantiser scale (VBR)", "q" },
3835 { "mblmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmax}, "max macroblock quantiser scale (VBR)", "q" },
3836 { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
3837 { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3838 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3839 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3840 { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
3842 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "" },
3843 { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
3844 { "error", HAS_ARG | OPT_EXPERT, {(void*)opt_error_rate}, "error rate", "rate" },
3845 { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3846 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3847 "use same video quality as source (implies VBR)" },
3848 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3849 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3850 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3851 "deinterlace pictures" },
3852 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3853 { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
3854 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3855 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3856 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3857 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3858 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3859 { "mepc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&me_penalty_compensation}, "motion estimation bitrate penalty compensation", "factor (1.0 = 256)" },
3860 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3861 { "skip_threshold", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_threshold}, "frame skip threshold", "threshold" },
3862 { "skip_factor", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_factor}, "frame skip factor", "factor" },
3863 { "skip_exp", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_exp}, "frame skip exponent", "exponent" },
3864 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3865 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3868 { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
3869 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3870 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3871 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3872 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3873 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3874 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3875 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3876 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3877 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3879 /* subtitle options */
3880 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3881 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3882 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3885 { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
3886 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3887 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3888 { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
3890 /* G.2 grab options */
3891 { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
3892 { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
3895 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3896 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3898 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
3899 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
3901 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3905 static void show_banner(void)
3907 fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2004 Fabrice Bellard\n");
3908 fprintf(stderr, " configuration: " FFMPEG_CONFIGURATION "\n");
3909 fprintf(stderr, " libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
3910 fprintf(stderr, " libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
3911 fprintf(stderr, " libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
3912 fprintf(stderr, " built on " __DATE__ " " __TIME__);
3914 fprintf(stderr, ", gcc: " __VERSION__ "\n");
3916 fprintf(stderr, ", using a non-gcc compiler\n");
3920 static void show_license(void)
3925 "This program is free software; you can redistribute it and/or modify\n"
3926 "it under the terms of the GNU General Public License as published by\n"
3927 "the Free Software Foundation; either version 2 of the License, or\n"
3928 "(at your option) any later version.\n"
3930 "This program 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\n"
3933 "GNU General Public License for more details.\n"
3935 "You should have received a copy of the GNU General Public License\n"
3936 "along with this program; if not, write to the Free Software\n"
3937 "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n"
3941 "This library is free software; you can redistribute it and/or\n"
3942 "modify it under the terms of the GNU Lesser General Public\n"
3943 "License as published by the Free Software Foundation; either\n"
3944 "version 2 of the License, or (at your option) any later version.\n"
3946 "This library is distributed in the hope that it will be useful,\n"
3947 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3948 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
3949 "Lesser General Public License for more details.\n"
3951 "You should have received a copy of the GNU Lesser General Public\n"
3952 "License along with this library; if not, write to the Free Software\n"
3953 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
3959 static void show_help(void)
3962 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3963 "Hyper fast Audio and Video encoder\n");
3965 show_help_options(options, "Main options:\n",
3966 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3967 show_help_options(options, "\nVideo options:\n",
3968 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3970 show_help_options(options, "\nAdvanced Video options:\n",
3971 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3972 OPT_VIDEO | OPT_EXPERT);
3973 show_help_options(options, "\nAudio options:\n",
3974 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3976 show_help_options(options, "\nAdvanced Audio options:\n",
3977 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3978 OPT_AUDIO | OPT_EXPERT);
3979 show_help_options(options, "\nSubtitle options:\n",
3980 OPT_SUBTITLE | OPT_GRAB,
3982 show_help_options(options, "\nAudio/Video grab options:\n",
3985 show_help_options(options, "\nAdvanced options:\n",
3986 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3988 av_opt_show(avctx_opts, NULL);
3989 av_opt_show(avformat_opts, NULL);
3994 void parse_arg_file(const char *filename)
3996 opt_output_file(filename);
3999 int main(int argc, char **argv)
4006 avctx_opts= avcodec_alloc_context();
4007 avformat_opts = av_alloc_format_context();
4015 parse_options(argc, argv, options);
4017 /* file converter / grab */
4018 if (nb_output_files <= 0) {
4019 fprintf(stderr, "Must supply at least one output file\n");
4023 if (nb_input_files == 0) {
4029 av_encode(output_files, nb_output_files, input_files, nb_input_files,
4030 stream_maps, nb_stream_maps);
4031 ti = getutime() - ti;
4033 printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4037 for(i=0;i<nb_output_files;i++) {
4038 /* maybe av_close_output_file ??? */
4039 AVFormatContext *s = output_files[i];
4041 if (!(s->oformat->flags & AVFMT_NOFILE))
4043 for(j=0;j<s->nb_streams;j++)
4044 av_free(s->streams[j]);
4047 for(i=0;i<nb_input_files;i++)
4048 av_close_input_file(input_files[i]);
4053 av_free(intra_matrix);
4055 av_free(inter_matrix);
4057 #ifdef POWERPC_PERFORMANCE_REPORT
4058 extern void powerpc_display_perf_report(void);
4059 powerpc_display_perf_report();
4060 #endif /* POWERPC_PERFORMANCE_REPORT */
4063 if (received_sigterm) {
4065 "Received signal %d: terminating.\n",
4066 (int) received_sigterm);
4070 exit(0); /* not all OS-es handle main() return value */