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 AVImageFormat *image_format;
95 static int frame_width = 0;
96 static int frame_height = 0;
97 static float frame_aspect_ratio = 0;
98 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
99 static int frame_padtop = 0;
100 static int frame_padbottom = 0;
101 static int frame_padleft = 0;
102 static int frame_padright = 0;
103 static int padcolor[3] = {16,128,128}; /* default to black */
104 static int frame_topBand = 0;
105 static int frame_bottomBand = 0;
106 static int frame_leftBand = 0;
107 static int frame_rightBand = 0;
108 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
109 static int frame_rate = 25;
110 static int frame_rate_base = 1;
111 static float video_qscale = 0;
112 static int video_qdiff = 3;
113 static uint16_t *intra_matrix = NULL;
114 static uint16_t *inter_matrix = NULL;
115 #if 0 //experimental, (can be removed)
116 static float video_rc_qsquish=1.0;
117 static float video_rc_qmod_amp=0;
118 static int video_rc_qmod_freq=0;
120 static char *video_rc_override_string=NULL;
121 static char *video_rc_eq="tex^qComp";
122 static int me_method = ME_EPZS;
123 static int video_disable = 0;
124 static int video_discard = 0;
125 static int video_codec_id = CODEC_ID_NONE;
126 static int video_codec_tag = 0;
127 static int same_quality = 0;
128 static int do_deinterlace = 0;
129 static int packet_size = 0;
130 static int strict = 0;
131 static int top_field_first = -1;
132 static int me_threshold = 0;
133 static int intra_dc_precision = 8;
134 static int loop_input = 0;
135 static int loop_output = AVFMT_NOOUTPUTLOOP;
136 static int qp_hist = 0;
138 static int intra_only = 0;
139 static int audio_sample_rate = 44100;
140 static int audio_bit_rate = 64000;
141 #define QSCALE_NONE -99999
142 static float audio_qscale = QSCALE_NONE;
143 static int audio_disable = 0;
144 static int audio_channels = 1;
145 static int audio_codec_id = CODEC_ID_NONE;
146 static int audio_codec_tag = 0;
147 static char *audio_language = NULL;
149 static int subtitle_codec_id = CODEC_ID_NONE;
150 static char *subtitle_language = NULL;
152 static float mux_preload= 0.5;
153 static float mux_max_delay= 0.7;
155 static int64_t recording_time = 0;
156 static int64_t start_time = 0;
157 static int64_t rec_timestamp = 0;
158 static int64_t input_ts_offset = 0;
159 static int file_overwrite = 0;
160 static char *str_title = NULL;
161 static char *str_author = NULL;
162 static char *str_copyright = NULL;
163 static char *str_comment = NULL;
164 static char *str_album = NULL;
165 static int do_benchmark = 0;
166 static int do_hex_dump = 0;
167 static int do_pkt_dump = 0;
168 static int do_psnr = 0;
169 static int do_vstats = 0;
170 static int do_pass = 0;
171 static char *pass_logfilename = NULL;
172 static int audio_stream_copy = 0;
173 static int video_stream_copy = 0;
174 static int subtitle_stream_copy = 0;
175 static int video_sync_method= 1;
176 static int audio_sync_method= 0;
177 static int copy_ts= 0;
178 static int opt_shortest = 0; //
179 static int video_global_header = 0;
181 static int rate_emu = 0;
184 static const char *video_grab_format = "bktr";
186 #ifdef CONFIG_VIDEO4LINUX2
187 static const char *video_grab_format = "video4linux2";
189 static const char *video_grab_format = "video4linux";
192 static char *video_device = NULL;
193 static char *grab_device = NULL;
194 static int video_channel = 0;
195 static char *video_standard = "ntsc";
197 static const char *audio_grab_format = "audio_device";
198 static char *audio_device = NULL;
199 static int audio_volume = 256;
201 static int using_stdin = 0;
202 static int using_vhook = 0;
203 static int verbose = 1;
204 static int thread_count= 1;
205 static int q_pressed = 0;
206 static int64_t video_size = 0;
207 static int64_t audio_size = 0;
208 static int64_t extra_size = 0;
209 static int nb_frames_dup = 0;
210 static int nb_frames_drop = 0;
211 static int input_sync;
212 static int limit_filesize = 0; //
214 static int pgmyuv_compatibility_hack=0;
215 static int dts_delta_threshold = 10;
217 static int sws_flags = SWS_BICUBIC;
219 const char **opt_names=NULL;
220 int opt_name_count=0;
221 AVCodecContext *avctx_opts;
222 AVFormatContext *avformat_opts;
224 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
225 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
226 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
228 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
230 struct AVInputStream;
232 typedef struct AVOutputStream {
233 int file_index; /* file index */
234 int index; /* stream index in the output file */
235 int source_index; /* AVInputStream index */
236 AVStream *st; /* stream in the output file */
237 int encoding_needed; /* true if encoding needed for this stream */
239 /* input pts and corresponding output pts
241 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
242 struct AVInputStream *sync_ist; /* input stream to sync against */
243 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
246 AVFrame pict_tmp; /* temporary image for resampling */
247 struct SwsContext *img_resample_ctx; /* for image resampling */
251 int topBand; /* cropping area sizes */
255 int padtop; /* padding area sizes */
262 ReSampleContext *resample; /* for audio resampling */
263 AVFifoBuffer fifo; /* for compression: one audio fifo per codec */
267 typedef struct AVInputStream {
271 int discard; /* true if stream data should be discarded */
272 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
273 int64_t sample_index; /* current sample */
275 int64_t start; /* time when read started */
276 unsigned long frame; /* current frame */
277 int64_t next_pts; /* synthetic pts for cases where pkt.pts
279 int64_t pts; /* current pts */
280 int is_start; /* is 1 at the start and after a discontinuity */
283 typedef struct AVInputFile {
284 int eof_reached; /* true if eof reached */
285 int ist_index; /* index of first stream in ist_table */
286 int buffer_size; /* current total buffer size */
287 int buffer_size_max; /* buffer size at which we consider we can stop
289 int nb_streams; /* nb streams we are aware of */
294 /* init terminal so that we can grab keys */
295 static struct termios oldtty;
297 static void term_exit(void)
299 tcsetattr (0, TCSANOW, &oldtty);
302 static volatile sig_atomic_t received_sigterm = 0;
305 sigterm_handler(int sig)
307 received_sigterm = sig;
311 static void term_init(void)
318 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
319 |INLCR|IGNCR|ICRNL|IXON);
320 tty.c_oflag |= OPOST;
321 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
322 tty.c_cflag &= ~(CSIZE|PARENB);
327 tcsetattr (0, TCSANOW, &tty);
329 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
330 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
331 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
333 register a function to be called at normal program termination
336 #ifdef CONFIG_BEOS_NETSERVER
337 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
341 /* read a key without blocking */
342 static int read_key(void)
346 #ifndef CONFIG_BEOS_NETSERVER
354 n = select(1, &rfds, NULL, NULL, &tv);
366 static int decode_interrupt_cb(void)
368 return q_pressed || (q_pressed = read_key() == 'q');
373 static volatile int received_sigterm = 0;
375 /* no interactive support */
376 static void term_exit(void)
380 static void term_init(void)
384 static int read_key(void)
391 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
396 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
399 /* copy stream format */
400 s->nb_streams = ic->nb_streams;
401 for(i=0;i<ic->nb_streams;i++) {
404 // FIXME: a more elegant solution is needed
405 st = av_mallocz(sizeof(AVStream));
406 memcpy(st, ic->streams[i], sizeof(AVStream));
407 st->codec = avcodec_alloc_context();
408 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
412 av_close_input_file(ic);
417 get_sync_ipts(const AVOutputStream *ost)
419 const AVInputStream *ist = ost->sync_ist;
420 return (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/AV_TIME_BASE;
423 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
425 AVPacket new_pkt= *pkt;
426 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
427 &new_pkt.data, &new_pkt.size,
428 pkt->data, pkt->size,
429 pkt->flags & PKT_FLAG_KEY);
432 new_pkt.destruct= av_destruct_packet;
439 av_interleaved_write_frame(s, pkt);
442 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
444 static void do_audio_out(AVFormatContext *s,
447 unsigned char *buf, int size)
450 static uint8_t *audio_buf = NULL;
451 static uint8_t *audio_out = NULL;
452 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
454 int size_out, frame_bytes, ret;
455 AVCodecContext *enc= ost->st->codec;
457 /* SC: dynamic allocation of buffers */
459 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
461 audio_out = av_malloc(audio_out_size);
462 if (!audio_buf || !audio_out)
463 return; /* Should signal an error ! */
465 if(audio_sync_method){
466 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
467 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
468 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
469 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
471 //FIXME resample delay
472 if(fabs(delta) > 50){
475 byte_delta= FFMAX(byte_delta, -size);
479 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
484 static uint8_t *input_tmp= NULL;
485 input_tmp= av_realloc(input_tmp, byte_delta + size);
487 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
490 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
492 memset(input_tmp, 0, byte_delta);
493 memcpy(input_tmp + byte_delta, buf, size);
497 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
499 }else if(audio_sync_method>1){
500 int comp= clip(delta, -audio_sync_method, audio_sync_method);
501 assert(ost->audio_resample);
503 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
504 // fprintf(stderr, "drift:%f len:%d opts:%lld ipts:%lld fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2));
505 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
509 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
510 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
512 if (ost->audio_resample) {
514 size_out = audio_resample(ost->resample,
515 (short *)buftmp, (short *)buf,
516 size / (ist->st->codec->channels * 2));
517 size_out = size_out * enc->channels * 2;
523 /* now encode as many frames as possible */
524 if (enc->frame_size > 1) {
525 /* output resampled raw samples */
526 av_fifo_write(&ost->fifo, buftmp, size_out);
528 frame_bytes = enc->frame_size * 2 * enc->channels;
530 while (av_fifo_read(&ost->fifo, audio_buf, frame_bytes) == 0) {
532 av_init_packet(&pkt);
534 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
537 pkt.stream_index= ost->index;
540 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
541 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
542 pkt.flags |= PKT_FLAG_KEY;
543 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
545 ost->sync_opts += enc->frame_size;
549 av_init_packet(&pkt);
551 ost->sync_opts += size_out / (2 * enc->channels);
553 /* output a pcm frame */
554 /* XXX: change encoding codec API to avoid this ? */
555 switch(enc->codec->id) {
556 case CODEC_ID_PCM_S32LE:
557 case CODEC_ID_PCM_S32BE:
558 case CODEC_ID_PCM_U32LE:
559 case CODEC_ID_PCM_U32BE:
560 size_out = size_out << 1;
562 case CODEC_ID_PCM_S24LE:
563 case CODEC_ID_PCM_S24BE:
564 case CODEC_ID_PCM_U24LE:
565 case CODEC_ID_PCM_U24BE:
566 case CODEC_ID_PCM_S24DAUD:
567 size_out = size_out / 2 * 3;
569 case CODEC_ID_PCM_S16LE:
570 case CODEC_ID_PCM_S16BE:
571 case CODEC_ID_PCM_U16LE:
572 case CODEC_ID_PCM_U16BE:
575 size_out = size_out >> 1;
578 ret = avcodec_encode_audio(enc, audio_out, size_out,
581 pkt.stream_index= ost->index;
584 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
585 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
586 pkt.flags |= PKT_FLAG_KEY;
587 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
591 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
595 AVPicture picture_tmp;
598 dec = ist->st->codec;
600 /* deinterlace : must be done before any resize */
601 if (do_deinterlace || using_vhook) {
604 /* create temporary picture */
605 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
606 buf = av_malloc(size);
610 picture2 = &picture_tmp;
611 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
614 if(avpicture_deinterlace(picture2, picture,
615 dec->pix_fmt, dec->width, dec->height) < 0) {
616 /* if error, do not deinterlace */
622 img_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
628 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
630 if (picture != picture2)
631 *picture = *picture2;
635 /* we begin to correct av delay at this threshold */
636 #define AV_DELAY_MAX 0.100
638 static void do_subtitle_out(AVFormatContext *s,
644 static uint8_t *subtitle_out = NULL;
645 int subtitle_out_max_size = 65536;
646 int subtitle_out_size, nb, i;
650 if (pts == AV_NOPTS_VALUE) {
651 fprintf(stderr, "Subtitle packets must have a pts\n");
655 enc = ost->st->codec;
658 subtitle_out = av_malloc(subtitle_out_max_size);
661 /* Note: DVB subtitle need one packet to draw them and one other
662 packet to clear them */
663 /* XXX: signal it in the codec context ? */
664 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
669 for(i = 0; i < nb; i++) {
670 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
671 subtitle_out_max_size, sub);
673 av_init_packet(&pkt);
674 pkt.stream_index = ost->index;
675 pkt.data = subtitle_out;
676 pkt.size = subtitle_out_size;
677 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);
678 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
679 /* XXX: the pts correction is handled here. Maybe handling
680 it in the codec would be better */
682 pkt.pts += 90 * sub->start_display_time;
684 pkt.pts += 90 * sub->end_display_time;
686 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
690 static int bit_buffer_size= 1024*256;
691 static uint8_t *bit_buffer= NULL;
693 static void do_video_out(AVFormatContext *s,
699 int nb_frames, i, ret;
700 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
701 AVFrame picture_crop_temp, picture_pad_temp;
702 uint8_t *buf = NULL, *buf1 = NULL;
703 AVCodecContext *enc, *dec;
705 avcodec_get_frame_defaults(&picture_crop_temp);
706 avcodec_get_frame_defaults(&picture_pad_temp);
708 enc = ost->st->codec;
709 dec = ist->st->codec;
711 /* by default, we output a single frame */
716 if(video_sync_method){
718 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
719 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
722 else if (vdelta > 1.1)
723 nb_frames = lrintf(vdelta);
724 //fprintf(stderr, "vdelta:%f, ost->sync_opts:%lld, ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, ost->sync_ipts, nb_frames);
728 fprintf(stderr, "*** drop!\n");
729 }else if (nb_frames > 1) {
730 nb_frames_dup += nb_frames;
732 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
735 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
737 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
741 if (ost->video_crop) {
742 if (img_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
743 av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
746 formatted_picture = &picture_crop_temp;
748 formatted_picture = in_picture;
751 final_picture = formatted_picture;
752 padding_src = formatted_picture;
753 resampling_dst = &ost->pict_tmp;
754 if (ost->video_pad) {
755 final_picture = &ost->pict_tmp;
756 if (ost->video_resample) {
757 if (img_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
758 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
761 resampling_dst = &picture_pad_temp;
765 if (ost->video_resample) {
767 final_picture = &ost->pict_tmp;
768 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
769 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
772 if (ost->video_pad) {
773 img_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
774 enc->height, enc->width, enc->pix_fmt,
775 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
778 /* duplicates frame if needed */
779 for(i=0;i<nb_frames;i++) {
781 av_init_packet(&pkt);
782 pkt.stream_index= ost->index;
784 if (s->oformat->flags & AVFMT_RAWPICTURE) {
785 /* raw pictures are written as AVPicture structure to
786 avoid any copies. We support temorarily the older
788 AVFrame* old_frame = enc->coded_frame;
789 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
790 pkt.data= (uint8_t *)final_picture;
791 pkt.size= sizeof(AVPicture);
792 if(dec->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
793 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
794 if(dec->coded_frame && dec->coded_frame->key_frame)
795 pkt.flags |= PKT_FLAG_KEY;
797 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
798 enc->coded_frame = old_frame;
802 big_picture= *final_picture;
803 /* better than nothing: use input picture interlaced
805 big_picture.interlaced_frame = in_picture->interlaced_frame;
806 if(avctx_opts->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
807 if(top_field_first == -1)
808 big_picture.top_field_first = in_picture->top_field_first;
810 big_picture.top_field_first = top_field_first;
813 /* handles sameq here. This is not correct because it may
814 not be a global option */
816 big_picture.quality = ist->st->quality;
818 big_picture.quality = ost->st->quality;
820 big_picture.pict_type = 0;
821 // big_picture.pts = AV_NOPTS_VALUE;
822 big_picture.pts= ost->sync_opts;
823 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
824 //av_log(NULL, AV_LOG_DEBUG, "%lld -> encoder\n", ost->sync_opts);
825 ret = avcodec_encode_video(enc,
826 bit_buffer, bit_buffer_size,
829 fprintf(stderr, "Video encoding failed\n");
832 //enc->frame_number = enc->real_pict_num;
834 pkt.data= bit_buffer;
836 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
837 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
838 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %lld/%lld\n",
839 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
840 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
842 if(enc->coded_frame && enc->coded_frame->key_frame)
843 pkt.flags |= PKT_FLAG_KEY;
844 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
846 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
847 // enc->frame_number-1, enc->real_pict_num, ret,
849 /* if two pass, output log */
850 if (ost->logfile && enc->stats_out) {
851 fprintf(ost->logfile, "%s", enc->stats_out);
863 static double psnr(double d){
864 if(d==0) return INFINITY;
865 return -10.0*log(d)/log(10.0);
868 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
871 static FILE *fvstats=NULL;
878 double ti1, bitrate, avg_bitrate;
882 today = localtime(&today2);
883 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
886 fvstats = fopen(filename,"w");
894 enc = ost->st->codec;
895 if (enc->codec_type == CODEC_TYPE_VIDEO) {
896 frame_number = ost->frame_number;
897 fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
898 if (enc->flags&CODEC_FLAG_PSNR)
899 fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
901 fprintf(fvstats,"f_size= %6d ", frame_size);
902 /* compute pts value */
903 ti1 = ost->sync_opts * av_q2d(enc->time_base);
907 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
908 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
909 fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
910 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
911 fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
915 static void print_report(AVFormatContext **output_files,
916 AVOutputStream **ost_table, int nb_ostreams,
921 AVFormatContext *oc, *os;
924 int frame_number, vid, i;
925 double bitrate, ti1, pts;
926 static int64_t last_time = -1;
927 static int qp_histogram[52];
929 if (!is_last_report) {
931 /* display the report every 0.5 seconds */
932 cur_time = av_gettime();
933 if (last_time == -1) {
934 last_time = cur_time;
937 if ((cur_time - last_time) < 500000)
939 last_time = cur_time;
943 oc = output_files[0];
945 total_size = url_ftell(&oc->pb);
950 for(i=0;i<nb_ostreams;i++) {
952 os = output_files[ost->file_index];
953 enc = ost->st->codec;
954 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
955 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
956 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
958 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
959 frame_number = ost->frame_number;
960 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d q=%3.1f ",
961 frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
963 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
964 if(qp_hist && enc->coded_frame){
966 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
967 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
970 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
972 if (enc->flags&CODEC_FLAG_PSNR){
974 double error, error_sum=0;
975 double scale, scale_sum=0;
976 char type[3]= {'Y','U','V'};
977 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
980 error= enc->error[j];
981 scale= enc->width*enc->height*255.0*255.0*frame_number;
983 error= enc->coded_frame->error[j];
984 scale= enc->width*enc->height*255.0*255.0;
989 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
991 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
995 /* compute min output value */
996 pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
997 if ((pts < ti1) && (pts > 0))
1003 if (verbose || is_last_report) {
1004 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1006 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1007 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1008 (double)total_size / 1024, ti1, bitrate);
1011 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1012 nb_frames_dup, nb_frames_drop);
1015 fprintf(stderr, "%s \r", buf);
1020 if (is_last_report && verbose >= 0){
1021 int64_t raw= audio_size + video_size + extra_size;
1022 fprintf(stderr, "\n");
1023 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1027 100.0*(total_size - raw)/raw
1032 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1033 static int output_packet(AVInputStream *ist, int ist_index,
1034 AVOutputStream **ost_table, int nb_ostreams,
1035 const AVPacket *pkt)
1037 AVFormatContext *os;
1038 AVOutputStream *ost;
1042 int data_size, got_picture;
1044 void *buffer_to_free;
1045 static unsigned int samples_size= 0;
1046 static short *samples= NULL;
1047 AVSubtitle subtitle, *subtitle_to_free;
1051 ist->pts= ist->next_pts; // needed for last packet if vsync=0
1052 } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1053 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1055 // assert(ist->pts == ist->next_pts);
1069 /* decode the packet if needed */
1070 data_buf = NULL; /* fail safe */
1072 subtitle_to_free = NULL;
1073 if (ist->decoding_needed) {
1074 switch(ist->st->codec->codec_type) {
1075 case CODEC_TYPE_AUDIO:{
1077 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
1078 /* XXX: could avoid copy if PCM 16 bits with same
1079 endianness as CPU */
1080 ret = avcodec_decode_audio(ist->st->codec, samples, &data_size,
1086 /* Some bug in mpeg audio decoder gives */
1087 /* data_size < 0, it seems they are overflows */
1088 if (data_size <= 0) {
1089 /* no audio frame */
1092 data_buf = (uint8_t *)samples;
1093 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1094 (ist->st->codec->sample_rate * ist->st->codec->channels);
1096 case CODEC_TYPE_VIDEO:
1097 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1098 /* XXX: allocate picture correctly */
1099 avcodec_get_frame_defaults(&picture);
1101 ret = avcodec_decode_video(ist->st->codec,
1102 &picture, &got_picture, ptr, len);
1103 ist->st->quality= picture.quality;
1107 /* no picture yet */
1108 goto discard_packet;
1110 if (ist->st->codec->time_base.num != 0) {
1111 ist->next_pts += ((int64_t)AV_TIME_BASE *
1112 ist->st->codec->time_base.num) /
1113 ist->st->codec->time_base.den;
1117 case CODEC_TYPE_SUBTITLE:
1118 ret = avcodec_decode_subtitle(ist->st->codec,
1119 &subtitle, &got_subtitle, ptr, len);
1122 if (!got_subtitle) {
1123 goto discard_packet;
1125 subtitle_to_free = &subtitle;
1132 switch(ist->st->codec->codec_type) {
1133 case CODEC_TYPE_AUDIO:
1134 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1135 (ist->st->codec->sample_rate * ist->st->codec->channels);
1137 case CODEC_TYPE_VIDEO:
1138 if (ist->st->codec->time_base.num != 0) {
1139 ist->next_pts += ((int64_t)AV_TIME_BASE *
1140 ist->st->codec->time_base.num) /
1141 ist->st->codec->time_base.den;
1151 buffer_to_free = NULL;
1152 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1153 pre_process_video_frame(ist, (AVPicture *)&picture,
1157 // preprocess audio (volume)
1158 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1159 if (audio_volume != 256) {
1162 for(i=0;i<(data_size / sizeof(short));i++) {
1163 int v = ((*volp) * audio_volume + 128) >> 8;
1164 if (v < -32768) v = -32768;
1165 if (v > 32767) v = 32767;
1171 /* frame rate emulation */
1172 if (ist->st->codec->rate_emu) {
1173 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1174 int64_t now = av_gettime() - ist->start;
1182 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1183 is the one of the next displayed one */
1184 /* XXX: add mpeg4 too ? */
1185 if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1186 if (ist->st->codec->pict_type != B_TYPE) {
1188 tmp = ist->last_ip_pts;
1189 ist->last_ip_pts = ist->frac_pts.val;
1190 ist->frac_pts.val = tmp;
1194 /* if output time reached then transcode raw format,
1195 encode packets and output them */
1196 if (start_time == 0 || ist->pts >= start_time)
1197 for(i=0;i<nb_ostreams;i++) {
1201 if (ost->source_index == ist_index) {
1202 os = output_files[ost->file_index];
1205 printf("%d: got pts=%0.3f %0.3f\n", i,
1206 (double)pkt->pts / AV_TIME_BASE,
1207 ((double)ist->pts / AV_TIME_BASE) -
1208 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1210 /* set the input output pts pairs */
1211 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1213 if (ost->encoding_needed) {
1214 switch(ost->st->codec->codec_type) {
1215 case CODEC_TYPE_AUDIO:
1216 do_audio_out(os, ost, ist, data_buf, data_size);
1218 case CODEC_TYPE_VIDEO:
1219 do_video_out(os, ost, ist, &picture, &frame_size);
1220 video_size += frame_size;
1221 if (do_vstats && frame_size)
1222 do_video_stats(os, ost, frame_size);
1224 case CODEC_TYPE_SUBTITLE:
1225 do_subtitle_out(os, ost, ist, &subtitle,
1232 AVFrame avframe; //FIXME/XXX remove this
1234 av_init_packet(&opkt);
1236 /* no reencoding needed : output the packet directly */
1237 /* force the input stream PTS */
1239 avcodec_get_frame_defaults(&avframe);
1240 ost->st->codec->coded_frame= &avframe;
1241 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1243 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1244 audio_size += data_size;
1245 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1246 video_size += data_size;
1250 opkt.stream_index= ost->index;
1251 if(pkt->pts != AV_NOPTS_VALUE)
1252 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);
1254 opkt.pts= AV_NOPTS_VALUE;
1258 if (pkt->dts == AV_NOPTS_VALUE)
1259 dts = ist->next_pts;
1261 dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1262 opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
1264 opkt.flags= pkt->flags;
1266 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1267 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1268 opkt.destruct= av_destruct_packet;
1270 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
1271 ost->st->codec->frame_number++;
1272 ost->frame_number++;
1273 av_free_packet(&opkt);
1277 av_free(buffer_to_free);
1278 /* XXX: allocate the subtitles in the codec ? */
1279 if (subtitle_to_free) {
1280 if (subtitle_to_free->rects != NULL) {
1281 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1282 av_free(subtitle_to_free->rects[i].bitmap);
1283 av_free(subtitle_to_free->rects[i].rgba_palette);
1285 av_freep(&subtitle_to_free->rects);
1287 subtitle_to_free->num_rects = 0;
1288 subtitle_to_free = NULL;
1295 for(i=0;i<nb_ostreams;i++) {
1297 if (ost->source_index == ist_index) {
1298 AVCodecContext *enc= ost->st->codec;
1299 os = output_files[ost->file_index];
1301 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1303 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1306 if (ost->encoding_needed) {
1310 av_init_packet(&pkt);
1311 pkt.stream_index= ost->index;
1313 switch(ost->st->codec->codec_type) {
1314 case CODEC_TYPE_AUDIO:
1315 fifo_bytes = av_fifo_size(&ost->fifo);
1317 /* encode any samples remaining in fifo */
1318 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1319 int fs_tmp = enc->frame_size;
1320 enc->frame_size = fifo_bytes / (2 * enc->channels);
1321 if(av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes) == 0) {
1322 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1324 enc->frame_size = fs_tmp;
1327 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1330 pkt.flags |= PKT_FLAG_KEY;
1332 case CODEC_TYPE_VIDEO:
1333 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1335 if(enc->coded_frame && enc->coded_frame->key_frame)
1336 pkt.flags |= PKT_FLAG_KEY;
1337 if (ost->logfile && enc->stats_out) {
1338 fprintf(ost->logfile, "%s", enc->stats_out);
1347 pkt.data= bit_buffer;
1349 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1350 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1351 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1365 * The following code is the main loop of the file converter
1367 static int av_encode(AVFormatContext **output_files,
1368 int nb_output_files,
1369 AVFormatContext **input_files,
1371 AVStreamMap *stream_maps, int nb_stream_maps)
1373 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1374 AVFormatContext *is, *os;
1375 AVCodecContext *codec, *icodec;
1376 AVOutputStream *ost, **ost_table = NULL;
1377 AVInputStream *ist, **ist_table = NULL;
1378 AVInputFile *file_table;
1379 AVFormatContext *stream_no_data;
1382 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1386 /* input stream init */
1388 for(i=0;i<nb_input_files;i++) {
1389 is = input_files[i];
1390 file_table[i].ist_index = j;
1391 file_table[i].nb_streams = is->nb_streams;
1392 j += is->nb_streams;
1396 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1400 for(i=0;i<nb_istreams;i++) {
1401 ist = av_mallocz(sizeof(AVInputStream));
1407 for(i=0;i<nb_input_files;i++) {
1408 is = input_files[i];
1409 for(k=0;k<is->nb_streams;k++) {
1410 ist = ist_table[j++];
1411 ist->st = is->streams[k];
1412 ist->file_index = i;
1414 ist->discard = 1; /* the stream is discarded by default
1417 if (ist->st->codec->rate_emu) {
1418 ist->start = av_gettime();
1424 /* output stream init */
1426 for(i=0;i<nb_output_files;i++) {
1427 os = output_files[i];
1428 nb_ostreams += os->nb_streams;
1430 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1431 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1435 /* Sanity check the mapping args -- do the input files & streams exist? */
1436 for(i=0;i<nb_stream_maps;i++) {
1437 int fi = stream_maps[i].file_index;
1438 int si = stream_maps[i].stream_index;
1440 if (fi < 0 || fi > nb_input_files - 1 ||
1441 si < 0 || si > file_table[fi].nb_streams - 1) {
1442 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1445 fi = stream_maps[i].sync_file_index;
1446 si = stream_maps[i].sync_stream_index;
1447 if (fi < 0 || fi > nb_input_files - 1 ||
1448 si < 0 || si > file_table[fi].nb_streams - 1) {
1449 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1454 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1457 for(i=0;i<nb_ostreams;i++) {
1458 ost = av_mallocz(sizeof(AVOutputStream));
1465 for(k=0;k<nb_output_files;k++) {
1466 os = output_files[k];
1467 for(i=0;i<os->nb_streams;i++) {
1469 ost = ost_table[n++];
1470 ost->file_index = k;
1472 ost->st = os->streams[i];
1473 if (nb_stream_maps > 0) {
1474 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1475 stream_maps[n-1].stream_index;
1477 /* Sanity check that the stream types match */
1478 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1479 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1480 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1481 ost->file_index, ost->index);
1486 /* get corresponding input stream index : we select the first one with the right type */
1488 for(j=0;j<nb_istreams;j++) {
1491 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1492 ost->source_index = j;
1499 /* try again and reuse existing stream */
1500 for(j=0;j<nb_istreams;j++) {
1502 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1503 ost->source_index = j;
1508 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1509 ost->file_index, ost->index);
1514 ist = ist_table[ost->source_index];
1516 ost->sync_ist = (nb_stream_maps > 0) ?
1517 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1518 stream_maps[n-1].sync_stream_index] : ist;
1522 /* for each output stream, we compute the right encoding parameters */
1523 for(i=0;i<nb_ostreams;i++) {
1525 ist = ist_table[ost->source_index];
1527 codec = ost->st->codec;
1528 icodec = ist->st->codec;
1530 if (ost->st->stream_copy) {
1531 /* if stream_copy is selected, no need to decode or encode */
1532 codec->codec_id = icodec->codec_id;
1533 codec->codec_type = icodec->codec_type;
1534 if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1535 codec->bit_rate = icodec->bit_rate;
1536 codec->extradata= icodec->extradata;
1537 codec->extradata_size= icodec->extradata_size;
1538 codec->time_base = icodec->time_base;
1539 switch(codec->codec_type) {
1540 case CODEC_TYPE_AUDIO:
1541 codec->sample_rate = icodec->sample_rate;
1542 codec->channels = icodec->channels;
1543 codec->frame_size = icodec->frame_size;
1544 codec->block_align= icodec->block_align;
1546 case CODEC_TYPE_VIDEO:
1547 codec->pix_fmt = icodec->pix_fmt;
1548 codec->width = icodec->width;
1549 codec->height = icodec->height;
1550 codec->has_b_frames = icodec->has_b_frames;
1552 case CODEC_TYPE_SUBTITLE:
1558 switch(codec->codec_type) {
1559 case CODEC_TYPE_AUDIO:
1560 if (av_fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1563 if (codec->channels == icodec->channels &&
1564 codec->sample_rate == icodec->sample_rate) {
1565 ost->audio_resample = 0;
1567 if (codec->channels != icodec->channels &&
1568 (icodec->codec_id == CODEC_ID_AC3 ||
1569 icodec->codec_id == CODEC_ID_DTS)) {
1570 /* Special case for 5:1 AC3 and DTS input */
1571 /* and mono or stereo output */
1572 /* Request specific number of channels */
1573 icodec->channels = codec->channels;
1574 if (codec->sample_rate == icodec->sample_rate)
1575 ost->audio_resample = 0;
1577 ost->audio_resample = 1;
1580 ost->audio_resample = 1;
1583 if(audio_sync_method>1)
1584 ost->audio_resample = 1;
1586 if(ost->audio_resample){
1587 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1588 codec->sample_rate, icodec->sample_rate);
1590 printf("Can't resample. Aborting.\n");
1594 ist->decoding_needed = 1;
1595 ost->encoding_needed = 1;
1597 case CODEC_TYPE_VIDEO:
1598 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1599 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1600 ost->video_resample = ((codec->width != icodec->width -
1601 (frame_leftBand + frame_rightBand) +
1602 (frame_padleft + frame_padright)) ||
1603 (codec->height != icodec->height -
1604 (frame_topBand + frame_bottomBand) +
1605 (frame_padtop + frame_padbottom)) ||
1606 (codec->pix_fmt != icodec->pix_fmt));
1607 if (ost->video_crop) {
1608 ost->topBand = frame_topBand;
1609 ost->leftBand = frame_leftBand;
1611 if (ost->video_pad) {
1612 ost->padtop = frame_padtop;
1613 ost->padleft = frame_padleft;
1614 ost->padbottom = frame_padbottom;
1615 ost->padright = frame_padright;
1616 if (!ost->video_resample) {
1617 avcodec_get_frame_defaults(&ost->pict_tmp);
1618 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1619 codec->width, codec->height ) )
1623 if (ost->video_resample) {
1624 avcodec_get_frame_defaults(&ost->pict_tmp);
1625 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1626 codec->width, codec->height ) )
1629 ost->img_resample_ctx = sws_getContext(
1630 icodec->width - (frame_leftBand + frame_rightBand),
1631 icodec->height - (frame_topBand + frame_bottomBand),
1633 codec->width - (frame_padleft + frame_padright),
1634 codec->height - (frame_padtop + frame_padbottom),
1636 sws_flags, NULL, NULL, NULL);
1637 if (ost->img_resample_ctx == NULL) {
1638 fprintf(stderr, "Cannot get resampling context\n");
1641 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1643 ost->encoding_needed = 1;
1644 ist->decoding_needed = 1;
1646 case CODEC_TYPE_SUBTITLE:
1647 ost->encoding_needed = 1;
1648 ist->decoding_needed = 1;
1655 if (ost->encoding_needed &&
1656 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1657 char logfilename[1024];
1662 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1664 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1665 if (codec->flags & CODEC_FLAG_PASS1) {
1666 f = fopen(logfilename, "w");
1668 perror(logfilename);
1673 /* read the log file */
1674 f = fopen(logfilename, "r");
1676 perror(logfilename);
1679 fseek(f, 0, SEEK_END);
1681 fseek(f, 0, SEEK_SET);
1682 logbuffer = av_malloc(size + 1);
1684 fprintf(stderr, "Could not allocate log buffer\n");
1687 size = fread(logbuffer, 1, size, f);
1689 logbuffer[size] = '\0';
1690 codec->stats_in = logbuffer;
1694 if(codec->codec_type == CODEC_TYPE_VIDEO){
1695 int size= codec->width * codec->height;
1696 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1701 bit_buffer = av_malloc(bit_buffer_size);
1705 /* dump the file output parameters - cannot be done before in case
1707 for(i=0;i<nb_output_files;i++) {
1708 dump_format(output_files[i], i, output_files[i]->filename, 1);
1711 /* dump the stream mapping */
1713 fprintf(stderr, "Stream mapping:\n");
1714 for(i=0;i<nb_ostreams;i++) {
1716 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1717 ist_table[ost->source_index]->file_index,
1718 ist_table[ost->source_index]->index,
1721 if (ost->sync_ist != ist_table[ost->source_index])
1722 fprintf(stderr, " [sync #%d.%d]",
1723 ost->sync_ist->file_index,
1724 ost->sync_ist->index);
1725 fprintf(stderr, "\n");
1729 /* open each encoder */
1730 for(i=0;i<nb_ostreams;i++) {
1732 if (ost->encoding_needed) {
1734 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1736 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1737 ost->file_index, ost->index);
1740 if (avcodec_open(ost->st->codec, codec) < 0) {
1741 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1742 ost->file_index, ost->index);
1745 extra_size += ost->st->codec->extradata_size;
1749 /* open each decoder */
1750 for(i=0;i<nb_istreams;i++) {
1752 if (ist->decoding_needed) {
1754 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1756 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1757 ist->st->codec->codec_id, ist->file_index, ist->index);
1760 if (avcodec_open(ist->st->codec, codec) < 0) {
1761 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1762 ist->file_index, ist->index);
1765 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1766 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1771 for(i=0;i<nb_istreams;i++) {
1773 is = input_files[ist->file_index];
1775 ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1776 if(ist->st->start_time == AV_NOPTS_VALUE)
1778 if(input_files_ts_offset[ist->file_index])
1779 ist->next_pts= AV_NOPTS_VALUE;
1783 /* compute buffer size max (should use a complete heuristic) */
1784 for(i=0;i<nb_input_files;i++) {
1785 file_table[i].buffer_size_max = 2048;
1788 /* set meta data information from input file if required */
1789 for (i=0;i<nb_meta_data_maps;i++) {
1790 AVFormatContext *out_file;
1791 AVFormatContext *in_file;
1793 int out_file_index = meta_data_maps[i].out_file;
1794 int in_file_index = meta_data_maps[i].in_file;
1795 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1796 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1800 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1801 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1806 out_file = output_files[out_file_index];
1807 in_file = input_files[in_file_index];
1809 strcpy(out_file->title, in_file->title);
1810 strcpy(out_file->author, in_file->author);
1811 strcpy(out_file->copyright, in_file->copyright);
1812 strcpy(out_file->comment, in_file->comment);
1813 strcpy(out_file->album, in_file->album);
1814 out_file->year = in_file->year;
1815 out_file->track = in_file->track;
1816 strcpy(out_file->genre, in_file->genre);
1819 /* open files and write file headers */
1820 for(i=0;i<nb_output_files;i++) {
1821 os = output_files[i];
1822 if (av_write_header(os) < 0) {
1823 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1830 if ( !using_stdin && verbose >= 0) {
1831 fprintf(stderr, "Press [q] to stop encoding\n");
1832 url_set_interrupt_cb(decode_interrupt_cb);
1840 for(; received_sigterm == 0;) {
1841 int file_index, ist_index;
1849 /* if 'q' pressed, exits */
1853 /* read_key() returns 0 on EOF */
1859 /* select the stream that we must read now by looking at the
1860 smallest output pts */
1862 for(i=0;i<nb_ostreams;i++) {
1865 os = output_files[ost->file_index];
1866 ist = ist_table[ost->source_index];
1867 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1868 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1870 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1871 ipts = (double)ist->pts;
1872 if (!file_table[ist->file_index].eof_reached){
1873 if(ipts < ipts_min) {
1875 if(input_sync ) file_index = ist->file_index;
1877 if(opts < opts_min) {
1879 if(!input_sync) file_index = ist->file_index;
1882 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1887 /* if none, if is finished */
1888 if (file_index < 0) {
1892 /* finish if recording time exhausted */
1893 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1896 /* finish if limit size exhausted */
1897 if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
1900 /* read a frame from it and output it in the fifo */
1901 is = input_files[file_index];
1902 if (av_read_frame(is, &pkt) < 0) {
1903 file_table[file_index].eof_reached = 1;
1904 if (opt_shortest) break; else continue; //
1908 stream_no_data = is;
1913 av_pkt_dump(stdout, &pkt, do_hex_dump);
1915 /* the following test is needed in case new streams appear
1916 dynamically in stream : we ignore them */
1917 if (pkt.stream_index >= file_table[file_index].nb_streams)
1918 goto discard_packet;
1919 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1920 ist = ist_table[ist_index];
1922 goto discard_packet;
1924 // fprintf(stderr, "next:%lld dts:%lld off:%lld %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec->codec_type);
1925 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1926 int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
1927 if(ABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
1928 input_files_ts_offset[ist->file_index]-= delta;
1930 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1931 for(i=0; i<file_table[file_index].nb_streams; i++){
1932 int index= file_table[file_index].ist_index + i;
1933 ist_table[index]->next_pts += delta;
1934 ist_table[index]->is_start=1;
1939 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1940 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1943 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1944 ist->file_index, ist->index);
1946 av_free_packet(&pkt);
1951 av_free_packet(&pkt);
1953 /* dump report by using the output first video and audio streams */
1954 print_report(output_files, ost_table, nb_ostreams, 0);
1957 /* at the end of stream, we must flush the decoder buffers */
1958 for(i=0;i<nb_istreams;i++) {
1960 if (ist->decoding_needed) {
1961 output_packet(ist, i, ost_table, nb_ostreams, NULL);
1967 /* write the trailer if needed and close file */
1968 for(i=0;i<nb_output_files;i++) {
1969 os = output_files[i];
1970 av_write_trailer(os);
1973 /* dump report by using the first video and audio streams */
1974 print_report(output_files, ost_table, nb_ostreams, 1);
1976 /* close each encoder */
1977 for(i=0;i<nb_ostreams;i++) {
1979 if (ost->encoding_needed) {
1980 av_freep(&ost->st->codec->stats_in);
1981 avcodec_close(ost->st->codec);
1985 /* close each decoder */
1986 for(i=0;i<nb_istreams;i++) {
1988 if (ist->decoding_needed) {
1989 avcodec_close(ist->st->codec);
1997 av_freep(&bit_buffer);
1998 av_free(file_table);
2001 for(i=0;i<nb_istreams;i++) {
2008 for(i=0;i<nb_ostreams;i++) {
2012 fclose(ost->logfile);
2013 ost->logfile = NULL;
2015 av_fifo_free(&ost->fifo); /* works even if fifo is not
2016 initialized but set to zero */
2017 av_free(ost->pict_tmp.data[0]);
2018 if (ost->video_resample)
2019 sws_freeContext(ost->img_resample_ctx);
2020 if (ost->audio_resample)
2021 audio_resample_close(ost->resample);
2034 int file_read(const char *filename)
2037 unsigned char buffer[1024];
2040 if (url_open(&h, filename, O_RDONLY) < 0) {
2041 printf("could not open '%s'\n", filename);
2045 len = url_read(h, buffer, sizeof(buffer));
2048 for(i=0;i<len;i++) putchar(buffer[i]);
2055 static void opt_image_format(const char *arg)
2059 for(f = first_image_format; f != NULL; f = f->next) {
2060 if (!strcmp(arg, f->name))
2064 fprintf(stderr, "Unknown image format: '%s'\n", arg);
2070 static void opt_format(const char *arg)
2072 /* compatibility stuff for pgmyuv */
2073 if (!strcmp(arg, "pgmyuv")) {
2074 pgmyuv_compatibility_hack=1;
2075 // opt_image_format(arg);
2079 file_iformat = av_find_input_format(arg);
2080 file_oformat = guess_format(arg, NULL, NULL);
2081 if (!file_iformat && !file_oformat) {
2082 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2087 static void opt_video_rc_eq(char *arg)
2092 static void opt_video_rc_override_string(char *arg)
2094 video_rc_override_string = arg;
2097 static void opt_me_threshold(const char *arg)
2099 me_threshold = atoi(arg);
2102 static void opt_verbose(const char *arg)
2104 verbose = atoi(arg);
2105 av_log_set_level(atoi(arg));
2108 static void opt_frame_rate(const char *arg)
2110 if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2111 fprintf(stderr, "Incorrect frame rate\n");
2116 static void opt_frame_crop_top(const char *arg)
2118 frame_topBand = atoi(arg);
2119 if (frame_topBand < 0) {
2120 fprintf(stderr, "Incorrect top crop size\n");
2123 if ((frame_topBand % 2) != 0) {
2124 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2127 if ((frame_topBand) >= frame_height){
2128 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2131 frame_height -= frame_topBand;
2134 static void opt_frame_crop_bottom(const char *arg)
2136 frame_bottomBand = atoi(arg);
2137 if (frame_bottomBand < 0) {
2138 fprintf(stderr, "Incorrect bottom crop size\n");
2141 if ((frame_bottomBand % 2) != 0) {
2142 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2145 if ((frame_bottomBand) >= frame_height){
2146 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2149 frame_height -= frame_bottomBand;
2152 static void opt_frame_crop_left(const char *arg)
2154 frame_leftBand = atoi(arg);
2155 if (frame_leftBand < 0) {
2156 fprintf(stderr, "Incorrect left crop size\n");
2159 if ((frame_leftBand % 2) != 0) {
2160 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2163 if ((frame_leftBand) >= frame_width){
2164 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2167 frame_width -= frame_leftBand;
2170 static void opt_frame_crop_right(const char *arg)
2172 frame_rightBand = atoi(arg);
2173 if (frame_rightBand < 0) {
2174 fprintf(stderr, "Incorrect right crop size\n");
2177 if ((frame_rightBand % 2) != 0) {
2178 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2181 if ((frame_rightBand) >= frame_width){
2182 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2185 frame_width -= frame_rightBand;
2188 static void opt_frame_size(const char *arg)
2190 if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2191 fprintf(stderr, "Incorrect frame size\n");
2194 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2195 fprintf(stderr, "Frame size must be a multiple of 2\n");
2201 #define SCALEBITS 10
2202 #define ONE_HALF (1 << (SCALEBITS - 1))
2203 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2205 #define RGB_TO_Y(r, g, b) \
2206 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2207 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2209 #define RGB_TO_U(r1, g1, b1, shift)\
2210 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2211 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2213 #define RGB_TO_V(r1, g1, b1, shift)\
2214 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2215 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2217 static void opt_pad_color(const char *arg) {
2218 /* Input is expected to be six hex digits similar to
2219 how colors are expressed in html tags (but without the #) */
2220 int rgb = strtol(arg, NULL, 16);
2224 g = ((rgb >> 8) & 255);
2227 padcolor[0] = RGB_TO_Y(r,g,b);
2228 padcolor[1] = RGB_TO_U(r,g,b,0);
2229 padcolor[2] = RGB_TO_V(r,g,b,0);
2232 static void opt_frame_pad_top(const char *arg)
2234 frame_padtop = atoi(arg);
2235 if (frame_padtop < 0) {
2236 fprintf(stderr, "Incorrect top pad size\n");
2239 if ((frame_padtop % 2) != 0) {
2240 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2245 static void opt_frame_pad_bottom(const char *arg)
2247 frame_padbottom = atoi(arg);
2248 if (frame_padbottom < 0) {
2249 fprintf(stderr, "Incorrect bottom pad size\n");
2252 if ((frame_padbottom % 2) != 0) {
2253 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2259 static void opt_frame_pad_left(const char *arg)
2261 frame_padleft = atoi(arg);
2262 if (frame_padleft < 0) {
2263 fprintf(stderr, "Incorrect left pad size\n");
2266 if ((frame_padleft % 2) != 0) {
2267 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2273 static void opt_frame_pad_right(const char *arg)
2275 frame_padright = atoi(arg);
2276 if (frame_padright < 0) {
2277 fprintf(stderr, "Incorrect right pad size\n");
2280 if ((frame_padright % 2) != 0) {
2281 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2287 static void opt_frame_pix_fmt(const char *arg)
2289 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2292 static void opt_frame_aspect_ratio(const char *arg)
2298 p = strchr(arg, ':');
2300 x = strtol(arg, (char **)&arg, 10);
2302 y = strtol(arg+1, (char **)&arg, 10);
2304 ar = (double)x / (double)y;
2306 ar = strtod(arg, (char **)&arg);
2309 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2312 frame_aspect_ratio = ar;
2315 static void opt_qscale(const char *arg)
2317 video_qscale = atof(arg);
2318 if (video_qscale <= 0 ||
2319 video_qscale > 255) {
2320 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2325 static void opt_qdiff(const char *arg)
2327 video_qdiff = atoi(arg);
2328 if (video_qdiff < 0 ||
2330 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2335 static void opt_packet_size(const char *arg)
2337 packet_size= atoi(arg);
2340 static void opt_strict(const char *arg)
2345 static void opt_top_field_first(const char *arg)
2347 top_field_first= atoi(arg);
2350 static void opt_thread_count(const char *arg)
2352 thread_count= atoi(arg);
2353 #if !defined(HAVE_THREADS)
2355 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2359 static void opt_audio_bitrate(const char *arg)
2361 audio_bit_rate = atoi(arg) * 1000;
2364 static void opt_audio_rate(const char *arg)
2366 audio_sample_rate = atoi(arg);
2369 static void opt_audio_channels(const char *arg)
2371 audio_channels = atoi(arg);
2374 static void opt_video_device(const char *arg)
2376 video_device = av_strdup(arg);
2379 static void opt_grab_device(const char *arg)
2381 grab_device = av_strdup(arg);
2384 static void opt_video_channel(const char *arg)
2386 video_channel = strtol(arg, NULL, 0);
2389 static void opt_video_standard(const char *arg)
2391 video_standard = av_strdup(arg);
2394 static void opt_audio_device(const char *arg)
2396 audio_device = av_strdup(arg);
2399 static void opt_codec(int *pstream_copy, int *pcodec_id,
2400 int codec_type, const char *arg)
2404 if (!strcmp(arg, "copy")) {
2409 if (!strcmp(p->name, arg) && p->type == codec_type)
2414 fprintf(stderr, "Unknown codec '%s'\n", arg);
2422 static void opt_audio_codec(const char *arg)
2424 opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2427 static void opt_audio_tag(const char *arg)
2430 audio_codec_tag= strtol(arg, &tail, 0);
2433 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2436 static void opt_video_tag(const char *arg)
2439 video_codec_tag= strtol(arg, &tail, 0);
2442 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2445 static void add_frame_hooker(const char *arg)
2450 char *args = av_strdup(arg);
2454 argv[0] = strtok(args, " ");
2455 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2458 i = frame_hook_add(argc, argv);
2461 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2466 const char *motion_str[] = {
2479 static void opt_motion_estimation(const char *arg)
2485 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2488 if (!strcmp(*p, arg))
2492 me_method = (p - motion_str) + 1;
2495 static void opt_video_codec(const char *arg)
2497 opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2500 static void opt_subtitle_codec(const char *arg)
2502 opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2505 static void opt_map(const char *arg)
2511 m = &stream_maps[nb_stream_maps++];
2513 m->file_index = strtol(arg, (char **)&p, 0);
2517 m->stream_index = strtol(p, (char **)&p, 0);
2520 m->sync_file_index = strtol(p, (char **)&p, 0);
2523 m->sync_stream_index = strtol(p, (char **)&p, 0);
2525 m->sync_file_index = m->file_index;
2526 m->sync_stream_index = m->stream_index;
2530 static void opt_map_meta_data(const char *arg)
2536 m = &meta_data_maps[nb_meta_data_maps++];
2538 m->out_file = strtol(arg, (char **)&p, 0);
2542 m->in_file = strtol(p, (char **)&p, 0);
2545 static void opt_recording_time(const char *arg)
2547 recording_time = parse_date(arg, 1);
2550 static void opt_start_time(const char *arg)
2552 start_time = parse_date(arg, 1);
2555 static void opt_rec_timestamp(const char *arg)
2557 rec_timestamp = parse_date(arg, 0) / 1000000;
2560 static void opt_input_ts_offset(const char *arg)
2562 input_ts_offset = parse_date(arg, 1);
2565 static void opt_input_file(const char *filename)
2567 AVFormatContext *ic;
2568 AVFormatParameters params, *ap = ¶ms;
2569 int err, i, ret, rfps, rfps_base;
2572 if (!strcmp(filename, "-"))
2575 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2576 !strcmp( filename, "/dev/stdin" );
2578 /* get default parameters from command line */
2579 ic = av_alloc_format_context();
2581 memset(ap, 0, sizeof(*ap));
2582 ap->prealloced_context = 1;
2583 ap->sample_rate = audio_sample_rate;
2584 ap->channels = audio_channels;
2585 ap->time_base.den = frame_rate;
2586 ap->time_base.num = frame_rate_base;
2587 ap->width = frame_width + frame_padleft + frame_padright;
2588 ap->height = frame_height + frame_padtop + frame_padbottom;
2589 ap->image_format = image_format;
2590 ap->pix_fmt = frame_pix_fmt;
2591 ap->device = grab_device;
2592 ap->channel = video_channel;
2593 ap->standard = video_standard;
2594 ap->video_codec_id = video_codec_id;
2595 ap->audio_codec_id = audio_codec_id;
2596 if(pgmyuv_compatibility_hack)
2597 ap->video_codec_id= CODEC_ID_PGMYUV;
2599 for(i=0; i<opt_name_count; i++){
2601 double d= av_get_double(avformat_opts, opt_names[i], &opt);
2602 if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2603 av_set_double(ic, opt_names[i], d);
2605 /* open the input file with generic libav function */
2606 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2608 print_error(filename, err);
2612 ic->loop_input = loop_input;
2614 /* If not enough info to get the stream parameters, we decode the
2615 first frames to get it. (used in mpeg case for example) */
2616 ret = av_find_stream_info(ic);
2617 if (ret < 0 && verbose >= 0) {
2618 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2622 timestamp = start_time;
2623 /* add the stream start time */
2624 if (ic->start_time != AV_NOPTS_VALUE)
2625 timestamp += ic->start_time;
2627 /* if seeking requested, we execute it */
2628 if (start_time != 0) {
2629 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2631 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2632 filename, (double)timestamp / AV_TIME_BASE);
2634 /* reset seek info */
2638 /* update the current parameters so that they match the one of the input stream */
2639 for(i=0;i<ic->nb_streams;i++) {
2641 AVCodecContext *enc = ic->streams[i]->codec;
2642 #if defined(HAVE_THREADS)
2644 avcodec_thread_init(enc, thread_count);
2646 enc->thread_count= thread_count;
2647 switch(enc->codec_type) {
2648 case CODEC_TYPE_AUDIO:
2649 for(j=0; j<opt_name_count; j++){
2651 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2652 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2653 av_set_double(enc, opt_names[j], d);
2655 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2656 audio_channels = enc->channels;
2657 audio_sample_rate = enc->sample_rate;
2659 ic->streams[i]->discard= AVDISCARD_ALL;
2661 case CODEC_TYPE_VIDEO:
2662 for(j=0; j<opt_name_count; j++){
2664 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2665 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2666 av_set_double(enc, opt_names[j], d);
2668 frame_height = enc->height;
2669 frame_width = enc->width;
2670 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2671 frame_pix_fmt = enc->pix_fmt;
2672 rfps = ic->streams[i]->r_frame_rate.num;
2673 rfps_base = ic->streams[i]->r_frame_rate.den;
2674 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2676 enc->debug |= FF_DEBUG_MV;
2678 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2681 fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2682 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2684 (float)rfps / rfps_base, rfps, rfps_base);
2686 /* update the current frame rate to match the stream frame rate */
2688 frame_rate_base = rfps_base;
2690 enc->rate_emu = rate_emu;
2692 ic->streams[i]->discard= AVDISCARD_ALL;
2693 else if(video_discard)
2694 ic->streams[i]->discard= video_discard;
2696 case CODEC_TYPE_DATA:
2698 case CODEC_TYPE_SUBTITLE:
2700 case CODEC_TYPE_UNKNOWN:
2707 input_files[nb_input_files] = ic;
2708 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2709 /* dump the file content */
2711 dump_format(ic, nb_input_files, filename, 0);
2714 file_iformat = NULL;
2715 file_oformat = NULL;
2716 image_format = NULL;
2724 static void opt_grab(const char *arg)
2726 file_iformat = av_find_input_format(arg);
2730 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2732 int has_video, has_audio, i, j;
2733 AVFormatContext *ic;
2737 for(j=0;j<nb_input_files;j++) {
2738 ic = input_files[j];
2739 for(i=0;i<ic->nb_streams;i++) {
2740 AVCodecContext *enc = ic->streams[i]->codec;
2741 switch(enc->codec_type) {
2742 case CODEC_TYPE_AUDIO:
2745 case CODEC_TYPE_VIDEO:
2748 case CODEC_TYPE_DATA:
2749 case CODEC_TYPE_UNKNOWN:
2750 case CODEC_TYPE_SUBTITLE:
2757 *has_video_ptr = has_video;
2758 *has_audio_ptr = has_audio;
2761 static void new_video_stream(AVFormatContext *oc)
2764 AVCodecContext *video_enc;
2767 st = av_new_stream(oc, oc->nb_streams);
2769 fprintf(stderr, "Could not alloc stream\n");
2772 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2773 video_bitstream_filters= NULL;
2775 #if defined(HAVE_THREADS)
2777 avcodec_thread_init(st->codec, thread_count);
2780 video_enc = st->codec;
2783 video_enc->codec_tag= video_codec_tag;
2785 if( (video_global_header&1)
2786 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2787 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2788 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2790 if(video_global_header&2){
2791 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2792 avctx_opts->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2795 if (video_stream_copy) {
2796 st->stream_copy = 1;
2797 video_enc->codec_type = CODEC_TYPE_VIDEO;
2803 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2804 if (video_codec_id != CODEC_ID_NONE)
2805 codec_id = video_codec_id;
2807 video_enc->codec_id = codec_id;
2808 codec = avcodec_find_encoder(codec_id);
2810 for(i=0; i<opt_name_count; i++){
2812 double d= av_get_double(avctx_opts, opt_names[i], &opt);
2813 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2814 av_set_double(video_enc, opt_names[i], d);
2817 video_enc->time_base.den = frame_rate;
2818 video_enc->time_base.num = frame_rate_base;
2819 if(codec && codec->supported_framerates){
2820 const AVRational *p= codec->supported_framerates;
2821 AVRational req= (AVRational){frame_rate, frame_rate_base};
2822 const AVRational *best=NULL;
2823 AVRational best_error= (AVRational){INT_MAX, 1};
2824 for(; p->den!=0; p++){
2825 AVRational error= av_sub_q(req, *p);
2826 if(error.num <0) error.num *= -1;
2827 if(av_cmp_q(error, best_error) < 0){
2832 video_enc->time_base.den= best->num;
2833 video_enc->time_base.num= best->den;
2836 video_enc->width = frame_width + frame_padright + frame_padleft;
2837 video_enc->height = frame_height + frame_padtop + frame_padbottom;
2838 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2839 video_enc->pix_fmt = frame_pix_fmt;
2841 if(codec && codec->pix_fmts){
2842 const enum PixelFormat *p= codec->pix_fmts;
2844 if(*p == video_enc->pix_fmt)
2848 video_enc->pix_fmt = codec->pix_fmts[0];
2852 video_enc->gop_size = 0;
2853 if (video_qscale || same_quality) {
2854 video_enc->flags |= CODEC_FLAG_QSCALE;
2855 video_enc->global_quality=
2856 st->quality = FF_QP2LAMBDA * video_qscale;
2860 video_enc->intra_matrix = intra_matrix;
2862 video_enc->inter_matrix = inter_matrix;
2864 video_enc->max_qdiff = video_qdiff;
2865 video_enc->rc_eq = video_rc_eq;
2866 video_enc->thread_count = thread_count;
2867 p= video_rc_override_string;
2870 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2872 fprintf(stderr, "error parsing rc_override\n");
2875 video_enc->rc_override=
2876 av_realloc(video_enc->rc_override,
2877 sizeof(RcOverride)*(i+1));
2878 video_enc->rc_override[i].start_frame= start;
2879 video_enc->rc_override[i].end_frame = end;
2881 video_enc->rc_override[i].qscale= q;
2882 video_enc->rc_override[i].quality_factor= 1.0;
2885 video_enc->rc_override[i].qscale= 0;
2886 video_enc->rc_override[i].quality_factor= -q/100.0;
2891 video_enc->rc_override_count=i;
2892 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2893 video_enc->me_threshold= me_threshold;
2894 video_enc->intra_dc_precision= intra_dc_precision - 8;
2895 video_enc->strict_std_compliance = strict;
2898 video_enc->rtp_mode= 1;
2899 video_enc->rtp_payload_size= packet_size;
2903 video_enc->flags|= CODEC_FLAG_PSNR;
2905 video_enc->me_method = me_method;
2910 video_enc->flags |= CODEC_FLAG_PASS1;
2912 video_enc->flags |= CODEC_FLAG_PASS2;
2917 /* reset some key parameters */
2919 video_codec_id = CODEC_ID_NONE;
2920 video_stream_copy = 0;
2923 static void new_audio_stream(AVFormatContext *oc)
2926 AVCodecContext *audio_enc;
2929 st = av_new_stream(oc, oc->nb_streams);
2931 fprintf(stderr, "Could not alloc stream\n");
2935 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2936 audio_bitstream_filters= NULL;
2938 #if defined(HAVE_THREADS)
2940 avcodec_thread_init(st->codec, thread_count);
2943 audio_enc = st->codec;
2944 audio_enc->codec_type = CODEC_TYPE_AUDIO;
2947 audio_enc->codec_tag= audio_codec_tag;
2949 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
2950 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2951 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2953 if (audio_stream_copy) {
2954 st->stream_copy = 1;
2955 audio_enc->channels = audio_channels;
2957 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
2959 for(i=0; i<opt_name_count; i++){
2961 double d= av_get_double(avctx_opts, opt_names[i], &opt);
2962 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2963 av_set_double(audio_enc, opt_names[i], d);
2966 if (audio_codec_id != CODEC_ID_NONE)
2967 codec_id = audio_codec_id;
2968 audio_enc->codec_id = codec_id;
2970 audio_enc->bit_rate = audio_bit_rate;
2971 if (audio_qscale > QSCALE_NONE) {
2972 audio_enc->flags |= CODEC_FLAG_QSCALE;
2973 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
2975 audio_enc->strict_std_compliance = strict;
2976 audio_enc->thread_count = thread_count;
2977 /* For audio codecs other than AC3 or DTS we limit */
2978 /* the number of coded channels to stereo */
2979 if (audio_channels > 2 && codec_id != CODEC_ID_AC3
2980 && codec_id != CODEC_ID_DTS) {
2981 audio_enc->channels = 2;
2983 audio_enc->channels = audio_channels;
2985 audio_enc->sample_rate = audio_sample_rate;
2986 audio_enc->time_base= (AVRational){1, audio_sample_rate};
2987 if (audio_language) {
2988 pstrcpy(st->language, sizeof(st->language), audio_language);
2989 av_free(audio_language);
2990 audio_language = NULL;
2993 /* reset some key parameters */
2995 audio_codec_id = CODEC_ID_NONE;
2996 audio_stream_copy = 0;
2999 static void opt_new_subtitle_stream(void)
3001 AVFormatContext *oc;
3003 AVCodecContext *subtitle_enc;
3006 if (nb_output_files <= 0) {
3007 fprintf(stderr, "At least one output file must be specified\n");
3010 oc = output_files[nb_output_files - 1];
3012 st = av_new_stream(oc, oc->nb_streams);
3014 fprintf(stderr, "Could not alloc stream\n");
3018 subtitle_enc = st->codec;
3019 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3020 if (subtitle_stream_copy) {
3021 st->stream_copy = 1;
3023 for(i=0; i<opt_name_count; i++){
3025 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3026 if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3027 av_set_double(subtitle_enc, opt_names[i], d);
3029 subtitle_enc->codec_id = subtitle_codec_id;
3032 if (subtitle_language) {
3033 pstrcpy(st->language, sizeof(st->language), subtitle_language);
3034 av_free(subtitle_language);
3035 subtitle_language = NULL;
3038 subtitle_codec_id = CODEC_ID_NONE;
3039 subtitle_stream_copy = 0;
3042 static void opt_new_audio_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_audio_stream(oc);
3053 static void opt_new_video_stream(void)
3055 AVFormatContext *oc;
3056 if (nb_output_files <= 0) {
3057 fprintf(stderr, "At least one output file must be specified\n");
3060 oc = output_files[nb_output_files - 1];
3061 new_video_stream(oc);
3064 static void opt_output_file(const char *filename)
3066 AVFormatContext *oc;
3067 int use_video, use_audio, input_has_video, input_has_audio, i;
3068 AVFormatParameters params, *ap = ¶ms;
3070 if (!strcmp(filename, "-"))
3073 oc = av_alloc_format_context();
3075 if (!file_oformat) {
3076 file_oformat = guess_format(NULL, filename, NULL);
3077 if (!file_oformat) {
3078 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3084 oc->oformat = file_oformat;
3085 pstrcpy(oc->filename, sizeof(oc->filename), filename);
3087 if (!strcmp(file_oformat->name, "ffm") &&
3088 strstart(filename, "http:", NULL)) {
3089 /* special case for files sent to ffserver: we get the stream
3090 parameters from ffserver */
3091 if (read_ffserver_streams(oc, filename) < 0) {
3092 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3096 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3097 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3099 /* disable if no corresponding type found and at least one
3101 if (nb_input_files > 0) {
3102 check_audio_video_inputs(&input_has_video, &input_has_audio);
3103 if (!input_has_video)
3105 if (!input_has_audio)
3109 /* manual disable */
3110 if (audio_disable) {
3113 if (video_disable) {
3118 new_video_stream(oc);
3122 new_audio_stream(oc);
3125 if (!oc->nb_streams) {
3126 fprintf(stderr, "No audio or video streams available\n");
3130 oc->timestamp = rec_timestamp;
3133 pstrcpy(oc->title, sizeof(oc->title), str_title);
3135 pstrcpy(oc->author, sizeof(oc->author), str_author);
3137 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3139 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3141 pstrcpy(oc->album, sizeof(oc->album), str_album);
3144 output_files[nb_output_files++] = oc;
3146 /* check filename in case of an image number is expected */
3147 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3148 if (!av_filename_number_test(oc->filename)) {
3149 print_error(oc->filename, AVERROR_NUMEXPECTED);
3154 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3155 /* test if it already exists to avoid loosing precious files */
3156 if (!file_overwrite &&
3157 (strchr(filename, ':') == NULL ||
3158 strstart(filename, "file:", NULL))) {
3159 if (url_exist(filename)) {
3162 if ( !using_stdin ) {
3163 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3166 if (toupper(c) != 'Y') {
3167 fprintf(stderr, "Not overwriting - exiting\n");
3172 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3179 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3180 fprintf(stderr, "Could not open '%s'\n", filename);
3185 memset(ap, 0, sizeof(*ap));
3186 ap->image_format = image_format;
3187 if (av_set_parameters(oc, ap) < 0) {
3188 fprintf(stderr, "%s: Invalid encoding parameters\n",
3193 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3194 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3195 oc->loop_output = loop_output;
3197 for(i=0; i<opt_name_count; i++){
3199 double d = av_get_double(avformat_opts, opt_names[i], &opt);
3200 if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3201 av_set_double(oc, opt_names[i], d);
3204 /* reset some options */
3205 file_oformat = NULL;
3206 file_iformat = NULL;
3207 image_format = NULL;
3210 /* prepare dummy protocols for grab */
3211 static void prepare_grab(void)
3213 int has_video, has_audio, i, j;
3214 AVFormatContext *oc;
3215 AVFormatContext *ic;
3216 AVFormatParameters vp1, *vp = &vp1;
3217 AVFormatParameters ap1, *ap = &ap1;
3219 /* see if audio/video inputs are needed */
3222 memset(ap, 0, sizeof(*ap));
3223 memset(vp, 0, sizeof(*vp));
3224 vp->time_base.num= 1;
3225 for(j=0;j<nb_output_files;j++) {
3226 oc = output_files[j];
3227 for(i=0;i<oc->nb_streams;i++) {
3228 AVCodecContext *enc = oc->streams[i]->codec;
3229 switch(enc->codec_type) {
3230 case CODEC_TYPE_AUDIO:
3231 if (enc->sample_rate > ap->sample_rate)
3232 ap->sample_rate = enc->sample_rate;
3233 if (enc->channels > ap->channels)
3234 ap->channels = enc->channels;
3237 case CODEC_TYPE_VIDEO:
3238 if (enc->width > vp->width)
3239 vp->width = enc->width;
3240 if (enc->height > vp->height)
3241 vp->height = enc->height;
3243 if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
3244 vp->time_base = enc->time_base;
3245 vp->width += frame_leftBand + frame_rightBand;
3246 vp->width -= (frame_padleft + frame_padright);
3247 vp->height += frame_topBand + frame_bottomBand;
3248 vp->height -= (frame_padtop + frame_padbottom);
3258 if (has_video == 0 && has_audio == 0) {
3259 fprintf(stderr, "Output file must have at least one audio or video stream\n");
3264 AVInputFormat *fmt1;
3265 fmt1 = av_find_input_format(video_grab_format);
3266 vp->device = video_device;
3267 vp->channel = video_channel;
3268 vp->standard = video_standard;
3269 vp->pix_fmt = frame_pix_fmt;
3270 if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3271 fprintf(stderr, "Could not find video grab device\n");
3274 /* If not enough info to get the stream parameters, we decode the
3275 first frames to get it. */
3276 if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3277 fprintf(stderr, "Could not find video grab parameters\n");
3280 /* by now video grab has one stream */
3281 ic->streams[0]->r_frame_rate.num = vp->time_base.den;
3282 ic->streams[0]->r_frame_rate.den = vp->time_base.num;
3283 input_files[nb_input_files] = ic;
3286 dump_format(ic, nb_input_files, "", 0);
3290 if (has_audio && audio_grab_format) {
3291 AVInputFormat *fmt1;
3292 fmt1 = av_find_input_format(audio_grab_format);
3293 ap->device = audio_device;
3294 if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3295 fprintf(stderr, "Could not find audio grab device\n");
3298 input_files[nb_input_files] = ic;
3301 dump_format(ic, nb_input_files, "", 0);
3307 /* same option as mencoder */
3308 static void opt_pass(const char *pass_str)
3311 pass = atoi(pass_str);
3312 if (pass != 1 && pass != 2) {
3313 fprintf(stderr, "pass number can be only 1 or 2\n");
3319 #if defined(__MINGW32__) || defined(CONFIG_OS2)
3320 static int64_t getutime(void)
3322 return av_gettime();
3325 static int64_t getutime(void)
3327 struct rusage rusage;
3329 getrusage(RUSAGE_SELF, &rusage);
3330 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3334 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3335 extern int ffm_nopts;
3338 static void show_formats(void)
3340 AVInputFormat *ifmt;
3341 AVOutputFormat *ofmt;
3342 AVImageFormat *image_fmt;
3345 const char **pp, *last_name;
3347 printf("File formats:\n");
3352 const char *name=NULL;
3353 const char *long_name=NULL;
3355 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3356 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3357 strcmp(ofmt->name, last_name)>0){
3359 long_name= ofmt->long_name;
3363 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3364 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3365 strcmp(ifmt->name, last_name)>0){
3367 long_name= ifmt->long_name;
3370 if(name && strcmp(ifmt->name, name)==0)
3382 long_name ? long_name:" ");
3386 printf("Image formats (filename extensions, if any, follow):\n");
3387 for(image_fmt = first_image_format; image_fmt != NULL;
3388 image_fmt = image_fmt->next) {
3391 image_fmt->img_read ? "D":" ",
3392 image_fmt->img_write ? "E":" ",
3394 image_fmt->extensions ? image_fmt->extensions:" ");
3398 printf("Codecs:\n");
3404 const char *type_str;
3407 for(p = first_avcodec; p != NULL; p = p->next) {
3408 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3409 strcmp(p->name, last_name)>0){
3411 decode= encode= cap=0;
3413 if(p2 && strcmp(p->name, p2->name)==0){
3414 if(p->decode) decode=1;
3415 if(p->encode) encode=1;
3416 cap |= p->capabilities;
3421 last_name= p2->name;
3424 case CODEC_TYPE_VIDEO:
3427 case CODEC_TYPE_AUDIO:
3430 case CODEC_TYPE_SUBTITLE:
3439 decode ? "D": (/*p2->decoder ? "d":*/" "),
3442 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3443 cap & CODEC_CAP_DR1 ? "D":" ",
3444 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3446 /* if(p2->decoder && decode==0)
3447 printf(" use %s for decoding", p2->decoder->name);*/
3452 printf("Supported file protocols:\n");
3453 for(up = first_protocol; up != NULL; up = up->next)
3454 printf(" %s:", up->name);
3457 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3458 printf("Motion estimation methods:\n");
3462 if ((pp - motion_str + 1) == ME_ZERO)
3463 printf("(fastest)");
3464 else if ((pp - motion_str + 1) == ME_FULL)
3465 printf("(slowest)");
3466 else if ((pp - motion_str + 1) == ME_EPZS)
3467 printf("(default)");
3472 "Note, the names of encoders and decoders dont always match, so there are\n"
3473 "several cases where the above table shows encoder only or decoder only entries\n"
3474 "even though both encoding and decoding are supported for example, the h263\n"
3475 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3480 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3483 const char *p = str;
3490 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3497 static void opt_inter_matrix(const char *arg)
3499 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3500 parse_matrix_coeffs(inter_matrix, arg);
3503 static void opt_intra_matrix(const char *arg)
3505 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3506 parse_matrix_coeffs(intra_matrix, arg);
3509 static void opt_target(const char *arg)
3512 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3514 if(!strncmp(arg, "pal-", 4)) {
3517 } else if(!strncmp(arg, "ntsc-", 5)) {
3520 } else if(!strncmp(arg, "film-", 5)) {
3525 /* Calculate FR via float to avoid int overflow */
3526 fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3529 } else if((fr == 29970) || (fr == 23976)) {
3532 /* Try to determine PAL/NTSC by peeking in the input files */
3533 if(nb_input_files) {
3535 for(j = 0; j < nb_input_files; j++) {
3536 for(i = 0; i < input_files[j]->nb_streams; i++) {
3537 AVCodecContext *c = input_files[j]->streams[i]->codec;
3538 if(c->codec_type != CODEC_TYPE_VIDEO)
3540 fr = c->time_base.den * 1000 / c->time_base.num;
3544 } else if((fr == 29970) || (fr == 23976)) {
3554 if(verbose && norm >= 0)
3555 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3559 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3560 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3561 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3565 if(!strcmp(arg, "vcd")) {
3567 opt_video_codec("mpeg1video");
3568 opt_audio_codec("mp2");
3571 opt_frame_size(norm ? "352x240" : "352x288");
3572 opt_frame_rate(frame_rates[norm]);
3573 opt_default("gop", norm ? "18" : "15");
3575 opt_default("b", "1150000");
3576 opt_default("maxrate", "1150000");
3577 opt_default("minrate", "1150000");
3578 opt_default("bufsize", "327680"); // 40*1024*8;
3580 audio_bit_rate = 224000;
3581 audio_sample_rate = 44100;
3583 opt_default("packetsize", "2324");
3584 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3586 /* We have to offset the PTS, so that it is consistent with the SCR.
3587 SCR starts at 36000, but the first two packs contain only padding
3588 and the first pack from the other stream, respectively, may also have
3589 been written before.
3590 So the real data starts at SCR 36000+3*1200. */
3591 mux_preload= (36000+3*1200) / 90000.0; //0.44
3592 } else if(!strcmp(arg, "svcd")) {
3594 opt_video_codec("mpeg2video");
3595 opt_audio_codec("mp2");
3598 opt_frame_size(norm ? "480x480" : "480x576");
3599 opt_frame_rate(frame_rates[norm]);
3600 opt_default("gop", norm ? "18" : "15");
3602 opt_default("b", "2040000");
3603 opt_default("maxrate", "2516000");
3604 opt_default("minrate", "0"); //1145000;
3605 opt_default("bufsize", "1835008"); //224*1024*8;
3606 opt_default("flags", "+SCAN_OFFSET");
3609 audio_bit_rate = 224000;
3610 audio_sample_rate = 44100;
3612 opt_default("packetsize", "2324");
3614 } else if(!strcmp(arg, "dvd")) {
3616 opt_video_codec("mpeg2video");
3617 opt_audio_codec("ac3");
3620 opt_frame_size(norm ? "720x480" : "720x576");
3621 opt_frame_rate(frame_rates[norm]);
3622 opt_default("gop", norm ? "18" : "15");
3624 opt_default("b", "6000000");
3625 opt_default("maxrate", "9000000");
3626 opt_default("minrate", "0"); //1500000;
3627 opt_default("bufsize", "1835008"); //224*1024*8;
3629 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3630 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3632 audio_bit_rate = 448000;
3633 audio_sample_rate = 48000;
3635 } else if(!strncmp(arg, "dv", 2)) {
3639 opt_frame_size(norm ? "720x480" : "720x576");
3640 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3641 (norm ? "yuv411p" : "yuv420p"));
3642 opt_frame_rate(frame_rates[norm]);
3644 audio_sample_rate = 48000;
3648 fprintf(stderr, "Unknown target: %s\n", arg);
3653 static void opt_video_bsf(const char *arg)
3655 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3656 AVBitStreamFilterContext **bsfp;
3659 fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3663 bsfp= &video_bitstream_filters;
3665 bsfp= &(*bsfp)->next;
3670 //FIXME avoid audio - video code duplication
3671 static void opt_audio_bsf(const char *arg)
3673 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3674 AVBitStreamFilterContext **bsfp;
3677 fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3681 bsfp= &audio_bitstream_filters;
3683 bsfp= &(*bsfp)->next;
3688 static void show_version(void)
3690 /* TODO: add function interface to avutil and avformat */
3691 fprintf(stderr, "ffmpeg " FFMPEG_VERSION "\n"
3695 LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3699 static int opt_default(const char *opt, const char *arg){
3700 AVOption *o= av_set_string(avctx_opts, opt, arg);
3702 o = av_set_string(avformat_opts, opt, arg);
3706 // 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));
3708 //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
3709 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
3710 opt_names[opt_name_count++]= o->name;
3712 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3713 /* disable generate of real time pts in ffm (need to be supressed anyway) */
3714 if(avctx_opts->flags & CODEC_FLAG_BITEXACT)
3718 if(avctx_opts->debug)
3719 av_log_set_level(AV_LOG_DEBUG);
3723 const OptionDef options[] = {
3725 { "L", 0, {(void*)show_license}, "show license" },
3726 { "h", 0, {(void*)show_help}, "show help" },
3727 { "version", 0, {(void*)show_version}, "show version" },
3728 { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3729 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3730 { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
3731 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3732 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3733 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3734 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3735 { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3736 { "fs", HAS_ARG | OPT_INT, {(void*)&limit_filesize}, "set the limit file size", "limit_size" }, //
3737 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3738 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3739 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3740 { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3741 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3742 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3743 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3744 { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3745 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3746 "add timings for benchmarking" },
3747 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3748 "dump each input packet" },
3749 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3750 "when dumping packets, also dump the payload" },
3751 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3752 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3753 { "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)", "" },
3754 { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3755 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3756 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3757 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3758 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3759 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3760 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3761 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3762 { "dts_delta_threshold", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
3765 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3766 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3767 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3768 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3769 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3770 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3771 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3772 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3773 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3774 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3775 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3776 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3777 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3778 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3779 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3780 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3781 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3782 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3783 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3784 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3785 { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantizer scale (VBR)", "q" },
3786 { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3787 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3788 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3789 { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
3791 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "" },
3792 { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
3793 { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3794 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3795 "use same video quality as source (implies VBR)" },
3796 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3797 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3798 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3799 "deinterlace pictures" },
3800 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3801 { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
3802 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3803 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3804 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3805 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3806 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3807 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3808 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3809 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3812 { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
3813 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3814 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3815 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3816 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3817 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3818 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3819 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3820 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3821 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3823 /* subtitle options */
3824 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3825 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3826 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3829 { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
3830 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3831 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3832 { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
3834 /* G.2 grab options */
3835 { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
3836 { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
3839 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3840 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3842 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
3843 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
3845 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3849 static void show_banner(void)
3851 fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2006 Fabrice Bellard, et al.\n");
3852 fprintf(stderr, " configuration: " FFMPEG_CONFIGURATION "\n");
3853 fprintf(stderr, " libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
3854 fprintf(stderr, " libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
3855 fprintf(stderr, " libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
3856 fprintf(stderr, " built on " __DATE__ " " __TIME__);
3858 fprintf(stderr, ", gcc: " __VERSION__ "\n");
3860 fprintf(stderr, ", using a non-gcc compiler\n");
3864 static void show_license(void)
3869 "FFmpeg is free software; you can redistribute it and/or modify\n"
3870 "it under the terms of the GNU General Public License as published by\n"
3871 "the Free Software Foundation; either version 2 of the License, or\n"
3872 "(at your option) any later version.\n"
3874 "FFmpeg is distributed in the hope that it will be useful,\n"
3875 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3876 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
3877 "GNU General Public License for more details.\n"
3879 "You should have received a copy of the GNU General Public License\n"
3880 "along with FFmpeg; if not, write to the Free Software\n"
3881 "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n"
3885 "FFmpeg is free software; you can redistribute it and/or\n"
3886 "modify it under the terms of the GNU Lesser General Public\n"
3887 "License as published by the Free Software Foundation; either\n"
3888 "version 2.1 of the License, or (at your option) any later version.\n"
3890 "FFmpeg is distributed in the hope that it will be useful,\n"
3891 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3892 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
3893 "Lesser General Public License for more details.\n"
3895 "You should have received a copy of the GNU Lesser General Public\n"
3896 "License along with FFmpeg; if not, write to the Free Software\n"
3897 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
3903 static void show_help(void)
3906 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3907 "Hyper fast Audio and Video encoder\n");
3909 show_help_options(options, "Main options:\n",
3910 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3911 show_help_options(options, "\nVideo options:\n",
3912 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3914 show_help_options(options, "\nAdvanced Video options:\n",
3915 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3916 OPT_VIDEO | OPT_EXPERT);
3917 show_help_options(options, "\nAudio options:\n",
3918 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3920 show_help_options(options, "\nAdvanced Audio options:\n",
3921 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3922 OPT_AUDIO | OPT_EXPERT);
3923 show_help_options(options, "\nSubtitle options:\n",
3924 OPT_SUBTITLE | OPT_GRAB,
3926 show_help_options(options, "\nAudio/Video grab options:\n",
3929 show_help_options(options, "\nAdvanced options:\n",
3930 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3932 av_opt_show(avctx_opts, NULL);
3933 av_opt_show(avformat_opts, NULL);
3938 void parse_arg_file(const char *filename)
3940 opt_output_file(filename);
3943 int main(int argc, char **argv)
3950 avctx_opts= avcodec_alloc_context();
3951 avformat_opts = av_alloc_format_context();
3959 parse_options(argc, argv, options);
3961 /* file converter / grab */
3962 if (nb_output_files <= 0) {
3963 fprintf(stderr, "Must supply at least one output file\n");
3967 if (nb_input_files == 0) {
3973 av_encode(output_files, nb_output_files, input_files, nb_input_files,
3974 stream_maps, nb_stream_maps);
3975 ti = getutime() - ti;
3977 printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3981 for(i=0;i<nb_output_files;i++) {
3982 /* maybe av_close_output_file ??? */
3983 AVFormatContext *s = output_files[i];
3985 if (!(s->oformat->flags & AVFMT_NOFILE))
3987 for(j=0;j<s->nb_streams;j++)
3988 av_free(s->streams[j]);
3991 for(i=0;i<nb_input_files;i++)
3992 av_close_input_file(input_files[i]);
3997 av_free(intra_matrix);
3999 av_free(inter_matrix);
4001 #ifdef POWERPC_PERFORMANCE_REPORT
4002 extern void powerpc_display_perf_report(void);
4003 powerpc_display_perf_report();
4004 #endif /* POWERPC_PERFORMANCE_REPORT */
4007 if (received_sigterm) {
4009 "Received signal %d: terminating.\n",
4010 (int) received_sigterm);
4014 exit(0); /* not all OS-es handle main() return value */