3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 #define HAVE_AV_CONFIG_H
25 #include "framehook.h"
33 #include <sys/ioctl.h>
36 #include <sys/resource.h>
40 #include <sys/types.h>
41 #include <sys/select.h>
44 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
53 #if !defined(INFINITY) && defined(HUGE_VAL)
54 #define INFINITY HUGE_VAL
57 /* select an input stream for an output stream */
58 typedef struct AVStreamMap {
62 int sync_stream_index;
65 /** select an input file for an output file */
66 typedef struct AVMetaDataMap {
71 extern const OptionDef options[];
73 static void show_help(void);
74 static void show_license(void);
75 static int opt_default(const char *opt, const char *arg);
79 static AVFormatContext *input_files[MAX_FILES];
80 static int64_t input_files_ts_offset[MAX_FILES];
81 static int nb_input_files = 0;
83 static AVFormatContext *output_files[MAX_FILES];
84 static int nb_output_files = 0;
86 static AVStreamMap stream_maps[MAX_FILES];
87 static int nb_stream_maps;
89 static AVMetaDataMap meta_data_maps[MAX_FILES];
90 static int nb_meta_data_maps;
92 static AVInputFormat *file_iformat;
93 static AVOutputFormat *file_oformat;
94 static int frame_width = 0;
95 static int frame_height = 0;
96 static float frame_aspect_ratio = 0;
97 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
98 static int frame_padtop = 0;
99 static int frame_padbottom = 0;
100 static int frame_padleft = 0;
101 static int frame_padright = 0;
102 static int padcolor[3] = {16,128,128}; /* default to black */
103 static int frame_topBand = 0;
104 static int frame_bottomBand = 0;
105 static int frame_leftBand = 0;
106 static int frame_rightBand = 0;
107 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
108 static int frame_rate = 25;
109 static int frame_rate_base = 1;
110 static float video_qscale = 0;
111 static int video_qdiff = 3;
112 static uint16_t *intra_matrix = NULL;
113 static uint16_t *inter_matrix = NULL;
114 #if 0 //experimental, (can be removed)
115 static float video_rc_qsquish=1.0;
116 static float video_rc_qmod_amp=0;
117 static int video_rc_qmod_freq=0;
119 static char *video_rc_override_string=NULL;
120 static char *video_rc_eq="tex^qComp";
121 static int me_method = ME_EPZS;
122 static int video_disable = 0;
123 static int video_discard = 0;
124 static int video_codec_id = CODEC_ID_NONE;
125 static int video_codec_tag = 0;
126 static int same_quality = 0;
127 static int do_deinterlace = 0;
128 static int packet_size = 0;
129 static int strict = 0;
130 static int top_field_first = -1;
131 static int me_threshold = 0;
132 static int intra_dc_precision = 8;
133 static int loop_input = 0;
134 static int loop_output = AVFMT_NOOUTPUTLOOP;
135 static int qp_hist = 0;
137 static int intra_only = 0;
138 static int audio_sample_rate = 44100;
139 static int audio_bit_rate = 64000;
140 #define QSCALE_NONE -99999
141 static float audio_qscale = QSCALE_NONE;
142 static int audio_disable = 0;
143 static int audio_channels = 1;
144 static int audio_codec_id = CODEC_ID_NONE;
145 static int audio_codec_tag = 0;
146 static char *audio_language = NULL;
148 static int subtitle_codec_id = CODEC_ID_NONE;
149 static char *subtitle_language = NULL;
151 static float mux_preload= 0.5;
152 static float mux_max_delay= 0.7;
154 static int64_t recording_time = 0;
155 static int64_t start_time = 0;
156 static int64_t rec_timestamp = 0;
157 static int64_t input_ts_offset = 0;
158 static int file_overwrite = 0;
159 static char *str_title = NULL;
160 static char *str_author = NULL;
161 static char *str_copyright = NULL;
162 static char *str_comment = NULL;
163 static char *str_album = NULL;
164 static int do_benchmark = 0;
165 static int do_hex_dump = 0;
166 static int do_pkt_dump = 0;
167 static int do_psnr = 0;
168 static int do_vstats = 0;
169 static int do_pass = 0;
170 static char *pass_logfilename = NULL;
171 static int audio_stream_copy = 0;
172 static int video_stream_copy = 0;
173 static int subtitle_stream_copy = 0;
174 static int video_sync_method= 1;
175 static int audio_sync_method= 0;
176 static int copy_ts= 0;
177 static int opt_shortest = 0; //
178 static int video_global_header = 0;
180 static int rate_emu = 0;
183 static const char *video_grab_format = "bktr";
185 #ifdef CONFIG_VIDEO4LINUX2
186 static const char *video_grab_format = "video4linux2";
188 static const char *video_grab_format = "video4linux";
191 static char *video_device = NULL;
192 static char *grab_device = NULL;
193 static int video_channel = 0;
194 static char *video_standard = "ntsc";
196 static const char *audio_grab_format = "audio_device";
197 static char *audio_device = NULL;
198 static int audio_volume = 256;
200 static int using_stdin = 0;
201 static int using_vhook = 0;
202 static int verbose = 1;
203 static int thread_count= 1;
204 static int q_pressed = 0;
205 static int64_t video_size = 0;
206 static int64_t audio_size = 0;
207 static int64_t extra_size = 0;
208 static int nb_frames_dup = 0;
209 static int nb_frames_drop = 0;
210 static int input_sync;
211 static int limit_filesize = 0; //
213 static int pgmyuv_compatibility_hack=0;
214 static int dts_delta_threshold = 10;
216 static int sws_flags = SWS_BICUBIC;
218 const char **opt_names=NULL;
219 int opt_name_count=0;
220 AVCodecContext *avctx_opts;
221 AVFormatContext *avformat_opts;
223 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
224 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
225 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
227 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
229 struct AVInputStream;
231 typedef struct AVOutputStream {
232 int file_index; /* file index */
233 int index; /* stream index in the output file */
234 int source_index; /* AVInputStream index */
235 AVStream *st; /* stream in the output file */
236 int encoding_needed; /* true if encoding needed for this stream */
238 /* input pts and corresponding output pts
240 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
241 struct AVInputStream *sync_ist; /* input stream to sync against */
242 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
245 AVFrame pict_tmp; /* temporary image for resampling */
246 struct SwsContext *img_resample_ctx; /* for image resampling */
250 int topBand; /* cropping area sizes */
254 int padtop; /* padding area sizes */
261 ReSampleContext *resample; /* for audio resampling */
262 AVFifoBuffer fifo; /* for compression: one audio fifo per codec */
266 typedef struct AVInputStream {
270 int discard; /* true if stream data should be discarded */
271 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
272 int64_t sample_index; /* current sample */
274 int64_t start; /* time when read started */
275 unsigned long frame; /* current frame */
276 int64_t next_pts; /* synthetic pts for cases where pkt.pts
278 int64_t pts; /* current pts */
279 int is_start; /* is 1 at the start and after a discontinuity */
282 typedef struct AVInputFile {
283 int eof_reached; /* true if eof reached */
284 int ist_index; /* index of first stream in ist_table */
285 int buffer_size; /* current total buffer size */
286 int buffer_size_max; /* buffer size at which we consider we can stop
288 int nb_streams; /* nb streams we are aware of */
293 /* init terminal so that we can grab keys */
294 static struct termios oldtty;
296 static void term_exit(void)
298 tcsetattr (0, TCSANOW, &oldtty);
301 static volatile sig_atomic_t received_sigterm = 0;
304 sigterm_handler(int sig)
306 received_sigterm = sig;
310 static void term_init(void)
317 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
318 |INLCR|IGNCR|ICRNL|IXON);
319 tty.c_oflag |= OPOST;
320 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
321 tty.c_cflag &= ~(CSIZE|PARENB);
326 tcsetattr (0, TCSANOW, &tty);
328 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
329 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
330 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
332 register a function to be called at normal program termination
335 #ifdef CONFIG_BEOS_NETSERVER
336 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
340 /* read a key without blocking */
341 static int read_key(void)
345 #ifndef CONFIG_BEOS_NETSERVER
353 n = select(1, &rfds, NULL, NULL, &tv);
365 static int decode_interrupt_cb(void)
367 return q_pressed || (q_pressed = read_key() == 'q');
372 static volatile int received_sigterm = 0;
374 /* no interactive support */
375 static void term_exit(void)
379 static void term_init(void)
383 static int read_key(void)
390 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
395 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
398 /* copy stream format */
399 s->nb_streams = ic->nb_streams;
400 for(i=0;i<ic->nb_streams;i++) {
403 // FIXME: a more elegant solution is needed
404 st = av_mallocz(sizeof(AVStream));
405 memcpy(st, ic->streams[i], sizeof(AVStream));
406 st->codec = avcodec_alloc_context();
407 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
411 av_close_input_file(ic);
416 get_sync_ipts(const AVOutputStream *ost)
418 const AVInputStream *ist = ost->sync_ist;
419 return (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/AV_TIME_BASE;
422 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
424 AVPacket new_pkt= *pkt;
425 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
426 &new_pkt.data, &new_pkt.size,
427 pkt->data, pkt->size,
428 pkt->flags & PKT_FLAG_KEY);
431 new_pkt.destruct= av_destruct_packet;
438 av_interleaved_write_frame(s, pkt);
441 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
443 static void do_audio_out(AVFormatContext *s,
446 unsigned char *buf, int size)
449 static uint8_t *audio_buf = NULL;
450 static uint8_t *audio_out = NULL;
451 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
453 int size_out, frame_bytes, ret;
454 AVCodecContext *enc= ost->st->codec;
456 /* SC: dynamic allocation of buffers */
458 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
460 audio_out = av_malloc(audio_out_size);
461 if (!audio_buf || !audio_out)
462 return; /* Should signal an error ! */
464 if(audio_sync_method){
465 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
466 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
467 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
468 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
470 //FIXME resample delay
471 if(fabs(delta) > 50){
474 byte_delta= FFMAX(byte_delta, -size);
478 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
483 static uint8_t *input_tmp= NULL;
484 input_tmp= av_realloc(input_tmp, byte_delta + size);
486 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
489 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
491 memset(input_tmp, 0, byte_delta);
492 memcpy(input_tmp + byte_delta, buf, size);
496 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
498 }else if(audio_sync_method>1){
499 int comp= clip(delta, -audio_sync_method, audio_sync_method);
500 assert(ost->audio_resample);
502 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
503 // fprintf(stderr, "drift:%f len:%d opts:%"PRId64" ipts:%"PRId64" fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2));
504 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
508 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
509 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
511 if (ost->audio_resample) {
513 size_out = audio_resample(ost->resample,
514 (short *)buftmp, (short *)buf,
515 size / (ist->st->codec->channels * 2));
516 size_out = size_out * enc->channels * 2;
522 /* now encode as many frames as possible */
523 if (enc->frame_size > 1) {
524 /* output resampled raw samples */
525 av_fifo_write(&ost->fifo, buftmp, size_out);
527 frame_bytes = enc->frame_size * 2 * enc->channels;
529 while (av_fifo_read(&ost->fifo, audio_buf, frame_bytes) == 0) {
531 av_init_packet(&pkt);
533 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
536 pkt.stream_index= ost->index;
539 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
540 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
541 pkt.flags |= PKT_FLAG_KEY;
542 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
544 ost->sync_opts += enc->frame_size;
548 av_init_packet(&pkt);
550 ost->sync_opts += size_out / (2 * enc->channels);
552 /* output a pcm frame */
553 /* XXX: change encoding codec API to avoid this ? */
554 switch(enc->codec->id) {
555 case CODEC_ID_PCM_S32LE:
556 case CODEC_ID_PCM_S32BE:
557 case CODEC_ID_PCM_U32LE:
558 case CODEC_ID_PCM_U32BE:
559 size_out = size_out << 1;
561 case CODEC_ID_PCM_S24LE:
562 case CODEC_ID_PCM_S24BE:
563 case CODEC_ID_PCM_U24LE:
564 case CODEC_ID_PCM_U24BE:
565 case CODEC_ID_PCM_S24DAUD:
566 size_out = size_out / 2 * 3;
568 case CODEC_ID_PCM_S16LE:
569 case CODEC_ID_PCM_S16BE:
570 case CODEC_ID_PCM_U16LE:
571 case CODEC_ID_PCM_U16BE:
574 size_out = size_out >> 1;
577 ret = avcodec_encode_audio(enc, audio_out, size_out,
580 pkt.stream_index= ost->index;
583 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
584 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
585 pkt.flags |= PKT_FLAG_KEY;
586 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
590 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
594 AVPicture picture_tmp;
597 dec = ist->st->codec;
599 /* deinterlace : must be done before any resize */
600 if (do_deinterlace || using_vhook) {
603 /* create temporary picture */
604 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
605 buf = av_malloc(size);
609 picture2 = &picture_tmp;
610 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
613 if(avpicture_deinterlace(picture2, picture,
614 dec->pix_fmt, dec->width, dec->height) < 0) {
615 /* if error, do not deinterlace */
621 img_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
627 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
629 if (picture != picture2)
630 *picture = *picture2;
634 /* we begin to correct av delay at this threshold */
635 #define AV_DELAY_MAX 0.100
637 static void do_subtitle_out(AVFormatContext *s,
643 static uint8_t *subtitle_out = NULL;
644 int subtitle_out_max_size = 65536;
645 int subtitle_out_size, nb, i;
649 if (pts == AV_NOPTS_VALUE) {
650 fprintf(stderr, "Subtitle packets must have a pts\n");
654 enc = ost->st->codec;
657 subtitle_out = av_malloc(subtitle_out_max_size);
660 /* Note: DVB subtitle need one packet to draw them and one other
661 packet to clear them */
662 /* XXX: signal it in the codec context ? */
663 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
668 for(i = 0; i < nb; i++) {
669 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
670 subtitle_out_max_size, sub);
672 av_init_packet(&pkt);
673 pkt.stream_index = ost->index;
674 pkt.data = subtitle_out;
675 pkt.size = subtitle_out_size;
676 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);
677 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
678 /* XXX: the pts correction is handled here. Maybe handling
679 it in the codec would be better */
681 pkt.pts += 90 * sub->start_display_time;
683 pkt.pts += 90 * sub->end_display_time;
685 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
689 static int bit_buffer_size= 1024*256;
690 static uint8_t *bit_buffer= NULL;
692 static void do_video_out(AVFormatContext *s,
698 int nb_frames, i, ret;
699 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
700 AVFrame picture_crop_temp, picture_pad_temp;
701 uint8_t *buf = NULL, *buf1 = NULL;
702 AVCodecContext *enc, *dec;
704 avcodec_get_frame_defaults(&picture_crop_temp);
705 avcodec_get_frame_defaults(&picture_pad_temp);
707 enc = ost->st->codec;
708 dec = ist->st->codec;
710 /* by default, we output a single frame */
715 if(video_sync_method){
717 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
718 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
721 else if (vdelta > 1.1)
722 nb_frames = lrintf(vdelta);
723 //fprintf(stderr, "vdelta:%f, ost->sync_opts:%"PRId64", ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, ost->sync_ipts, nb_frames);
727 fprintf(stderr, "*** drop!\n");
728 }else if (nb_frames > 1) {
729 nb_frames_dup += nb_frames;
731 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
734 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
736 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
740 if (ost->video_crop) {
741 if (img_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
742 av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
745 formatted_picture = &picture_crop_temp;
747 formatted_picture = in_picture;
750 final_picture = formatted_picture;
751 padding_src = formatted_picture;
752 resampling_dst = &ost->pict_tmp;
753 if (ost->video_pad) {
754 final_picture = &ost->pict_tmp;
755 if (ost->video_resample) {
756 if (img_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
757 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
760 resampling_dst = &picture_pad_temp;
764 if (ost->video_resample) {
766 final_picture = &ost->pict_tmp;
767 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
768 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
771 if (ost->video_pad) {
772 img_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
773 enc->height, enc->width, enc->pix_fmt,
774 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
777 /* duplicates frame if needed */
778 for(i=0;i<nb_frames;i++) {
780 av_init_packet(&pkt);
781 pkt.stream_index= ost->index;
783 if (s->oformat->flags & AVFMT_RAWPICTURE) {
784 /* raw pictures are written as AVPicture structure to
785 avoid any copies. We support temorarily the older
787 AVFrame* old_frame = enc->coded_frame;
788 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
789 pkt.data= (uint8_t *)final_picture;
790 pkt.size= sizeof(AVPicture);
791 if(dec->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
792 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
793 if(dec->coded_frame && dec->coded_frame->key_frame)
794 pkt.flags |= PKT_FLAG_KEY;
796 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
797 enc->coded_frame = old_frame;
801 big_picture= *final_picture;
802 /* better than nothing: use input picture interlaced
804 big_picture.interlaced_frame = in_picture->interlaced_frame;
805 if(avctx_opts->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
806 if(top_field_first == -1)
807 big_picture.top_field_first = in_picture->top_field_first;
809 big_picture.top_field_first = top_field_first;
812 /* handles sameq here. This is not correct because it may
813 not be a global option */
815 big_picture.quality = ist->st->quality;
817 big_picture.quality = ost->st->quality;
819 big_picture.pict_type = 0;
820 // big_picture.pts = AV_NOPTS_VALUE;
821 big_picture.pts= ost->sync_opts;
822 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
823 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
824 ret = avcodec_encode_video(enc,
825 bit_buffer, bit_buffer_size,
828 fprintf(stderr, "Video encoding failed\n");
831 //enc->frame_number = enc->real_pict_num;
833 pkt.data= bit_buffer;
835 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
836 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
837 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
838 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
839 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
841 if(enc->coded_frame && enc->coded_frame->key_frame)
842 pkt.flags |= PKT_FLAG_KEY;
843 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
845 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
846 // enc->frame_number-1, enc->real_pict_num, ret,
848 /* if two pass, output log */
849 if (ost->logfile && enc->stats_out) {
850 fprintf(ost->logfile, "%s", enc->stats_out);
862 static double psnr(double d){
863 if(d==0) return INFINITY;
864 return -10.0*log(d)/log(10.0);
867 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
870 static FILE *fvstats=NULL;
877 double ti1, bitrate, avg_bitrate;
881 today = localtime(&today2);
882 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
885 fvstats = fopen(filename,"w");
893 enc = ost->st->codec;
894 if (enc->codec_type == CODEC_TYPE_VIDEO) {
895 frame_number = ost->frame_number;
896 fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
897 if (enc->flags&CODEC_FLAG_PSNR)
898 fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
900 fprintf(fvstats,"f_size= %6d ", frame_size);
901 /* compute pts value */
902 ti1 = ost->sync_opts * av_q2d(enc->time_base);
906 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
907 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
908 fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
909 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
910 fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
914 static void print_report(AVFormatContext **output_files,
915 AVOutputStream **ost_table, int nb_ostreams,
920 AVFormatContext *oc, *os;
923 int frame_number, vid, i;
924 double bitrate, ti1, pts;
925 static int64_t last_time = -1;
926 static int qp_histogram[52];
928 if (!is_last_report) {
930 /* display the report every 0.5 seconds */
931 cur_time = av_gettime();
932 if (last_time == -1) {
933 last_time = cur_time;
936 if ((cur_time - last_time) < 500000)
938 last_time = cur_time;
942 oc = output_files[0];
944 total_size = url_ftell(&oc->pb);
949 for(i=0;i<nb_ostreams;i++) {
951 os = output_files[ost->file_index];
952 enc = ost->st->codec;
953 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
954 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
955 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
957 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
958 frame_number = ost->frame_number;
959 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d q=%3.1f ",
960 frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
962 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
963 if(qp_hist && enc->coded_frame){
965 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
966 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
969 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
971 if (enc->flags&CODEC_FLAG_PSNR){
973 double error, error_sum=0;
974 double scale, scale_sum=0;
975 char type[3]= {'Y','U','V'};
976 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
979 error= enc->error[j];
980 scale= enc->width*enc->height*255.0*255.0*frame_number;
982 error= enc->coded_frame->error[j];
983 scale= enc->width*enc->height*255.0*255.0;
988 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
990 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
994 /* compute min output value */
995 pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
996 if ((pts < ti1) && (pts > 0))
1002 if (verbose || is_last_report) {
1003 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1005 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1006 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1007 (double)total_size / 1024, ti1, bitrate);
1010 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1011 nb_frames_dup, nb_frames_drop);
1014 fprintf(stderr, "%s \r", buf);
1019 if (is_last_report && verbose >= 0){
1020 int64_t raw= audio_size + video_size + extra_size;
1021 fprintf(stderr, "\n");
1022 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1026 100.0*(total_size - raw)/raw
1031 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1032 static int output_packet(AVInputStream *ist, int ist_index,
1033 AVOutputStream **ost_table, int nb_ostreams,
1034 const AVPacket *pkt)
1036 AVFormatContext *os;
1037 AVOutputStream *ost;
1041 int data_size, got_picture;
1043 void *buffer_to_free;
1044 static unsigned int samples_size= 0;
1045 static short *samples= NULL;
1046 AVSubtitle subtitle, *subtitle_to_free;
1050 ist->pts= ist->next_pts; // needed for last packet if vsync=0
1051 } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1052 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1054 // assert(ist->pts == ist->next_pts);
1068 /* decode the packet if needed */
1069 data_buf = NULL; /* fail safe */
1071 subtitle_to_free = NULL;
1072 if (ist->decoding_needed) {
1073 switch(ist->st->codec->codec_type) {
1074 case CODEC_TYPE_AUDIO:{
1076 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
1077 /* XXX: could avoid copy if PCM 16 bits with same
1078 endianness as CPU */
1079 ret = avcodec_decode_audio(ist->st->codec, samples, &data_size,
1085 /* Some bug in mpeg audio decoder gives */
1086 /* data_size < 0, it seems they are overflows */
1087 if (data_size <= 0) {
1088 /* no audio frame */
1091 data_buf = (uint8_t *)samples;
1092 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1093 (ist->st->codec->sample_rate * ist->st->codec->channels);
1095 case CODEC_TYPE_VIDEO:
1096 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1097 /* XXX: allocate picture correctly */
1098 avcodec_get_frame_defaults(&picture);
1100 ret = avcodec_decode_video(ist->st->codec,
1101 &picture, &got_picture, ptr, len);
1102 ist->st->quality= picture.quality;
1106 /* no picture yet */
1107 goto discard_packet;
1109 if (ist->st->codec->time_base.num != 0) {
1110 ist->next_pts += ((int64_t)AV_TIME_BASE *
1111 ist->st->codec->time_base.num) /
1112 ist->st->codec->time_base.den;
1116 case CODEC_TYPE_SUBTITLE:
1117 ret = avcodec_decode_subtitle(ist->st->codec,
1118 &subtitle, &got_subtitle, ptr, len);
1121 if (!got_subtitle) {
1122 goto discard_packet;
1124 subtitle_to_free = &subtitle;
1131 switch(ist->st->codec->codec_type) {
1132 case CODEC_TYPE_AUDIO:
1133 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1134 (ist->st->codec->sample_rate * ist->st->codec->channels);
1136 case CODEC_TYPE_VIDEO:
1137 if (ist->st->codec->time_base.num != 0) {
1138 ist->next_pts += ((int64_t)AV_TIME_BASE *
1139 ist->st->codec->time_base.num) /
1140 ist->st->codec->time_base.den;
1150 buffer_to_free = NULL;
1151 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1152 pre_process_video_frame(ist, (AVPicture *)&picture,
1156 // preprocess audio (volume)
1157 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1158 if (audio_volume != 256) {
1161 for(i=0;i<(data_size / sizeof(short));i++) {
1162 int v = ((*volp) * audio_volume + 128) >> 8;
1163 if (v < -32768) v = -32768;
1164 if (v > 32767) v = 32767;
1170 /* frame rate emulation */
1171 if (ist->st->codec->rate_emu) {
1172 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1173 int64_t now = av_gettime() - ist->start;
1181 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1182 is the one of the next displayed one */
1183 /* XXX: add mpeg4 too ? */
1184 if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1185 if (ist->st->codec->pict_type != B_TYPE) {
1187 tmp = ist->last_ip_pts;
1188 ist->last_ip_pts = ist->frac_pts.val;
1189 ist->frac_pts.val = tmp;
1193 /* if output time reached then transcode raw format,
1194 encode packets and output them */
1195 if (start_time == 0 || ist->pts >= start_time)
1196 for(i=0;i<nb_ostreams;i++) {
1200 if (ost->source_index == ist_index) {
1201 os = output_files[ost->file_index];
1204 printf("%d: got pts=%0.3f %0.3f\n", i,
1205 (double)pkt->pts / AV_TIME_BASE,
1206 ((double)ist->pts / AV_TIME_BASE) -
1207 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1209 /* set the input output pts pairs */
1210 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1212 if (ost->encoding_needed) {
1213 switch(ost->st->codec->codec_type) {
1214 case CODEC_TYPE_AUDIO:
1215 do_audio_out(os, ost, ist, data_buf, data_size);
1217 case CODEC_TYPE_VIDEO:
1218 do_video_out(os, ost, ist, &picture, &frame_size);
1219 video_size += frame_size;
1220 if (do_vstats && frame_size)
1221 do_video_stats(os, ost, frame_size);
1223 case CODEC_TYPE_SUBTITLE:
1224 do_subtitle_out(os, ost, ist, &subtitle,
1231 AVFrame avframe; //FIXME/XXX remove this
1233 av_init_packet(&opkt);
1235 /* no reencoding needed : output the packet directly */
1236 /* force the input stream PTS */
1238 avcodec_get_frame_defaults(&avframe);
1239 ost->st->codec->coded_frame= &avframe;
1240 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1242 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1243 audio_size += data_size;
1244 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1245 video_size += data_size;
1249 opkt.stream_index= ost->index;
1250 if(pkt->pts != AV_NOPTS_VALUE)
1251 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);
1253 opkt.pts= AV_NOPTS_VALUE;
1257 if (pkt->dts == AV_NOPTS_VALUE)
1258 dts = ist->next_pts;
1260 dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1261 opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
1263 opkt.flags= pkt->flags;
1265 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1266 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1267 opkt.destruct= av_destruct_packet;
1269 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
1270 ost->st->codec->frame_number++;
1271 ost->frame_number++;
1272 av_free_packet(&opkt);
1276 av_free(buffer_to_free);
1277 /* XXX: allocate the subtitles in the codec ? */
1278 if (subtitle_to_free) {
1279 if (subtitle_to_free->rects != NULL) {
1280 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1281 av_free(subtitle_to_free->rects[i].bitmap);
1282 av_free(subtitle_to_free->rects[i].rgba_palette);
1284 av_freep(&subtitle_to_free->rects);
1286 subtitle_to_free->num_rects = 0;
1287 subtitle_to_free = NULL;
1294 for(i=0;i<nb_ostreams;i++) {
1296 if (ost->source_index == ist_index) {
1297 AVCodecContext *enc= ost->st->codec;
1298 os = output_files[ost->file_index];
1300 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1302 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1305 if (ost->encoding_needed) {
1309 av_init_packet(&pkt);
1310 pkt.stream_index= ost->index;
1312 switch(ost->st->codec->codec_type) {
1313 case CODEC_TYPE_AUDIO:
1314 fifo_bytes = av_fifo_size(&ost->fifo);
1316 /* encode any samples remaining in fifo */
1317 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1318 int fs_tmp = enc->frame_size;
1319 enc->frame_size = fifo_bytes / (2 * enc->channels);
1320 if(av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes) == 0) {
1321 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1323 enc->frame_size = fs_tmp;
1326 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1329 pkt.flags |= PKT_FLAG_KEY;
1331 case CODEC_TYPE_VIDEO:
1332 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1334 if(enc->coded_frame && enc->coded_frame->key_frame)
1335 pkt.flags |= PKT_FLAG_KEY;
1336 if (ost->logfile && enc->stats_out) {
1337 fprintf(ost->logfile, "%s", enc->stats_out);
1346 pkt.data= bit_buffer;
1348 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1349 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1350 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1364 * The following code is the main loop of the file converter
1366 static int av_encode(AVFormatContext **output_files,
1367 int nb_output_files,
1368 AVFormatContext **input_files,
1370 AVStreamMap *stream_maps, int nb_stream_maps)
1372 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1373 AVFormatContext *is, *os;
1374 AVCodecContext *codec, *icodec;
1375 AVOutputStream *ost, **ost_table = NULL;
1376 AVInputStream *ist, **ist_table = NULL;
1377 AVInputFile *file_table;
1378 AVFormatContext *stream_no_data;
1381 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1385 /* input stream init */
1387 for(i=0;i<nb_input_files;i++) {
1388 is = input_files[i];
1389 file_table[i].ist_index = j;
1390 file_table[i].nb_streams = is->nb_streams;
1391 j += is->nb_streams;
1395 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1399 for(i=0;i<nb_istreams;i++) {
1400 ist = av_mallocz(sizeof(AVInputStream));
1406 for(i=0;i<nb_input_files;i++) {
1407 is = input_files[i];
1408 for(k=0;k<is->nb_streams;k++) {
1409 ist = ist_table[j++];
1410 ist->st = is->streams[k];
1411 ist->file_index = i;
1413 ist->discard = 1; /* the stream is discarded by default
1416 if (ist->st->codec->rate_emu) {
1417 ist->start = av_gettime();
1423 /* output stream init */
1425 for(i=0;i<nb_output_files;i++) {
1426 os = output_files[i];
1427 if (!os->nb_streams) {
1428 fprintf(stderr, "Output file does not contain any stream\n");
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 if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1542 codec->time_base = icodec->time_base;
1544 codec->time_base = ist->st->time_base;
1545 switch(codec->codec_type) {
1546 case CODEC_TYPE_AUDIO:
1547 codec->sample_rate = icodec->sample_rate;
1548 codec->channels = icodec->channels;
1549 codec->frame_size = icodec->frame_size;
1550 codec->block_align= icodec->block_align;
1552 case CODEC_TYPE_VIDEO:
1553 codec->pix_fmt = icodec->pix_fmt;
1554 codec->width = icodec->width;
1555 codec->height = icodec->height;
1556 codec->has_b_frames = icodec->has_b_frames;
1558 case CODEC_TYPE_SUBTITLE:
1564 switch(codec->codec_type) {
1565 case CODEC_TYPE_AUDIO:
1566 if (av_fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1569 if (codec->channels == icodec->channels &&
1570 codec->sample_rate == icodec->sample_rate) {
1571 ost->audio_resample = 0;
1573 if (codec->channels != icodec->channels &&
1574 (icodec->codec_id == CODEC_ID_AC3 ||
1575 icodec->codec_id == CODEC_ID_DTS)) {
1576 /* Special case for 5:1 AC3 and DTS input */
1577 /* and mono or stereo output */
1578 /* Request specific number of channels */
1579 icodec->channels = codec->channels;
1580 if (codec->sample_rate == icodec->sample_rate)
1581 ost->audio_resample = 0;
1583 ost->audio_resample = 1;
1586 ost->audio_resample = 1;
1589 if(audio_sync_method>1)
1590 ost->audio_resample = 1;
1592 if(ost->audio_resample){
1593 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1594 codec->sample_rate, icodec->sample_rate);
1596 printf("Can't resample. Aborting.\n");
1600 ist->decoding_needed = 1;
1601 ost->encoding_needed = 1;
1603 case CODEC_TYPE_VIDEO:
1604 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1605 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1606 ost->video_resample = ((codec->width != icodec->width -
1607 (frame_leftBand + frame_rightBand) +
1608 (frame_padleft + frame_padright)) ||
1609 (codec->height != icodec->height -
1610 (frame_topBand + frame_bottomBand) +
1611 (frame_padtop + frame_padbottom)) ||
1612 (codec->pix_fmt != icodec->pix_fmt));
1613 if (ost->video_crop) {
1614 ost->topBand = frame_topBand;
1615 ost->leftBand = frame_leftBand;
1617 if (ost->video_pad) {
1618 ost->padtop = frame_padtop;
1619 ost->padleft = frame_padleft;
1620 ost->padbottom = frame_padbottom;
1621 ost->padright = frame_padright;
1622 if (!ost->video_resample) {
1623 avcodec_get_frame_defaults(&ost->pict_tmp);
1624 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1625 codec->width, codec->height ) )
1629 if (ost->video_resample) {
1630 avcodec_get_frame_defaults(&ost->pict_tmp);
1631 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1632 codec->width, codec->height ) )
1635 ost->img_resample_ctx = sws_getContext(
1636 icodec->width - (frame_leftBand + frame_rightBand),
1637 icodec->height - (frame_topBand + frame_bottomBand),
1639 codec->width - (frame_padleft + frame_padright),
1640 codec->height - (frame_padtop + frame_padbottom),
1642 sws_flags, NULL, NULL, NULL);
1643 if (ost->img_resample_ctx == NULL) {
1644 fprintf(stderr, "Cannot get resampling context\n");
1647 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1649 ost->encoding_needed = 1;
1650 ist->decoding_needed = 1;
1652 case CODEC_TYPE_SUBTITLE:
1653 ost->encoding_needed = 1;
1654 ist->decoding_needed = 1;
1661 if (ost->encoding_needed &&
1662 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1663 char logfilename[1024];
1668 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1670 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1671 if (codec->flags & CODEC_FLAG_PASS1) {
1672 f = fopen(logfilename, "w");
1674 perror(logfilename);
1679 /* read the log file */
1680 f = fopen(logfilename, "r");
1682 perror(logfilename);
1685 fseek(f, 0, SEEK_END);
1687 fseek(f, 0, SEEK_SET);
1688 logbuffer = av_malloc(size + 1);
1690 fprintf(stderr, "Could not allocate log buffer\n");
1693 size = fread(logbuffer, 1, size, f);
1695 logbuffer[size] = '\0';
1696 codec->stats_in = logbuffer;
1700 if(codec->codec_type == CODEC_TYPE_VIDEO){
1701 int size= codec->width * codec->height;
1702 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1707 bit_buffer = av_malloc(bit_buffer_size);
1711 /* dump the file output parameters - cannot be done before in case
1713 for(i=0;i<nb_output_files;i++) {
1714 dump_format(output_files[i], i, output_files[i]->filename, 1);
1717 /* dump the stream mapping */
1719 fprintf(stderr, "Stream mapping:\n");
1720 for(i=0;i<nb_ostreams;i++) {
1722 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1723 ist_table[ost->source_index]->file_index,
1724 ist_table[ost->source_index]->index,
1727 if (ost->sync_ist != ist_table[ost->source_index])
1728 fprintf(stderr, " [sync #%d.%d]",
1729 ost->sync_ist->file_index,
1730 ost->sync_ist->index);
1731 fprintf(stderr, "\n");
1735 /* open each encoder */
1736 for(i=0;i<nb_ostreams;i++) {
1738 if (ost->encoding_needed) {
1740 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1742 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1743 ost->file_index, ost->index);
1746 if (avcodec_open(ost->st->codec, codec) < 0) {
1747 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1748 ost->file_index, ost->index);
1751 extra_size += ost->st->codec->extradata_size;
1755 /* open each decoder */
1756 for(i=0;i<nb_istreams;i++) {
1758 if (ist->decoding_needed) {
1760 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1762 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1763 ist->st->codec->codec_id, ist->file_index, ist->index);
1766 if (avcodec_open(ist->st->codec, codec) < 0) {
1767 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1768 ist->file_index, ist->index);
1771 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1772 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1777 for(i=0;i<nb_istreams;i++) {
1779 is = input_files[ist->file_index];
1781 ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1782 if(ist->st->start_time == AV_NOPTS_VALUE)
1784 if(input_files_ts_offset[ist->file_index])
1785 ist->next_pts= AV_NOPTS_VALUE;
1789 /* compute buffer size max (should use a complete heuristic) */
1790 for(i=0;i<nb_input_files;i++) {
1791 file_table[i].buffer_size_max = 2048;
1794 /* set meta data information from input file if required */
1795 for (i=0;i<nb_meta_data_maps;i++) {
1796 AVFormatContext *out_file;
1797 AVFormatContext *in_file;
1799 int out_file_index = meta_data_maps[i].out_file;
1800 int in_file_index = meta_data_maps[i].in_file;
1801 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1802 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1806 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1807 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1812 out_file = output_files[out_file_index];
1813 in_file = input_files[in_file_index];
1815 strcpy(out_file->title, in_file->title);
1816 strcpy(out_file->author, in_file->author);
1817 strcpy(out_file->copyright, in_file->copyright);
1818 strcpy(out_file->comment, in_file->comment);
1819 strcpy(out_file->album, in_file->album);
1820 out_file->year = in_file->year;
1821 out_file->track = in_file->track;
1822 strcpy(out_file->genre, in_file->genre);
1825 /* open files and write file headers */
1826 for(i=0;i<nb_output_files;i++) {
1827 os = output_files[i];
1828 if (av_write_header(os) < 0) {
1829 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1836 if ( !using_stdin && verbose >= 0) {
1837 fprintf(stderr, "Press [q] to stop encoding\n");
1838 url_set_interrupt_cb(decode_interrupt_cb);
1846 for(; received_sigterm == 0;) {
1847 int file_index, ist_index;
1855 /* if 'q' pressed, exits */
1859 /* read_key() returns 0 on EOF */
1865 /* select the stream that we must read now by looking at the
1866 smallest output pts */
1868 for(i=0;i<nb_ostreams;i++) {
1871 os = output_files[ost->file_index];
1872 ist = ist_table[ost->source_index];
1873 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1874 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1876 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1877 ipts = (double)ist->pts;
1878 if (!file_table[ist->file_index].eof_reached){
1879 if(ipts < ipts_min) {
1881 if(input_sync ) file_index = ist->file_index;
1883 if(opts < opts_min) {
1885 if(!input_sync) file_index = ist->file_index;
1888 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1893 /* if none, if is finished */
1894 if (file_index < 0) {
1898 /* finish if recording time exhausted */
1899 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1902 /* finish if limit size exhausted */
1903 if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
1906 /* read a frame from it and output it in the fifo */
1907 is = input_files[file_index];
1908 if (av_read_frame(is, &pkt) < 0) {
1909 file_table[file_index].eof_reached = 1;
1910 if (opt_shortest) break; else continue; //
1914 stream_no_data = is;
1919 av_pkt_dump(stdout, &pkt, do_hex_dump);
1921 /* the following test is needed in case new streams appear
1922 dynamically in stream : we ignore them */
1923 if (pkt.stream_index >= file_table[file_index].nb_streams)
1924 goto discard_packet;
1925 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1926 ist = ist_table[ist_index];
1928 goto discard_packet;
1930 // fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec->codec_type);
1931 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1932 int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
1933 if(FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
1934 input_files_ts_offset[ist->file_index]-= delta;
1936 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1937 for(i=0; i<file_table[file_index].nb_streams; i++){
1938 int index= file_table[file_index].ist_index + i;
1939 ist_table[index]->next_pts += delta;
1940 ist_table[index]->is_start=1;
1945 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1946 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1949 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1950 ist->file_index, ist->index);
1952 av_free_packet(&pkt);
1957 av_free_packet(&pkt);
1959 /* dump report by using the output first video and audio streams */
1960 print_report(output_files, ost_table, nb_ostreams, 0);
1963 /* at the end of stream, we must flush the decoder buffers */
1964 for(i=0;i<nb_istreams;i++) {
1966 if (ist->decoding_needed) {
1967 output_packet(ist, i, ost_table, nb_ostreams, NULL);
1973 /* write the trailer if needed and close file */
1974 for(i=0;i<nb_output_files;i++) {
1975 os = output_files[i];
1976 av_write_trailer(os);
1979 /* dump report by using the first video and audio streams */
1980 print_report(output_files, ost_table, nb_ostreams, 1);
1982 /* close each encoder */
1983 for(i=0;i<nb_ostreams;i++) {
1985 if (ost->encoding_needed) {
1986 av_freep(&ost->st->codec->stats_in);
1987 avcodec_close(ost->st->codec);
1991 /* close each decoder */
1992 for(i=0;i<nb_istreams;i++) {
1994 if (ist->decoding_needed) {
1995 avcodec_close(ist->st->codec);
2003 av_freep(&bit_buffer);
2004 av_free(file_table);
2007 for(i=0;i<nb_istreams;i++) {
2014 for(i=0;i<nb_ostreams;i++) {
2018 fclose(ost->logfile);
2019 ost->logfile = NULL;
2021 av_fifo_free(&ost->fifo); /* works even if fifo is not
2022 initialized but set to zero */
2023 av_free(ost->pict_tmp.data[0]);
2024 if (ost->video_resample)
2025 sws_freeContext(ost->img_resample_ctx);
2026 if (ost->audio_resample)
2027 audio_resample_close(ost->resample);
2040 int file_read(const char *filename)
2043 unsigned char buffer[1024];
2046 if (url_open(&h, filename, O_RDONLY) < 0) {
2047 printf("could not open '%s'\n", filename);
2051 len = url_read(h, buffer, sizeof(buffer));
2054 for(i=0;i<len;i++) putchar(buffer[i]);
2061 static void opt_format(const char *arg)
2063 /* compatibility stuff for pgmyuv */
2064 if (!strcmp(arg, "pgmyuv")) {
2065 pgmyuv_compatibility_hack=1;
2066 // opt_image_format(arg);
2070 file_iformat = av_find_input_format(arg);
2071 file_oformat = guess_format(arg, NULL, NULL);
2072 if (!file_iformat && !file_oformat) {
2073 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2078 static void opt_video_rc_eq(char *arg)
2083 static void opt_video_rc_override_string(char *arg)
2085 video_rc_override_string = arg;
2088 static void opt_me_threshold(const char *arg)
2090 me_threshold = atoi(arg);
2093 static void opt_verbose(const char *arg)
2095 verbose = atoi(arg);
2096 av_log_set_level(atoi(arg));
2099 static void opt_frame_rate(const char *arg)
2101 if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2102 fprintf(stderr, "Incorrect frame rate\n");
2107 static void opt_frame_crop_top(const char *arg)
2109 frame_topBand = atoi(arg);
2110 if (frame_topBand < 0) {
2111 fprintf(stderr, "Incorrect top crop size\n");
2114 if ((frame_topBand % 2) != 0) {
2115 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2118 if ((frame_topBand) >= frame_height){
2119 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2122 frame_height -= frame_topBand;
2125 static void opt_frame_crop_bottom(const char *arg)
2127 frame_bottomBand = atoi(arg);
2128 if (frame_bottomBand < 0) {
2129 fprintf(stderr, "Incorrect bottom crop size\n");
2132 if ((frame_bottomBand % 2) != 0) {
2133 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2136 if ((frame_bottomBand) >= frame_height){
2137 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2140 frame_height -= frame_bottomBand;
2143 static void opt_frame_crop_left(const char *arg)
2145 frame_leftBand = atoi(arg);
2146 if (frame_leftBand < 0) {
2147 fprintf(stderr, "Incorrect left crop size\n");
2150 if ((frame_leftBand % 2) != 0) {
2151 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2154 if ((frame_leftBand) >= frame_width){
2155 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2158 frame_width -= frame_leftBand;
2161 static void opt_frame_crop_right(const char *arg)
2163 frame_rightBand = atoi(arg);
2164 if (frame_rightBand < 0) {
2165 fprintf(stderr, "Incorrect right crop size\n");
2168 if ((frame_rightBand % 2) != 0) {
2169 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2172 if ((frame_rightBand) >= frame_width){
2173 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2176 frame_width -= frame_rightBand;
2179 static void opt_frame_size(const char *arg)
2181 if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2182 fprintf(stderr, "Incorrect frame size\n");
2185 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2186 fprintf(stderr, "Frame size must be a multiple of 2\n");
2192 #define SCALEBITS 10
2193 #define ONE_HALF (1 << (SCALEBITS - 1))
2194 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2196 #define RGB_TO_Y(r, g, b) \
2197 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2198 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2200 #define RGB_TO_U(r1, g1, b1, shift)\
2201 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2202 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2204 #define RGB_TO_V(r1, g1, b1, shift)\
2205 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2206 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2208 static void opt_pad_color(const char *arg) {
2209 /* Input is expected to be six hex digits similar to
2210 how colors are expressed in html tags (but without the #) */
2211 int rgb = strtol(arg, NULL, 16);
2215 g = ((rgb >> 8) & 255);
2218 padcolor[0] = RGB_TO_Y(r,g,b);
2219 padcolor[1] = RGB_TO_U(r,g,b,0);
2220 padcolor[2] = RGB_TO_V(r,g,b,0);
2223 static void opt_frame_pad_top(const char *arg)
2225 frame_padtop = atoi(arg);
2226 if (frame_padtop < 0) {
2227 fprintf(stderr, "Incorrect top pad size\n");
2230 if ((frame_padtop % 2) != 0) {
2231 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2236 static void opt_frame_pad_bottom(const char *arg)
2238 frame_padbottom = atoi(arg);
2239 if (frame_padbottom < 0) {
2240 fprintf(stderr, "Incorrect bottom pad size\n");
2243 if ((frame_padbottom % 2) != 0) {
2244 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2250 static void opt_frame_pad_left(const char *arg)
2252 frame_padleft = atoi(arg);
2253 if (frame_padleft < 0) {
2254 fprintf(stderr, "Incorrect left pad size\n");
2257 if ((frame_padleft % 2) != 0) {
2258 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2264 static void opt_frame_pad_right(const char *arg)
2266 frame_padright = atoi(arg);
2267 if (frame_padright < 0) {
2268 fprintf(stderr, "Incorrect right pad size\n");
2271 if ((frame_padright % 2) != 0) {
2272 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2278 static void opt_frame_pix_fmt(const char *arg)
2280 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2283 static void opt_frame_aspect_ratio(const char *arg)
2289 p = strchr(arg, ':');
2291 x = strtol(arg, (char **)&arg, 10);
2293 y = strtol(arg+1, (char **)&arg, 10);
2295 ar = (double)x / (double)y;
2297 ar = strtod(arg, (char **)&arg);
2300 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2303 frame_aspect_ratio = ar;
2306 static void opt_qscale(const char *arg)
2308 video_qscale = atof(arg);
2309 if (video_qscale <= 0 ||
2310 video_qscale > 255) {
2311 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2316 static void opt_qdiff(const char *arg)
2318 video_qdiff = atoi(arg);
2319 if (video_qdiff < 0 ||
2321 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2326 static void opt_packet_size(const char *arg)
2328 packet_size= atoi(arg);
2331 static void opt_strict(const char *arg)
2336 static void opt_top_field_first(const char *arg)
2338 top_field_first= atoi(arg);
2341 static void opt_thread_count(const char *arg)
2343 thread_count= atoi(arg);
2344 #if !defined(HAVE_THREADS)
2346 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2350 static void opt_audio_bitrate(const char *arg)
2352 audio_bit_rate = atoi(arg) * 1000;
2355 static void opt_audio_rate(const char *arg)
2357 audio_sample_rate = atoi(arg);
2360 static void opt_audio_channels(const char *arg)
2362 audio_channels = atoi(arg);
2365 static void opt_video_device(const char *arg)
2367 video_device = av_strdup(arg);
2370 static void opt_grab_device(const char *arg)
2372 grab_device = av_strdup(arg);
2375 static void opt_video_channel(const char *arg)
2377 video_channel = strtol(arg, NULL, 0);
2380 static void opt_video_standard(const char *arg)
2382 video_standard = av_strdup(arg);
2385 static void opt_audio_device(const char *arg)
2387 audio_device = av_strdup(arg);
2390 static void opt_codec(int *pstream_copy, int *pcodec_id,
2391 int codec_type, const char *arg)
2395 if (!strcmp(arg, "copy")) {
2400 if (!strcmp(p->name, arg) && p->type == codec_type)
2405 fprintf(stderr, "Unknown codec '%s'\n", arg);
2413 static void opt_audio_codec(const char *arg)
2415 opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2418 static void opt_audio_tag(const char *arg)
2421 audio_codec_tag= strtol(arg, &tail, 0);
2424 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2427 static void opt_video_tag(const char *arg)
2430 video_codec_tag= strtol(arg, &tail, 0);
2433 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2436 static void add_frame_hooker(const char *arg)
2441 char *args = av_strdup(arg);
2445 argv[0] = strtok(args, " ");
2446 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2449 i = frame_hook_add(argc, argv);
2452 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2457 const char *motion_str[] = {
2470 static void opt_motion_estimation(const char *arg)
2476 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2479 if (!strcmp(*p, arg))
2483 me_method = (p - motion_str) + 1;
2486 static void opt_video_codec(const char *arg)
2488 opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2491 static void opt_subtitle_codec(const char *arg)
2493 opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2496 static void opt_map(const char *arg)
2502 m = &stream_maps[nb_stream_maps++];
2504 m->file_index = strtol(arg, (char **)&p, 0);
2508 m->stream_index = strtol(p, (char **)&p, 0);
2511 m->sync_file_index = strtol(p, (char **)&p, 0);
2514 m->sync_stream_index = strtol(p, (char **)&p, 0);
2516 m->sync_file_index = m->file_index;
2517 m->sync_stream_index = m->stream_index;
2521 static void opt_map_meta_data(const char *arg)
2527 m = &meta_data_maps[nb_meta_data_maps++];
2529 m->out_file = strtol(arg, (char **)&p, 0);
2533 m->in_file = strtol(p, (char **)&p, 0);
2536 static void opt_recording_time(const char *arg)
2538 recording_time = parse_date(arg, 1);
2541 static void opt_start_time(const char *arg)
2543 start_time = parse_date(arg, 1);
2546 static void opt_rec_timestamp(const char *arg)
2548 rec_timestamp = parse_date(arg, 0) / 1000000;
2551 static void opt_input_ts_offset(const char *arg)
2553 input_ts_offset = parse_date(arg, 1);
2556 static void opt_input_file(const char *filename)
2558 AVFormatContext *ic;
2559 AVFormatParameters params, *ap = ¶ms;
2560 int err, i, ret, rfps, rfps_base;
2563 if (!strcmp(filename, "-"))
2566 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2567 !strcmp( filename, "/dev/stdin" );
2569 /* get default parameters from command line */
2570 ic = av_alloc_format_context();
2572 memset(ap, 0, sizeof(*ap));
2573 ap->prealloced_context = 1;
2574 ap->sample_rate = audio_sample_rate;
2575 ap->channels = audio_channels;
2576 ap->time_base.den = frame_rate;
2577 ap->time_base.num = frame_rate_base;
2578 ap->width = frame_width + frame_padleft + frame_padright;
2579 ap->height = frame_height + frame_padtop + frame_padbottom;
2580 ap->pix_fmt = frame_pix_fmt;
2581 ap->device = grab_device;
2582 ap->channel = video_channel;
2583 ap->standard = video_standard;
2584 ap->video_codec_id = video_codec_id;
2585 ap->audio_codec_id = audio_codec_id;
2586 if(pgmyuv_compatibility_hack)
2587 ap->video_codec_id= CODEC_ID_PGMYUV;
2589 for(i=0; i<opt_name_count; i++){
2591 double d= av_get_double(avformat_opts, opt_names[i], &opt);
2592 if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2593 av_set_double(ic, opt_names[i], d);
2595 /* open the input file with generic libav function */
2596 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2598 print_error(filename, err);
2602 ic->loop_input = loop_input;
2604 /* If not enough info to get the stream parameters, we decode the
2605 first frames to get it. (used in mpeg case for example) */
2606 ret = av_find_stream_info(ic);
2607 if (ret < 0 && verbose >= 0) {
2608 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2612 timestamp = start_time;
2613 /* add the stream start time */
2614 if (ic->start_time != AV_NOPTS_VALUE)
2615 timestamp += ic->start_time;
2617 /* if seeking requested, we execute it */
2618 if (start_time != 0) {
2619 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2621 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2622 filename, (double)timestamp / AV_TIME_BASE);
2624 /* reset seek info */
2628 /* update the current parameters so that they match the one of the input stream */
2629 for(i=0;i<ic->nb_streams;i++) {
2631 AVCodecContext *enc = ic->streams[i]->codec;
2632 #if defined(HAVE_THREADS)
2634 avcodec_thread_init(enc, thread_count);
2636 enc->thread_count= thread_count;
2637 switch(enc->codec_type) {
2638 case CODEC_TYPE_AUDIO:
2639 for(j=0; j<opt_name_count; j++){
2641 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2642 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2643 av_set_double(enc, opt_names[j], d);
2645 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2646 audio_channels = enc->channels;
2647 audio_sample_rate = enc->sample_rate;
2649 ic->streams[i]->discard= AVDISCARD_ALL;
2651 case CODEC_TYPE_VIDEO:
2652 for(j=0; j<opt_name_count; j++){
2654 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2655 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2656 av_set_double(enc, opt_names[j], d);
2658 frame_height = enc->height;
2659 frame_width = enc->width;
2660 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2661 frame_pix_fmt = enc->pix_fmt;
2662 rfps = ic->streams[i]->r_frame_rate.num;
2663 rfps_base = ic->streams[i]->r_frame_rate.den;
2664 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2666 enc->debug |= FF_DEBUG_MV;
2668 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2671 fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2672 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2674 (float)rfps / rfps_base, rfps, rfps_base);
2676 /* update the current frame rate to match the stream frame rate */
2678 frame_rate_base = rfps_base;
2680 enc->rate_emu = rate_emu;
2682 ic->streams[i]->discard= AVDISCARD_ALL;
2683 else if(video_discard)
2684 ic->streams[i]->discard= video_discard;
2686 case CODEC_TYPE_DATA:
2688 case CODEC_TYPE_SUBTITLE:
2690 case CODEC_TYPE_UNKNOWN:
2697 input_files[nb_input_files] = ic;
2698 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2699 /* dump the file content */
2701 dump_format(ic, nb_input_files, filename, 0);
2704 file_iformat = NULL;
2705 file_oformat = NULL;
2713 static void opt_grab(const char *arg)
2715 file_iformat = av_find_input_format(arg);
2719 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2721 int has_video, has_audio, i, j;
2722 AVFormatContext *ic;
2726 for(j=0;j<nb_input_files;j++) {
2727 ic = input_files[j];
2728 for(i=0;i<ic->nb_streams;i++) {
2729 AVCodecContext *enc = ic->streams[i]->codec;
2730 switch(enc->codec_type) {
2731 case CODEC_TYPE_AUDIO:
2734 case CODEC_TYPE_VIDEO:
2737 case CODEC_TYPE_DATA:
2738 case CODEC_TYPE_UNKNOWN:
2739 case CODEC_TYPE_SUBTITLE:
2746 *has_video_ptr = has_video;
2747 *has_audio_ptr = has_audio;
2750 static void new_video_stream(AVFormatContext *oc)
2753 AVCodecContext *video_enc;
2756 st = av_new_stream(oc, oc->nb_streams);
2758 fprintf(stderr, "Could not alloc stream\n");
2761 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2762 video_bitstream_filters= NULL;
2764 #if defined(HAVE_THREADS)
2766 avcodec_thread_init(st->codec, thread_count);
2769 video_enc = st->codec;
2772 video_enc->codec_tag= video_codec_tag;
2774 if( (video_global_header&1)
2775 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2776 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2777 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2779 if(video_global_header&2){
2780 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2781 avctx_opts->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2784 if (video_stream_copy) {
2785 st->stream_copy = 1;
2786 video_enc->codec_type = CODEC_TYPE_VIDEO;
2792 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2793 if (video_codec_id != CODEC_ID_NONE)
2794 codec_id = video_codec_id;
2796 video_enc->codec_id = codec_id;
2797 codec = avcodec_find_encoder(codec_id);
2799 for(i=0; i<opt_name_count; i++){
2801 double d= av_get_double(avctx_opts, opt_names[i], &opt);
2802 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2803 av_set_double(video_enc, opt_names[i], d);
2806 video_enc->time_base.den = frame_rate;
2807 video_enc->time_base.num = frame_rate_base;
2808 if(codec && codec->supported_framerates){
2809 const AVRational *p= codec->supported_framerates;
2810 AVRational req= (AVRational){frame_rate, frame_rate_base};
2811 const AVRational *best=NULL;
2812 AVRational best_error= (AVRational){INT_MAX, 1};
2813 for(; p->den!=0; p++){
2814 AVRational error= av_sub_q(req, *p);
2815 if(error.num <0) error.num *= -1;
2816 if(av_cmp_q(error, best_error) < 0){
2821 video_enc->time_base.den= best->num;
2822 video_enc->time_base.num= best->den;
2825 video_enc->width = frame_width + frame_padright + frame_padleft;
2826 video_enc->height = frame_height + frame_padtop + frame_padbottom;
2827 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2828 video_enc->pix_fmt = frame_pix_fmt;
2830 if(codec && codec->pix_fmts){
2831 const enum PixelFormat *p= codec->pix_fmts;
2833 if(*p == video_enc->pix_fmt)
2837 video_enc->pix_fmt = codec->pix_fmts[0];
2841 video_enc->gop_size = 0;
2842 if (video_qscale || same_quality) {
2843 video_enc->flags |= CODEC_FLAG_QSCALE;
2844 video_enc->global_quality=
2845 st->quality = FF_QP2LAMBDA * video_qscale;
2849 video_enc->intra_matrix = intra_matrix;
2851 video_enc->inter_matrix = inter_matrix;
2853 video_enc->max_qdiff = video_qdiff;
2854 video_enc->rc_eq = video_rc_eq;
2855 video_enc->thread_count = thread_count;
2856 p= video_rc_override_string;
2859 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2861 fprintf(stderr, "error parsing rc_override\n");
2864 video_enc->rc_override=
2865 av_realloc(video_enc->rc_override,
2866 sizeof(RcOverride)*(i+1));
2867 video_enc->rc_override[i].start_frame= start;
2868 video_enc->rc_override[i].end_frame = end;
2870 video_enc->rc_override[i].qscale= q;
2871 video_enc->rc_override[i].quality_factor= 1.0;
2874 video_enc->rc_override[i].qscale= 0;
2875 video_enc->rc_override[i].quality_factor= -q/100.0;
2880 video_enc->rc_override_count=i;
2881 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2882 video_enc->me_threshold= me_threshold;
2883 video_enc->intra_dc_precision= intra_dc_precision - 8;
2884 video_enc->strict_std_compliance = strict;
2887 video_enc->rtp_mode= 1;
2888 video_enc->rtp_payload_size= packet_size;
2892 video_enc->flags|= CODEC_FLAG_PSNR;
2894 video_enc->me_method = me_method;
2899 video_enc->flags |= CODEC_FLAG_PASS1;
2901 video_enc->flags |= CODEC_FLAG_PASS2;
2906 /* reset some key parameters */
2908 video_codec_id = CODEC_ID_NONE;
2909 video_stream_copy = 0;
2912 static void new_audio_stream(AVFormatContext *oc)
2915 AVCodecContext *audio_enc;
2918 st = av_new_stream(oc, oc->nb_streams);
2920 fprintf(stderr, "Could not alloc stream\n");
2924 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2925 audio_bitstream_filters= NULL;
2927 #if defined(HAVE_THREADS)
2929 avcodec_thread_init(st->codec, thread_count);
2932 audio_enc = st->codec;
2933 audio_enc->codec_type = CODEC_TYPE_AUDIO;
2934 audio_enc->strict_std_compliance = strict;
2937 audio_enc->codec_tag= audio_codec_tag;
2939 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
2940 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2941 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2943 if (audio_stream_copy) {
2944 st->stream_copy = 1;
2945 audio_enc->channels = audio_channels;
2947 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
2949 for(i=0; i<opt_name_count; i++){
2951 double d= av_get_double(avctx_opts, opt_names[i], &opt);
2952 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2953 av_set_double(audio_enc, opt_names[i], d);
2956 if (audio_codec_id != CODEC_ID_NONE)
2957 codec_id = audio_codec_id;
2958 audio_enc->codec_id = codec_id;
2960 audio_enc->bit_rate = audio_bit_rate;
2961 if (audio_qscale > QSCALE_NONE) {
2962 audio_enc->flags |= CODEC_FLAG_QSCALE;
2963 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
2965 audio_enc->thread_count = thread_count;
2966 /* For audio codecs other than AC3 or DTS we limit */
2967 /* the number of coded channels to stereo */
2968 if (audio_channels > 2 && codec_id != CODEC_ID_AC3
2969 && codec_id != CODEC_ID_DTS) {
2970 audio_enc->channels = 2;
2972 audio_enc->channels = audio_channels;
2974 audio_enc->sample_rate = audio_sample_rate;
2975 audio_enc->time_base= (AVRational){1, audio_sample_rate};
2976 if (audio_language) {
2977 pstrcpy(st->language, sizeof(st->language), audio_language);
2978 av_free(audio_language);
2979 audio_language = NULL;
2982 /* reset some key parameters */
2984 audio_codec_id = CODEC_ID_NONE;
2985 audio_stream_copy = 0;
2988 static void opt_new_subtitle_stream(void)
2990 AVFormatContext *oc;
2992 AVCodecContext *subtitle_enc;
2995 if (nb_output_files <= 0) {
2996 fprintf(stderr, "At least one output file must be specified\n");
2999 oc = output_files[nb_output_files - 1];
3001 st = av_new_stream(oc, oc->nb_streams);
3003 fprintf(stderr, "Could not alloc stream\n");
3007 subtitle_enc = st->codec;
3008 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3009 if (subtitle_stream_copy) {
3010 st->stream_copy = 1;
3012 for(i=0; i<opt_name_count; i++){
3014 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3015 if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3016 av_set_double(subtitle_enc, opt_names[i], d);
3018 subtitle_enc->codec_id = subtitle_codec_id;
3021 if (subtitle_language) {
3022 pstrcpy(st->language, sizeof(st->language), subtitle_language);
3023 av_free(subtitle_language);
3024 subtitle_language = NULL;
3027 subtitle_codec_id = CODEC_ID_NONE;
3028 subtitle_stream_copy = 0;
3031 static void opt_new_audio_stream(void)
3033 AVFormatContext *oc;
3034 if (nb_output_files <= 0) {
3035 fprintf(stderr, "At least one output file must be specified\n");
3038 oc = output_files[nb_output_files - 1];
3039 new_audio_stream(oc);
3042 static void opt_new_video_stream(void)
3044 AVFormatContext *oc;
3045 if (nb_output_files <= 0) {
3046 fprintf(stderr, "At least one output file must be specified\n");
3049 oc = output_files[nb_output_files - 1];
3050 new_video_stream(oc);
3053 static void opt_output_file(const char *filename)
3055 AVFormatContext *oc;
3056 int use_video, use_audio, input_has_video, input_has_audio, i;
3057 AVFormatParameters params, *ap = ¶ms;
3059 if (!strcmp(filename, "-"))
3062 oc = av_alloc_format_context();
3064 if (!file_oformat) {
3065 file_oformat = guess_format(NULL, filename, NULL);
3066 if (!file_oformat) {
3067 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3073 oc->oformat = file_oformat;
3074 pstrcpy(oc->filename, sizeof(oc->filename), filename);
3076 if (!strcmp(file_oformat->name, "ffm") &&
3077 strstart(filename, "http:", NULL)) {
3078 /* special case for files sent to ffserver: we get the stream
3079 parameters from ffserver */
3080 if (read_ffserver_streams(oc, filename) < 0) {
3081 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3085 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3086 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3088 /* disable if no corresponding type found and at least one
3090 if (nb_input_files > 0) {
3091 check_audio_video_inputs(&input_has_video, &input_has_audio);
3092 if (!input_has_video)
3094 if (!input_has_audio)
3098 /* manual disable */
3099 if (audio_disable) {
3102 if (video_disable) {
3107 new_video_stream(oc);
3111 new_audio_stream(oc);
3114 oc->timestamp = rec_timestamp;
3117 pstrcpy(oc->title, sizeof(oc->title), str_title);
3119 pstrcpy(oc->author, sizeof(oc->author), str_author);
3121 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3123 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3125 pstrcpy(oc->album, sizeof(oc->album), str_album);
3128 output_files[nb_output_files++] = oc;
3130 /* check filename in case of an image number is expected */
3131 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3132 if (!av_filename_number_test(oc->filename)) {
3133 print_error(oc->filename, AVERROR_NUMEXPECTED);
3138 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3139 /* test if it already exists to avoid loosing precious files */
3140 if (!file_overwrite &&
3141 (strchr(filename, ':') == NULL ||
3142 strstart(filename, "file:", NULL))) {
3143 if (url_exist(filename)) {
3146 if ( !using_stdin ) {
3147 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3150 if (toupper(c) != 'Y') {
3151 fprintf(stderr, "Not overwriting - exiting\n");
3156 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3163 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3164 fprintf(stderr, "Could not open '%s'\n", filename);
3169 memset(ap, 0, sizeof(*ap));
3170 if (av_set_parameters(oc, ap) < 0) {
3171 fprintf(stderr, "%s: Invalid encoding parameters\n",
3176 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3177 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3178 oc->loop_output = loop_output;
3180 for(i=0; i<opt_name_count; i++){
3182 double d = av_get_double(avformat_opts, opt_names[i], &opt);
3183 if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3184 av_set_double(oc, opt_names[i], d);
3187 /* reset some options */
3188 file_oformat = NULL;
3189 file_iformat = NULL;
3192 /* prepare dummy protocols for grab */
3193 static void prepare_grab(void)
3195 int has_video, has_audio, i, j;
3196 AVFormatContext *oc;
3197 AVFormatContext *ic;
3198 AVFormatParameters vp1, *vp = &vp1;
3199 AVFormatParameters ap1, *ap = &ap1;
3201 /* see if audio/video inputs are needed */
3204 memset(ap, 0, sizeof(*ap));
3205 memset(vp, 0, sizeof(*vp));
3206 vp->time_base.num= 1;
3207 for(j=0;j<nb_output_files;j++) {
3208 oc = output_files[j];
3209 for(i=0;i<oc->nb_streams;i++) {
3210 AVCodecContext *enc = oc->streams[i]->codec;
3211 switch(enc->codec_type) {
3212 case CODEC_TYPE_AUDIO:
3213 if (enc->sample_rate > ap->sample_rate)
3214 ap->sample_rate = enc->sample_rate;
3215 if (enc->channels > ap->channels)
3216 ap->channels = enc->channels;
3219 case CODEC_TYPE_VIDEO:
3220 if (enc->width > vp->width)
3221 vp->width = enc->width;
3222 if (enc->height > vp->height)
3223 vp->height = enc->height;
3225 if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
3226 vp->time_base = enc->time_base;
3227 vp->width += frame_leftBand + frame_rightBand;
3228 vp->width -= (frame_padleft + frame_padright);
3229 vp->height += frame_topBand + frame_bottomBand;
3230 vp->height -= (frame_padtop + frame_padbottom);
3240 if (has_video == 0 && has_audio == 0) {
3241 fprintf(stderr, "Output file must have at least one audio or video stream\n");
3246 AVInputFormat *fmt1;
3247 fmt1 = av_find_input_format(video_grab_format);
3248 vp->device = video_device;
3249 vp->channel = video_channel;
3250 vp->standard = video_standard;
3251 vp->pix_fmt = frame_pix_fmt;
3252 if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3253 fprintf(stderr, "Could not find video grab device\n");
3256 /* If not enough info to get the stream parameters, we decode the
3257 first frames to get it. */
3258 if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3259 fprintf(stderr, "Could not find video grab parameters\n");
3262 /* by now video grab has one stream */
3263 ic->streams[0]->r_frame_rate.num = vp->time_base.den;
3264 ic->streams[0]->r_frame_rate.den = vp->time_base.num;
3265 input_files[nb_input_files] = ic;
3268 dump_format(ic, nb_input_files, "", 0);
3272 if (has_audio && audio_grab_format) {
3273 AVInputFormat *fmt1;
3274 fmt1 = av_find_input_format(audio_grab_format);
3275 ap->device = audio_device;
3276 if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3277 fprintf(stderr, "Could not find audio grab device\n");
3280 input_files[nb_input_files] = ic;
3283 dump_format(ic, nb_input_files, "", 0);
3289 /* same option as mencoder */
3290 static void opt_pass(const char *pass_str)
3293 pass = atoi(pass_str);
3294 if (pass != 1 && pass != 2) {
3295 fprintf(stderr, "pass number can be only 1 or 2\n");
3301 #if defined(__MINGW32__) || defined(CONFIG_OS2)
3302 static int64_t getutime(void)
3304 return av_gettime();
3307 static int64_t getutime(void)
3309 struct rusage rusage;
3311 getrusage(RUSAGE_SELF, &rusage);
3312 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3316 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3317 extern int ffm_nopts;
3320 static void show_formats(void)
3322 AVInputFormat *ifmt;
3323 AVOutputFormat *ofmt;
3326 const char **pp, *last_name;
3328 printf("File formats:\n");
3333 const char *name=NULL;
3334 const char *long_name=NULL;
3336 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3337 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3338 strcmp(ofmt->name, last_name)>0){
3340 long_name= ofmt->long_name;
3344 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3345 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3346 strcmp(ifmt->name, last_name)>0){
3348 long_name= ifmt->long_name;
3351 if(name && strcmp(ifmt->name, name)==0)
3363 long_name ? long_name:" ");
3367 printf("Codecs:\n");
3373 const char *type_str;
3376 for(p = first_avcodec; p != NULL; p = p->next) {
3377 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3378 strcmp(p->name, last_name)>0){
3380 decode= encode= cap=0;
3382 if(p2 && strcmp(p->name, p2->name)==0){
3383 if(p->decode) decode=1;
3384 if(p->encode) encode=1;
3385 cap |= p->capabilities;
3390 last_name= p2->name;
3393 case CODEC_TYPE_VIDEO:
3396 case CODEC_TYPE_AUDIO:
3399 case CODEC_TYPE_SUBTITLE:
3408 decode ? "D": (/*p2->decoder ? "d":*/" "),
3411 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3412 cap & CODEC_CAP_DR1 ? "D":" ",
3413 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3415 /* if(p2->decoder && decode==0)
3416 printf(" use %s for decoding", p2->decoder->name);*/
3421 printf("Supported file protocols:\n");
3422 for(up = first_protocol; up != NULL; up = up->next)
3423 printf(" %s:", up->name);
3426 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3427 printf("Motion estimation methods:\n");
3431 if ((pp - motion_str + 1) == ME_ZERO)
3432 printf("(fastest)");
3433 else if ((pp - motion_str + 1) == ME_FULL)
3434 printf("(slowest)");
3435 else if ((pp - motion_str + 1) == ME_EPZS)
3436 printf("(default)");
3441 "Note, the names of encoders and decoders dont always match, so there are\n"
3442 "several cases where the above table shows encoder only or decoder only entries\n"
3443 "even though both encoding and decoding are supported for example, the h263\n"
3444 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3449 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3452 const char *p = str;
3459 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3466 static void opt_inter_matrix(const char *arg)
3468 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3469 parse_matrix_coeffs(inter_matrix, arg);
3472 static void opt_intra_matrix(const char *arg)
3474 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3475 parse_matrix_coeffs(intra_matrix, arg);
3478 static void opt_target(const char *arg)
3481 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3483 if(!strncmp(arg, "pal-", 4)) {
3486 } else if(!strncmp(arg, "ntsc-", 5)) {
3489 } else if(!strncmp(arg, "film-", 5)) {
3494 /* Calculate FR via float to avoid int overflow */
3495 fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3498 } else if((fr == 29970) || (fr == 23976)) {
3501 /* Try to determine PAL/NTSC by peeking in the input files */
3502 if(nb_input_files) {
3504 for(j = 0; j < nb_input_files; j++) {
3505 for(i = 0; i < input_files[j]->nb_streams; i++) {
3506 AVCodecContext *c = input_files[j]->streams[i]->codec;
3507 if(c->codec_type != CODEC_TYPE_VIDEO)
3509 fr = c->time_base.den * 1000 / c->time_base.num;
3513 } else if((fr == 29970) || (fr == 23976)) {
3523 if(verbose && norm >= 0)
3524 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3528 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3529 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3530 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3534 if(!strcmp(arg, "vcd")) {
3536 opt_video_codec("mpeg1video");
3537 opt_audio_codec("mp2");
3540 opt_frame_size(norm ? "352x240" : "352x288");
3541 opt_frame_rate(frame_rates[norm]);
3542 opt_default("gop", norm ? "18" : "15");
3544 opt_default("b", "1150000");
3545 opt_default("maxrate", "1150000");
3546 opt_default("minrate", "1150000");
3547 opt_default("bufsize", "327680"); // 40*1024*8;
3549 audio_bit_rate = 224000;
3550 audio_sample_rate = 44100;
3552 opt_default("packetsize", "2324");
3553 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3555 /* We have to offset the PTS, so that it is consistent with the SCR.
3556 SCR starts at 36000, but the first two packs contain only padding
3557 and the first pack from the other stream, respectively, may also have
3558 been written before.
3559 So the real data starts at SCR 36000+3*1200. */
3560 mux_preload= (36000+3*1200) / 90000.0; //0.44
3561 } else if(!strcmp(arg, "svcd")) {
3563 opt_video_codec("mpeg2video");
3564 opt_audio_codec("mp2");
3567 opt_frame_size(norm ? "480x480" : "480x576");
3568 opt_frame_rate(frame_rates[norm]);
3569 opt_default("gop", norm ? "18" : "15");
3571 opt_default("b", "2040000");
3572 opt_default("maxrate", "2516000");
3573 opt_default("minrate", "0"); //1145000;
3574 opt_default("bufsize", "1835008"); //224*1024*8;
3575 opt_default("flags", "+SCAN_OFFSET");
3578 audio_bit_rate = 224000;
3579 audio_sample_rate = 44100;
3581 opt_default("packetsize", "2324");
3583 } else if(!strcmp(arg, "dvd")) {
3585 opt_video_codec("mpeg2video");
3586 opt_audio_codec("ac3");
3589 opt_frame_size(norm ? "720x480" : "720x576");
3590 opt_frame_rate(frame_rates[norm]);
3591 opt_default("gop", norm ? "18" : "15");
3593 opt_default("b", "6000000");
3594 opt_default("maxrate", "9000000");
3595 opt_default("minrate", "0"); //1500000;
3596 opt_default("bufsize", "1835008"); //224*1024*8;
3598 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3599 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3601 audio_bit_rate = 448000;
3602 audio_sample_rate = 48000;
3604 } else if(!strncmp(arg, "dv", 2)) {
3608 opt_frame_size(norm ? "720x480" : "720x576");
3609 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3610 (norm ? "yuv411p" : "yuv420p"));
3611 opt_frame_rate(frame_rates[norm]);
3613 audio_sample_rate = 48000;
3617 fprintf(stderr, "Unknown target: %s\n", arg);
3622 static void opt_video_bsf(const char *arg)
3624 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3625 AVBitStreamFilterContext **bsfp;
3628 fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3632 bsfp= &video_bitstream_filters;
3634 bsfp= &(*bsfp)->next;
3639 //FIXME avoid audio - video code duplication
3640 static void opt_audio_bsf(const char *arg)
3642 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3643 AVBitStreamFilterContext **bsfp;
3646 fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3650 bsfp= &audio_bitstream_filters;
3652 bsfp= &(*bsfp)->next;
3657 static void show_version(void)
3659 /* TODO: add function interface to avutil and avformat */
3660 fprintf(stderr, "ffmpeg " FFMPEG_VERSION "\n"
3664 LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3668 static int opt_default(const char *opt, const char *arg){
3669 AVOption *o= av_set_string(avctx_opts, opt, arg);
3671 o = av_set_string(avformat_opts, opt, arg);
3675 // 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));
3677 //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
3678 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
3679 opt_names[opt_name_count++]= o->name;
3681 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3682 /* disable generate of real time pts in ffm (need to be supressed anyway) */
3683 if(avctx_opts->flags & CODEC_FLAG_BITEXACT)
3687 if(avctx_opts->debug)
3688 av_log_set_level(AV_LOG_DEBUG);
3692 const OptionDef options[] = {
3694 { "L", 0, {(void*)show_license}, "show license" },
3695 { "h", 0, {(void*)show_help}, "show help" },
3696 { "version", 0, {(void*)show_version}, "show version" },
3697 { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3698 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3699 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3700 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3701 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3702 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3703 { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3704 { "fs", HAS_ARG | OPT_INT, {(void*)&limit_filesize}, "set the limit file size", "limit_size" }, //
3705 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3706 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3707 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3708 { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3709 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3710 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3711 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3712 { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3713 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3714 "add timings for benchmarking" },
3715 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3716 "dump each input packet" },
3717 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3718 "when dumping packets, also dump the payload" },
3719 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3720 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3721 { "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)", "" },
3722 { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3723 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3724 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3725 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3726 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3727 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3728 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3729 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3730 { "dts_delta_threshold", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
3733 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3734 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3735 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3736 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3737 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3738 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3739 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3740 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3741 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3742 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3743 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3744 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3745 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3746 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3747 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3748 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3749 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3750 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3751 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3752 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3753 { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantizer scale (VBR)", "q" },
3754 { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3755 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3756 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3757 { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
3759 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "" },
3760 { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
3761 { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3762 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3763 "use same video quality as source (implies VBR)" },
3764 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3765 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3766 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3767 "deinterlace pictures" },
3768 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3769 { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
3770 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3771 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3772 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3773 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3774 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3775 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3776 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3777 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3780 { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
3781 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3782 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3783 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3784 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3785 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3786 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3787 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3788 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3789 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3791 /* subtitle options */
3792 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3793 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3794 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3797 { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
3798 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3799 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3800 { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
3802 /* G.2 grab options */
3803 { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
3804 { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
3807 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3808 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3810 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
3811 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
3813 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3817 static void show_banner(void)
3819 fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2006 Fabrice Bellard, et al.\n");
3820 fprintf(stderr, " configuration: " FFMPEG_CONFIGURATION "\n");
3821 fprintf(stderr, " libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
3822 fprintf(stderr, " libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
3823 fprintf(stderr, " libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
3824 fprintf(stderr, " built on " __DATE__ " " __TIME__);
3826 fprintf(stderr, ", gcc: " __VERSION__ "\n");
3828 fprintf(stderr, ", using a non-gcc compiler\n");
3832 static void show_license(void)
3837 "FFmpeg is free software; you can redistribute it and/or modify\n"
3838 "it under the terms of the GNU General Public License as published by\n"
3839 "the Free Software Foundation; either version 2 of the License, or\n"
3840 "(at your option) any later version.\n"
3842 "FFmpeg is distributed in the hope that it will be useful,\n"
3843 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3844 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
3845 "GNU General Public License for more details.\n"
3847 "You should have received a copy of the GNU General Public License\n"
3848 "along with FFmpeg; if not, write to the Free Software\n"
3849 "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n"
3853 "FFmpeg is free software; you can redistribute it and/or\n"
3854 "modify it under the terms of the GNU Lesser General Public\n"
3855 "License as published by the Free Software Foundation; either\n"
3856 "version 2.1 of the License, or (at your option) any later version.\n"
3858 "FFmpeg is distributed in the hope that it will be useful,\n"
3859 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3860 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
3861 "Lesser General Public License for more details.\n"
3863 "You should have received a copy of the GNU Lesser General Public\n"
3864 "License along with FFmpeg; if not, write to the Free Software\n"
3865 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
3871 static void show_help(void)
3874 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3875 "Hyper fast Audio and Video encoder\n");
3877 show_help_options(options, "Main options:\n",
3878 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3879 show_help_options(options, "\nVideo options:\n",
3880 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3882 show_help_options(options, "\nAdvanced Video options:\n",
3883 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3884 OPT_VIDEO | OPT_EXPERT);
3885 show_help_options(options, "\nAudio options:\n",
3886 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3888 show_help_options(options, "\nAdvanced Audio options:\n",
3889 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3890 OPT_AUDIO | OPT_EXPERT);
3891 show_help_options(options, "\nSubtitle options:\n",
3892 OPT_SUBTITLE | OPT_GRAB,
3894 show_help_options(options, "\nAudio/Video grab options:\n",
3897 show_help_options(options, "\nAdvanced options:\n",
3898 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3900 av_opt_show(avctx_opts, NULL);
3901 av_opt_show(avformat_opts, NULL);
3906 void parse_arg_file(const char *filename)
3908 opt_output_file(filename);
3911 int main(int argc, char **argv)
3918 avctx_opts= avcodec_alloc_context();
3919 avformat_opts = av_alloc_format_context();
3927 parse_options(argc, argv, options);
3929 /* file converter / grab */
3930 if (nb_output_files <= 0) {
3931 fprintf(stderr, "Must supply at least one output file\n");
3935 if (nb_input_files == 0) {
3941 av_encode(output_files, nb_output_files, input_files, nb_input_files,
3942 stream_maps, nb_stream_maps);
3943 ti = getutime() - ti;
3945 printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3949 for(i=0;i<nb_output_files;i++) {
3950 /* maybe av_close_output_file ??? */
3951 AVFormatContext *s = output_files[i];
3953 if (!(s->oformat->flags & AVFMT_NOFILE))
3955 for(j=0;j<s->nb_streams;j++)
3956 av_free(s->streams[j]);
3959 for(i=0;i<nb_input_files;i++)
3960 av_close_input_file(input_files[i]);
3965 av_free(intra_matrix);
3967 av_free(inter_matrix);
3969 #ifdef POWERPC_PERFORMANCE_REPORT
3970 extern void powerpc_display_perf_report(void);
3971 powerpc_display_perf_report();
3972 #endif /* POWERPC_PERFORMANCE_REPORT */
3975 if (received_sigterm) {
3977 "Received signal %d: terminating.\n",
3978 (int) received_sigterm);
3982 exit(0); /* not all OS-es handle main() return value */