3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 #define HAVE_AV_CONFIG_H
23 #include "framehook.h"
31 #include <sys/ioctl.h>
34 #include <sys/resource.h>
38 #include <sys/types.h>
39 #include <sys/select.h>
42 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
51 #if !defined(INFINITY) && defined(HUGE_VAL)
52 #define INFINITY HUGE_VAL
55 /* select an input stream for an output stream */
56 typedef struct AVStreamMap {
60 int sync_stream_index;
63 /** select an input file for an output file */
64 typedef struct AVMetaDataMap {
69 extern const OptionDef options[];
71 static void show_help(void);
72 static void show_license(void);
73 static int opt_default(const char *opt, const char *arg);
77 static AVFormatContext *input_files[MAX_FILES];
78 static int64_t input_files_ts_offset[MAX_FILES];
79 static int nb_input_files = 0;
81 static AVFormatContext *output_files[MAX_FILES];
82 static int nb_output_files = 0;
84 static AVStreamMap stream_maps[MAX_FILES];
85 static int nb_stream_maps;
87 static AVMetaDataMap meta_data_maps[MAX_FILES];
88 static int nb_meta_data_maps;
90 static AVInputFormat *file_iformat;
91 static AVOutputFormat *file_oformat;
92 static AVImageFormat *image_format;
93 static int frame_width = 0;
94 static int frame_height = 0;
95 static float frame_aspect_ratio = 0;
96 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
97 static int frame_padtop = 0;
98 static int frame_padbottom = 0;
99 static int frame_padleft = 0;
100 static int frame_padright = 0;
101 static int padcolor[3] = {16,128,128}; /* default to black */
102 static int frame_topBand = 0;
103 static int frame_bottomBand = 0;
104 static int frame_leftBand = 0;
105 static int frame_rightBand = 0;
106 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
107 static int frame_rate = 25;
108 static int frame_rate_base = 1;
109 static float video_qscale = 0;
110 static int video_mb_lmin = 2*FF_QP2LAMBDA;
111 static int video_mb_lmax = 31*FF_QP2LAMBDA;
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_mb_lmin(const char *arg)
2327 video_mb_lmin = atof(arg)*FF_QP2LAMBDA;
2328 if (video_mb_lmin < 1 ||
2329 video_mb_lmin > FF_LAMBDA_MAX) {
2330 fprintf(stderr, "mblmin must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2335 static void opt_mb_lmax(const char *arg)
2337 video_mb_lmax = atof(arg)*FF_QP2LAMBDA;
2338 if (video_mb_lmax < 1 ||
2339 video_mb_lmax > FF_LAMBDA_MAX) {
2340 fprintf(stderr, "mblmax must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2345 static void opt_qdiff(const char *arg)
2347 video_qdiff = atoi(arg);
2348 if (video_qdiff < 0 ||
2350 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2355 static void opt_packet_size(const char *arg)
2357 packet_size= atoi(arg);
2360 static void opt_strict(const char *arg)
2365 static void opt_top_field_first(const char *arg)
2367 top_field_first= atoi(arg);
2370 static void opt_thread_count(const char *arg)
2372 thread_count= atoi(arg);
2373 #if !defined(HAVE_THREADS)
2375 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2379 static void opt_audio_bitrate(const char *arg)
2381 audio_bit_rate = atoi(arg) * 1000;
2384 static void opt_audio_rate(const char *arg)
2386 audio_sample_rate = atoi(arg);
2389 static void opt_audio_channels(const char *arg)
2391 audio_channels = atoi(arg);
2394 static void opt_video_device(const char *arg)
2396 video_device = av_strdup(arg);
2399 static void opt_grab_device(const char *arg)
2401 grab_device = av_strdup(arg);
2404 static void opt_video_channel(const char *arg)
2406 video_channel = strtol(arg, NULL, 0);
2409 static void opt_video_standard(const char *arg)
2411 video_standard = av_strdup(arg);
2414 static void opt_audio_device(const char *arg)
2416 audio_device = av_strdup(arg);
2419 static void opt_codec(int *pstream_copy, int *pcodec_id,
2420 int codec_type, const char *arg)
2424 if (!strcmp(arg, "copy")) {
2429 if (!strcmp(p->name, arg) && p->type == codec_type)
2434 fprintf(stderr, "Unknown codec '%s'\n", arg);
2442 static void opt_audio_codec(const char *arg)
2444 opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2447 static void opt_audio_tag(const char *arg)
2450 audio_codec_tag= strtol(arg, &tail, 0);
2453 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2456 static void opt_video_tag(const char *arg)
2459 video_codec_tag= strtol(arg, &tail, 0);
2462 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2465 static void add_frame_hooker(const char *arg)
2470 char *args = av_strdup(arg);
2474 argv[0] = strtok(args, " ");
2475 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2478 i = frame_hook_add(argc, argv);
2481 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2486 const char *motion_str[] = {
2499 static void opt_motion_estimation(const char *arg)
2505 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2508 if (!strcmp(*p, arg))
2512 me_method = (p - motion_str) + 1;
2515 static void opt_video_codec(const char *arg)
2517 opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2520 static void opt_subtitle_codec(const char *arg)
2522 opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2525 static void opt_map(const char *arg)
2531 m = &stream_maps[nb_stream_maps++];
2533 m->file_index = strtol(arg, (char **)&p, 0);
2537 m->stream_index = strtol(p, (char **)&p, 0);
2540 m->sync_file_index = strtol(p, (char **)&p, 0);
2543 m->sync_stream_index = strtol(p, (char **)&p, 0);
2545 m->sync_file_index = m->file_index;
2546 m->sync_stream_index = m->stream_index;
2550 static void opt_map_meta_data(const char *arg)
2556 m = &meta_data_maps[nb_meta_data_maps++];
2558 m->out_file = strtol(arg, (char **)&p, 0);
2562 m->in_file = strtol(p, (char **)&p, 0);
2565 static void opt_recording_time(const char *arg)
2567 recording_time = parse_date(arg, 1);
2570 static void opt_start_time(const char *arg)
2572 start_time = parse_date(arg, 1);
2575 static void opt_rec_timestamp(const char *arg)
2577 rec_timestamp = parse_date(arg, 0) / 1000000;
2580 static void opt_input_ts_offset(const char *arg)
2582 input_ts_offset = parse_date(arg, 1);
2585 static void opt_input_file(const char *filename)
2587 AVFormatContext *ic;
2588 AVFormatParameters params, *ap = ¶ms;
2589 int err, i, ret, rfps, rfps_base;
2592 if (!strcmp(filename, "-"))
2595 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2596 !strcmp( filename, "/dev/stdin" );
2598 /* get default parameters from command line */
2599 ic = av_alloc_format_context();
2601 memset(ap, 0, sizeof(*ap));
2602 ap->prealloced_context = 1;
2603 ap->sample_rate = audio_sample_rate;
2604 ap->channels = audio_channels;
2605 ap->time_base.den = frame_rate;
2606 ap->time_base.num = frame_rate_base;
2607 ap->width = frame_width + frame_padleft + frame_padright;
2608 ap->height = frame_height + frame_padtop + frame_padbottom;
2609 ap->image_format = image_format;
2610 ap->pix_fmt = frame_pix_fmt;
2611 ap->device = grab_device;
2612 ap->channel = video_channel;
2613 ap->standard = video_standard;
2614 ap->video_codec_id = video_codec_id;
2615 ap->audio_codec_id = audio_codec_id;
2616 if(pgmyuv_compatibility_hack)
2617 ap->video_codec_id= CODEC_ID_PGMYUV;
2619 for(i=0; i<opt_name_count; i++){
2621 double d= av_get_double(avformat_opts, opt_names[i], &opt);
2622 if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2623 av_set_double(ic, opt_names[i], d);
2625 /* open the input file with generic libav function */
2626 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2628 print_error(filename, err);
2632 ic->loop_input = loop_input;
2634 /* If not enough info to get the stream parameters, we decode the
2635 first frames to get it. (used in mpeg case for example) */
2636 ret = av_find_stream_info(ic);
2637 if (ret < 0 && verbose >= 0) {
2638 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2642 timestamp = start_time;
2643 /* add the stream start time */
2644 if (ic->start_time != AV_NOPTS_VALUE)
2645 timestamp += ic->start_time;
2647 /* if seeking requested, we execute it */
2648 if (start_time != 0) {
2649 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2651 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2652 filename, (double)timestamp / AV_TIME_BASE);
2654 /* reset seek info */
2658 /* update the current parameters so that they match the one of the input stream */
2659 for(i=0;i<ic->nb_streams;i++) {
2661 AVCodecContext *enc = ic->streams[i]->codec;
2662 #if defined(HAVE_THREADS)
2664 avcodec_thread_init(enc, thread_count);
2666 enc->thread_count= thread_count;
2667 switch(enc->codec_type) {
2668 case CODEC_TYPE_AUDIO:
2669 for(j=0; j<opt_name_count; j++){
2671 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2672 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2673 av_set_double(enc, opt_names[j], d);
2675 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2676 audio_channels = enc->channels;
2677 audio_sample_rate = enc->sample_rate;
2679 ic->streams[i]->discard= AVDISCARD_ALL;
2681 case CODEC_TYPE_VIDEO:
2682 for(j=0; j<opt_name_count; j++){
2684 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2685 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2686 av_set_double(enc, opt_names[j], d);
2688 frame_height = enc->height;
2689 frame_width = enc->width;
2690 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2691 frame_pix_fmt = enc->pix_fmt;
2692 rfps = ic->streams[i]->r_frame_rate.num;
2693 rfps_base = ic->streams[i]->r_frame_rate.den;
2694 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2696 enc->debug |= FF_DEBUG_MV;
2698 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2701 fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2702 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2704 (float)rfps / rfps_base, rfps, rfps_base);
2706 /* update the current frame rate to match the stream frame rate */
2708 frame_rate_base = rfps_base;
2710 enc->rate_emu = rate_emu;
2712 ic->streams[i]->discard= AVDISCARD_ALL;
2713 else if(video_discard)
2714 ic->streams[i]->discard= video_discard;
2716 case CODEC_TYPE_DATA:
2718 case CODEC_TYPE_SUBTITLE:
2720 case CODEC_TYPE_UNKNOWN:
2727 input_files[nb_input_files] = ic;
2728 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2729 /* dump the file content */
2731 dump_format(ic, nb_input_files, filename, 0);
2734 file_iformat = NULL;
2735 file_oformat = NULL;
2736 image_format = NULL;
2744 static void opt_grab(const char *arg)
2746 file_iformat = av_find_input_format(arg);
2750 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2752 int has_video, has_audio, i, j;
2753 AVFormatContext *ic;
2757 for(j=0;j<nb_input_files;j++) {
2758 ic = input_files[j];
2759 for(i=0;i<ic->nb_streams;i++) {
2760 AVCodecContext *enc = ic->streams[i]->codec;
2761 switch(enc->codec_type) {
2762 case CODEC_TYPE_AUDIO:
2765 case CODEC_TYPE_VIDEO:
2768 case CODEC_TYPE_DATA:
2769 case CODEC_TYPE_UNKNOWN:
2770 case CODEC_TYPE_SUBTITLE:
2777 *has_video_ptr = has_video;
2778 *has_audio_ptr = has_audio;
2781 static void new_video_stream(AVFormatContext *oc)
2784 AVCodecContext *video_enc;
2787 st = av_new_stream(oc, oc->nb_streams);
2789 fprintf(stderr, "Could not alloc stream\n");
2792 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2793 video_bitstream_filters= NULL;
2795 #if defined(HAVE_THREADS)
2797 avcodec_thread_init(st->codec, thread_count);
2800 video_enc = st->codec;
2803 video_enc->codec_tag= video_codec_tag;
2805 if( (video_global_header&1)
2806 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2807 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2808 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2810 if(video_global_header&2){
2811 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2812 avctx_opts->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2815 if (video_stream_copy) {
2816 st->stream_copy = 1;
2817 video_enc->codec_type = CODEC_TYPE_VIDEO;
2823 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2824 if (video_codec_id != CODEC_ID_NONE)
2825 codec_id = video_codec_id;
2827 video_enc->codec_id = codec_id;
2828 codec = avcodec_find_encoder(codec_id);
2830 for(i=0; i<opt_name_count; i++){
2832 double d= av_get_double(avctx_opts, opt_names[i], &opt);
2833 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2834 av_set_double(video_enc, opt_names[i], d);
2837 video_enc->time_base.den = frame_rate;
2838 video_enc->time_base.num = frame_rate_base;
2839 if(codec && codec->supported_framerates){
2840 const AVRational *p= codec->supported_framerates;
2841 AVRational req= (AVRational){frame_rate, frame_rate_base};
2842 const AVRational *best=NULL;
2843 AVRational best_error= (AVRational){INT_MAX, 1};
2844 for(; p->den!=0; p++){
2845 AVRational error= av_sub_q(req, *p);
2846 if(error.num <0) error.num *= -1;
2847 if(av_cmp_q(error, best_error) < 0){
2852 video_enc->time_base.den= best->num;
2853 video_enc->time_base.num= best->den;
2856 video_enc->width = frame_width + frame_padright + frame_padleft;
2857 video_enc->height = frame_height + frame_padtop + frame_padbottom;
2858 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2859 video_enc->pix_fmt = frame_pix_fmt;
2861 if(codec && codec->pix_fmts){
2862 const enum PixelFormat *p= codec->pix_fmts;
2864 if(*p == video_enc->pix_fmt)
2868 video_enc->pix_fmt = codec->pix_fmts[0];
2872 video_enc->gop_size = 0;
2873 if (video_qscale || same_quality) {
2874 video_enc->flags |= CODEC_FLAG_QSCALE;
2875 video_enc->global_quality=
2876 st->quality = FF_QP2LAMBDA * video_qscale;
2880 video_enc->intra_matrix = intra_matrix;
2882 video_enc->inter_matrix = inter_matrix;
2884 video_enc->mb_lmin = video_mb_lmin;
2885 video_enc->mb_lmax = video_mb_lmax;
2886 video_enc->max_qdiff = video_qdiff;
2887 video_enc->rc_eq = video_rc_eq;
2888 video_enc->thread_count = thread_count;
2889 p= video_rc_override_string;
2892 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2894 fprintf(stderr, "error parsing rc_override\n");
2897 video_enc->rc_override=
2898 av_realloc(video_enc->rc_override,
2899 sizeof(RcOverride)*(i+1));
2900 video_enc->rc_override[i].start_frame= start;
2901 video_enc->rc_override[i].end_frame = end;
2903 video_enc->rc_override[i].qscale= q;
2904 video_enc->rc_override[i].quality_factor= 1.0;
2907 video_enc->rc_override[i].qscale= 0;
2908 video_enc->rc_override[i].quality_factor= -q/100.0;
2913 video_enc->rc_override_count=i;
2914 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2915 video_enc->me_threshold= me_threshold;
2916 video_enc->intra_dc_precision= intra_dc_precision - 8;
2917 video_enc->strict_std_compliance = strict;
2920 video_enc->rtp_mode= 1;
2921 video_enc->rtp_payload_size= packet_size;
2925 video_enc->flags|= CODEC_FLAG_PSNR;
2927 video_enc->me_method = me_method;
2932 video_enc->flags |= CODEC_FLAG_PASS1;
2934 video_enc->flags |= CODEC_FLAG_PASS2;
2939 /* reset some key parameters */
2941 video_codec_id = CODEC_ID_NONE;
2942 video_stream_copy = 0;
2945 static void new_audio_stream(AVFormatContext *oc)
2948 AVCodecContext *audio_enc;
2951 st = av_new_stream(oc, oc->nb_streams);
2953 fprintf(stderr, "Could not alloc stream\n");
2957 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2958 audio_bitstream_filters= NULL;
2960 #if defined(HAVE_THREADS)
2962 avcodec_thread_init(st->codec, thread_count);
2965 audio_enc = st->codec;
2966 audio_enc->codec_type = CODEC_TYPE_AUDIO;
2969 audio_enc->codec_tag= audio_codec_tag;
2971 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
2972 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2973 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2975 if (audio_stream_copy) {
2976 st->stream_copy = 1;
2977 audio_enc->channels = audio_channels;
2979 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
2981 for(i=0; i<opt_name_count; i++){
2983 double d= av_get_double(avctx_opts, opt_names[i], &opt);
2984 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2985 av_set_double(audio_enc, opt_names[i], d);
2988 if (audio_codec_id != CODEC_ID_NONE)
2989 codec_id = audio_codec_id;
2990 audio_enc->codec_id = codec_id;
2992 audio_enc->bit_rate = audio_bit_rate;
2993 if (audio_qscale > QSCALE_NONE) {
2994 audio_enc->flags |= CODEC_FLAG_QSCALE;
2995 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
2997 audio_enc->strict_std_compliance = strict;
2998 audio_enc->thread_count = thread_count;
2999 /* For audio codecs other than AC3 or DTS we limit */
3000 /* the number of coded channels to stereo */
3001 if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3002 && codec_id != CODEC_ID_DTS) {
3003 audio_enc->channels = 2;
3005 audio_enc->channels = audio_channels;
3007 audio_enc->sample_rate = audio_sample_rate;
3008 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3009 if (audio_language) {
3010 pstrcpy(st->language, sizeof(st->language), audio_language);
3011 av_free(audio_language);
3012 audio_language = NULL;
3015 /* reset some key parameters */
3017 audio_codec_id = CODEC_ID_NONE;
3018 audio_stream_copy = 0;
3021 static void opt_new_subtitle_stream(void)
3023 AVFormatContext *oc;
3025 AVCodecContext *subtitle_enc;
3028 if (nb_output_files <= 0) {
3029 fprintf(stderr, "At least one output file must be specified\n");
3032 oc = output_files[nb_output_files - 1];
3034 st = av_new_stream(oc, oc->nb_streams);
3036 fprintf(stderr, "Could not alloc stream\n");
3040 subtitle_enc = st->codec;
3041 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3042 if (subtitle_stream_copy) {
3043 st->stream_copy = 1;
3045 for(i=0; i<opt_name_count; i++){
3047 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3048 if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3049 av_set_double(subtitle_enc, opt_names[i], d);
3051 subtitle_enc->codec_id = subtitle_codec_id;
3054 if (subtitle_language) {
3055 pstrcpy(st->language, sizeof(st->language), subtitle_language);
3056 av_free(subtitle_language);
3057 subtitle_language = NULL;
3060 subtitle_codec_id = CODEC_ID_NONE;
3061 subtitle_stream_copy = 0;
3064 static void opt_new_audio_stream(void)
3066 AVFormatContext *oc;
3067 if (nb_output_files <= 0) {
3068 fprintf(stderr, "At least one output file must be specified\n");
3071 oc = output_files[nb_output_files - 1];
3072 new_audio_stream(oc);
3075 static void opt_new_video_stream(void)
3077 AVFormatContext *oc;
3078 if (nb_output_files <= 0) {
3079 fprintf(stderr, "At least one output file must be specified\n");
3082 oc = output_files[nb_output_files - 1];
3083 new_video_stream(oc);
3086 static void opt_output_file(const char *filename)
3088 AVFormatContext *oc;
3089 int use_video, use_audio, input_has_video, input_has_audio, i;
3090 AVFormatParameters params, *ap = ¶ms;
3092 if (!strcmp(filename, "-"))
3095 oc = av_alloc_format_context();
3097 if (!file_oformat) {
3098 file_oformat = guess_format(NULL, filename, NULL);
3099 if (!file_oformat) {
3100 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3106 oc->oformat = file_oformat;
3107 pstrcpy(oc->filename, sizeof(oc->filename), filename);
3109 if (!strcmp(file_oformat->name, "ffm") &&
3110 strstart(filename, "http:", NULL)) {
3111 /* special case for files sent to ffserver: we get the stream
3112 parameters from ffserver */
3113 if (read_ffserver_streams(oc, filename) < 0) {
3114 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3118 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3119 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3121 /* disable if no corresponding type found and at least one
3123 if (nb_input_files > 0) {
3124 check_audio_video_inputs(&input_has_video, &input_has_audio);
3125 if (!input_has_video)
3127 if (!input_has_audio)
3131 /* manual disable */
3132 if (audio_disable) {
3135 if (video_disable) {
3140 new_video_stream(oc);
3144 new_audio_stream(oc);
3147 if (!oc->nb_streams) {
3148 fprintf(stderr, "No audio or video streams available\n");
3152 oc->timestamp = rec_timestamp;
3155 pstrcpy(oc->title, sizeof(oc->title), str_title);
3157 pstrcpy(oc->author, sizeof(oc->author), str_author);
3159 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3161 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3163 pstrcpy(oc->album, sizeof(oc->album), str_album);
3166 output_files[nb_output_files++] = oc;
3168 /* check filename in case of an image number is expected */
3169 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3170 if (!av_filename_number_test(oc->filename)) {
3171 print_error(oc->filename, AVERROR_NUMEXPECTED);
3176 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3177 /* test if it already exists to avoid loosing precious files */
3178 if (!file_overwrite &&
3179 (strchr(filename, ':') == NULL ||
3180 strstart(filename, "file:", NULL))) {
3181 if (url_exist(filename)) {
3184 if ( !using_stdin ) {
3185 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3188 if (toupper(c) != 'Y') {
3189 fprintf(stderr, "Not overwriting - exiting\n");
3194 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3201 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3202 fprintf(stderr, "Could not open '%s'\n", filename);
3207 memset(ap, 0, sizeof(*ap));
3208 ap->image_format = image_format;
3209 if (av_set_parameters(oc, ap) < 0) {
3210 fprintf(stderr, "%s: Invalid encoding parameters\n",
3215 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3216 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3217 oc->loop_output = loop_output;
3219 for(i=0; i<opt_name_count; i++){
3221 double d = av_get_double(avformat_opts, opt_names[i], &opt);
3222 if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3223 av_set_double(oc, opt_names[i], d);
3226 /* reset some options */
3227 file_oformat = NULL;
3228 file_iformat = NULL;
3229 image_format = NULL;
3232 /* prepare dummy protocols for grab */
3233 static void prepare_grab(void)
3235 int has_video, has_audio, i, j;
3236 AVFormatContext *oc;
3237 AVFormatContext *ic;
3238 AVFormatParameters vp1, *vp = &vp1;
3239 AVFormatParameters ap1, *ap = &ap1;
3241 /* see if audio/video inputs are needed */
3244 memset(ap, 0, sizeof(*ap));
3245 memset(vp, 0, sizeof(*vp));
3246 vp->time_base.num= 1;
3247 for(j=0;j<nb_output_files;j++) {
3248 oc = output_files[j];
3249 for(i=0;i<oc->nb_streams;i++) {
3250 AVCodecContext *enc = oc->streams[i]->codec;
3251 switch(enc->codec_type) {
3252 case CODEC_TYPE_AUDIO:
3253 if (enc->sample_rate > ap->sample_rate)
3254 ap->sample_rate = enc->sample_rate;
3255 if (enc->channels > ap->channels)
3256 ap->channels = enc->channels;
3259 case CODEC_TYPE_VIDEO:
3260 if (enc->width > vp->width)
3261 vp->width = enc->width;
3262 if (enc->height > vp->height)
3263 vp->height = enc->height;
3265 if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
3266 vp->time_base = enc->time_base;
3267 vp->width += frame_leftBand + frame_rightBand;
3268 vp->width -= (frame_padleft + frame_padright);
3269 vp->height += frame_topBand + frame_bottomBand;
3270 vp->height -= (frame_padtop + frame_padbottom);
3280 if (has_video == 0 && has_audio == 0) {
3281 fprintf(stderr, "Output file must have at least one audio or video stream\n");
3286 AVInputFormat *fmt1;
3287 fmt1 = av_find_input_format(video_grab_format);
3288 vp->device = video_device;
3289 vp->channel = video_channel;
3290 vp->standard = video_standard;
3291 vp->pix_fmt = frame_pix_fmt;
3292 if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3293 fprintf(stderr, "Could not find video grab device\n");
3296 /* If not enough info to get the stream parameters, we decode the
3297 first frames to get it. */
3298 if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3299 fprintf(stderr, "Could not find video grab parameters\n");
3302 /* by now video grab has one stream */
3303 ic->streams[0]->r_frame_rate.num = vp->time_base.den;
3304 ic->streams[0]->r_frame_rate.den = vp->time_base.num;
3305 input_files[nb_input_files] = ic;
3308 dump_format(ic, nb_input_files, "", 0);
3312 if (has_audio && audio_grab_format) {
3313 AVInputFormat *fmt1;
3314 fmt1 = av_find_input_format(audio_grab_format);
3315 ap->device = audio_device;
3316 if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3317 fprintf(stderr, "Could not find audio grab device\n");
3320 input_files[nb_input_files] = ic;
3323 dump_format(ic, nb_input_files, "", 0);
3329 /* same option as mencoder */
3330 static void opt_pass(const char *pass_str)
3333 pass = atoi(pass_str);
3334 if (pass != 1 && pass != 2) {
3335 fprintf(stderr, "pass number can be only 1 or 2\n");
3341 #if defined(__MINGW32__) || defined(CONFIG_OS2)
3342 static int64_t getutime(void)
3344 return av_gettime();
3347 static int64_t getutime(void)
3349 struct rusage rusage;
3351 getrusage(RUSAGE_SELF, &rusage);
3352 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3356 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3357 extern int ffm_nopts;
3360 static void show_formats(void)
3362 AVInputFormat *ifmt;
3363 AVOutputFormat *ofmt;
3364 AVImageFormat *image_fmt;
3367 const char **pp, *last_name;
3369 printf("File formats:\n");
3374 const char *name=NULL;
3375 const char *long_name=NULL;
3377 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3378 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3379 strcmp(ofmt->name, last_name)>0){
3381 long_name= ofmt->long_name;
3385 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3386 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3387 strcmp(ifmt->name, last_name)>0){
3389 long_name= ifmt->long_name;
3392 if(name && strcmp(ifmt->name, name)==0)
3404 long_name ? long_name:" ");
3408 printf("Image formats (filename extensions, if any, follow):\n");
3409 for(image_fmt = first_image_format; image_fmt != NULL;
3410 image_fmt = image_fmt->next) {
3413 image_fmt->img_read ? "D":" ",
3414 image_fmt->img_write ? "E":" ",
3416 image_fmt->extensions ? image_fmt->extensions:" ");
3420 printf("Codecs:\n");
3426 const char *type_str;
3429 for(p = first_avcodec; p != NULL; p = p->next) {
3430 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3431 strcmp(p->name, last_name)>0){
3433 decode= encode= cap=0;
3435 if(p2 && strcmp(p->name, p2->name)==0){
3436 if(p->decode) decode=1;
3437 if(p->encode) encode=1;
3438 cap |= p->capabilities;
3443 last_name= p2->name;
3446 case CODEC_TYPE_VIDEO:
3449 case CODEC_TYPE_AUDIO:
3452 case CODEC_TYPE_SUBTITLE:
3461 decode ? "D": (/*p2->decoder ? "d":*/" "),
3464 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3465 cap & CODEC_CAP_DR1 ? "D":" ",
3466 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3468 /* if(p2->decoder && decode==0)
3469 printf(" use %s for decoding", p2->decoder->name);*/
3474 printf("Supported file protocols:\n");
3475 for(up = first_protocol; up != NULL; up = up->next)
3476 printf(" %s:", up->name);
3479 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3480 printf("Motion estimation methods:\n");
3484 if ((pp - motion_str + 1) == ME_ZERO)
3485 printf("(fastest)");
3486 else if ((pp - motion_str + 1) == ME_FULL)
3487 printf("(slowest)");
3488 else if ((pp - motion_str + 1) == ME_EPZS)
3489 printf("(default)");
3494 "Note, the names of encoders and decoders dont always match, so there are\n"
3495 "several cases where the above table shows encoder only or decoder only entries\n"
3496 "even though both encoding and decoding are supported for example, the h263\n"
3497 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3502 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3505 const char *p = str;
3512 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3519 static void opt_inter_matrix(const char *arg)
3521 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3522 parse_matrix_coeffs(inter_matrix, arg);
3525 static void opt_intra_matrix(const char *arg)
3527 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3528 parse_matrix_coeffs(intra_matrix, arg);
3531 static void opt_target(const char *arg)
3534 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3536 if(!strncmp(arg, "pal-", 4)) {
3539 } else if(!strncmp(arg, "ntsc-", 5)) {
3542 } else if(!strncmp(arg, "film-", 5)) {
3547 /* Calculate FR via float to avoid int overflow */
3548 fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3551 } else if((fr == 29970) || (fr == 23976)) {
3554 /* Try to determine PAL/NTSC by peeking in the input files */
3555 if(nb_input_files) {
3557 for(j = 0; j < nb_input_files; j++) {
3558 for(i = 0; i < input_files[j]->nb_streams; i++) {
3559 AVCodecContext *c = input_files[j]->streams[i]->codec;
3560 if(c->codec_type != CODEC_TYPE_VIDEO)
3562 fr = c->time_base.den * 1000 / c->time_base.num;
3566 } else if((fr == 29970) || (fr == 23976)) {
3576 if(verbose && norm >= 0)
3577 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3581 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3582 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3583 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3587 if(!strcmp(arg, "vcd")) {
3589 opt_video_codec("mpeg1video");
3590 opt_audio_codec("mp2");
3593 opt_frame_size(norm ? "352x240" : "352x288");
3594 opt_frame_rate(frame_rates[norm]);
3595 opt_default("gop", norm ? "18" : "15");
3597 opt_default("b", "1150000");
3598 opt_default("maxrate", "1150000");
3599 opt_default("minrate", "1150000");
3600 opt_default("bufsize", "327680"); // 40*1024*8;
3602 audio_bit_rate = 224000;
3603 audio_sample_rate = 44100;
3605 opt_default("packetsize", "2324");
3606 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3608 /* We have to offset the PTS, so that it is consistent with the SCR.
3609 SCR starts at 36000, but the first two packs contain only padding
3610 and the first pack from the other stream, respectively, may also have
3611 been written before.
3612 So the real data starts at SCR 36000+3*1200. */
3613 mux_preload= (36000+3*1200) / 90000.0; //0.44
3614 } else if(!strcmp(arg, "svcd")) {
3616 opt_video_codec("mpeg2video");
3617 opt_audio_codec("mp2");
3620 opt_frame_size(norm ? "480x480" : "480x576");
3621 opt_frame_rate(frame_rates[norm]);
3622 opt_default("gop", norm ? "18" : "15");
3624 opt_default("b", "2040000");
3625 opt_default("maxrate", "2516000");
3626 opt_default("minrate", "0"); //1145000;
3627 opt_default("bufsize", "1835008"); //224*1024*8;
3628 opt_default("flags", "+SCAN_OFFSET");
3631 audio_bit_rate = 224000;
3632 audio_sample_rate = 44100;
3634 opt_default("packetsize", "2324");
3636 } else if(!strcmp(arg, "dvd")) {
3638 opt_video_codec("mpeg2video");
3639 opt_audio_codec("ac3");
3642 opt_frame_size(norm ? "720x480" : "720x576");
3643 opt_frame_rate(frame_rates[norm]);
3644 opt_default("gop", norm ? "18" : "15");
3646 opt_default("b", "6000000");
3647 opt_default("maxrate", "9000000");
3648 opt_default("minrate", "0"); //1500000;
3649 opt_default("bufsize", "1835008"); //224*1024*8;
3651 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3652 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3654 audio_bit_rate = 448000;
3655 audio_sample_rate = 48000;
3657 } else if(!strncmp(arg, "dv", 2)) {
3661 opt_frame_size(norm ? "720x480" : "720x576");
3662 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3663 (norm ? "yuv411p" : "yuv420p"));
3664 opt_frame_rate(frame_rates[norm]);
3666 audio_sample_rate = 48000;
3670 fprintf(stderr, "Unknown target: %s\n", arg);
3675 static void opt_video_bsf(const char *arg)
3677 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3678 AVBitStreamFilterContext **bsfp;
3681 fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3685 bsfp= &video_bitstream_filters;
3687 bsfp= &(*bsfp)->next;
3692 //FIXME avoid audio - video code duplication
3693 static void opt_audio_bsf(const char *arg)
3695 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3696 AVBitStreamFilterContext **bsfp;
3699 fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3703 bsfp= &audio_bitstream_filters;
3705 bsfp= &(*bsfp)->next;
3710 static void show_version(void)
3712 /* TODO: add function interface to avutil and avformat */
3713 fprintf(stderr, "ffmpeg " FFMPEG_VERSION "\n"
3717 LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3721 static int opt_default(const char *opt, const char *arg){
3722 AVOption *o= av_set_string(avctx_opts, opt, arg);
3724 o = av_set_string(avformat_opts, opt, arg);
3728 // 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));