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
33 #include "framehook.h"
37 #include "os_support.h"
39 #if !defined(HAVE_GETRUSAGE) && defined(HAVE_GETPROCESSTIMES)
43 #if defined(HAVE_TERMIOS_H)
46 #include <sys/ioctl.h>
49 #include <sys/resource.h>
50 #elif defined(HAVE_CONIO_H)
53 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
62 #if !defined(INFINITY) && defined(HUGE_VAL)
63 #define INFINITY HUGE_VAL
68 static const char program_name[] = "FFmpeg";
69 static const int program_birth_year = 2000;
71 /* select an input stream for an output stream */
72 typedef struct AVStreamMap {
76 int sync_stream_index;
79 /** select an input file for an output file */
80 typedef struct AVMetaDataMap {
85 extern const OptionDef options[];
89 static AVFormatContext *input_files[MAX_FILES];
90 static int64_t input_files_ts_offset[MAX_FILES];
91 static int nb_input_files = 0;
93 static AVFormatContext *output_files[MAX_FILES];
94 static int nb_output_files = 0;
96 static AVStreamMap stream_maps[MAX_FILES];
97 static int nb_stream_maps;
99 static AVMetaDataMap meta_data_maps[MAX_FILES];
100 static int nb_meta_data_maps;
102 static AVInputFormat *file_iformat;
103 static AVOutputFormat *file_oformat;
104 static int frame_width = 0;
105 static int frame_height = 0;
106 static float frame_aspect_ratio = 0;
107 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
108 static int frame_padtop = 0;
109 static int frame_padbottom = 0;
110 static int frame_padleft = 0;
111 static int frame_padright = 0;
112 static int padcolor[3] = {16,128,128}; /* default to black */
113 static int frame_topBand = 0;
114 static int frame_bottomBand = 0;
115 static int frame_leftBand = 0;
116 static int frame_rightBand = 0;
117 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
118 static AVRational frame_rate = (AVRational) {25,1};
119 static float video_qscale = 0;
120 static int video_qdiff = 3;
121 static uint16_t *intra_matrix = NULL;
122 static uint16_t *inter_matrix = NULL;
123 #if 0 //experimental, (can be removed)
124 static float video_rc_qsquish=1.0;
125 static float video_rc_qmod_amp=0;
126 static int video_rc_qmod_freq=0;
128 static char *video_rc_override_string=NULL;
129 static char *video_rc_eq="tex^qComp";
130 static int video_disable = 0;
131 static int video_discard = 0;
132 static char *video_codec_name = NULL;
133 static int video_codec_tag = 0;
134 static int same_quality = 0;
135 static int do_deinterlace = 0;
136 static int strict = 0;
137 static int top_field_first = -1;
138 static int me_threshold = 0;
139 static int intra_dc_precision = 8;
140 static int loop_input = 0;
141 static int loop_output = AVFMT_NOOUTPUTLOOP;
142 static int qp_hist = 0;
144 static int intra_only = 0;
145 static int audio_sample_rate = 44100;
146 #define QSCALE_NONE -99999
147 static float audio_qscale = QSCALE_NONE;
148 static int audio_disable = 0;
149 static int audio_channels = 1;
150 static char *audio_codec_name = NULL;
151 static int audio_codec_tag = 0;
152 static char *audio_language = NULL;
154 static int subtitle_disable = 0;
155 static char *subtitle_codec_name = NULL;
156 static char *subtitle_language = NULL;
158 static float mux_preload= 0.5;
159 static float mux_max_delay= 0.7;
161 static int64_t recording_time = 0;
162 static int64_t start_time = 0;
163 static int64_t rec_timestamp = 0;
164 static int64_t input_ts_offset = 0;
165 static int file_overwrite = 0;
166 static char *str_title = NULL;
167 static char *str_author = NULL;
168 static char *str_copyright = NULL;
169 static char *str_comment = NULL;
170 static char *str_album = NULL;
171 static int do_benchmark = 0;
172 static int do_hex_dump = 0;
173 static int do_pkt_dump = 0;
174 static int do_psnr = 0;
175 static int do_pass = 0;
176 static char *pass_logfilename = NULL;
177 static int audio_stream_copy = 0;
178 static int video_stream_copy = 0;
179 static int subtitle_stream_copy = 0;
180 static int video_sync_method= 1;
181 static int audio_sync_method= 0;
182 static float audio_drift_threshold= 0.1;
183 static int copy_ts= 0;
184 static int opt_shortest = 0; //
185 static int video_global_header = 0;
186 static char *vstats_filename;
187 static FILE *vstats_file;
188 static int opt_programid = 0;
190 static int rate_emu = 0;
192 static int video_channel = 0;
193 static char *video_standard;
195 static int audio_volume = 256;
197 static int using_stdin = 0;
198 static int using_vhook = 0;
199 static int verbose = 1;
200 static int thread_count= 1;
201 static int q_pressed = 0;
202 static int64_t video_size = 0;
203 static int64_t audio_size = 0;
204 static int64_t extra_size = 0;
205 static int nb_frames_dup = 0;
206 static int nb_frames_drop = 0;
207 static int input_sync;
208 static uint64_t limit_filesize = 0; //
210 static int pgmyuv_compatibility_hack=0;
211 static float dts_delta_threshold = 10;
213 static int sws_flags = SWS_BICUBIC;
215 static const char **opt_names;
216 static int opt_name_count;
217 static AVCodecContext *avctx_opts[CODEC_TYPE_NB];
218 static AVFormatContext *avformat_opts;
219 static struct SwsContext *sws_opts;
220 static int64_t timer_start;
222 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
223 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
224 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
226 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
228 struct AVInputStream;
230 typedef struct AVOutputStream {
231 int file_index; /* file index */
232 int index; /* stream index in the output file */
233 int source_index; /* AVInputStream index */
234 AVStream *st; /* stream in the output file */
235 int encoding_needed; /* true if encoding needed for this stream */
237 /* input pts and corresponding output pts
239 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
240 struct AVInputStream *sync_ist; /* input stream to sync against */
241 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
244 AVFrame pict_tmp; /* temporary image for resampling */
245 struct SwsContext *img_resample_ctx; /* for image resampling */
249 int topBand; /* cropping area sizes */
253 int padtop; /* padding area sizes */
260 ReSampleContext *resample; /* for audio resampling */
261 AVFifoBuffer fifo; /* for compression: one audio fifo per codec */
265 typedef struct AVInputStream {
269 int discard; /* true if stream data should be discarded */
270 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
271 int64_t sample_index; /* current sample */
273 int64_t start; /* time when read started */
274 unsigned long frame; /* current frame */
275 int64_t next_pts; /* synthetic pts for cases where pkt.pts
277 int64_t pts; /* current pts */
278 int is_start; /* is 1 at the start and after a discontinuity */
281 typedef struct AVInputFile {
282 int eof_reached; /* true if eof reached */
283 int ist_index; /* index of first stream in ist_table */
284 int buffer_size; /* current total buffer size */
285 int nb_streams; /* nb streams we are aware of */
288 #ifdef HAVE_TERMIOS_H
290 /* init terminal so that we can grab keys */
291 static struct termios oldtty;
294 static void term_exit(void)
296 #ifdef HAVE_TERMIOS_H
297 tcsetattr (0, TCSANOW, &oldtty);
301 static volatile sig_atomic_t received_sigterm = 0;
304 sigterm_handler(int sig)
306 received_sigterm = sig;
310 static void term_init(void)
312 #ifdef HAVE_TERMIOS_H
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);
328 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
331 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
332 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
334 register a function to be called at normal program termination
337 #ifdef CONFIG_BEOS_NETSERVER
338 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
342 /* read a key without blocking */
343 static int read_key(void)
345 #if defined(HAVE_TERMIOS_H)
348 #ifndef CONFIG_BEOS_NETSERVER
356 n = select(1, &rfds, NULL, NULL, &tv);
365 #elif defined(HAVE_CONIO_H)
372 static int decode_interrupt_cb(void)
374 return q_pressed || (q_pressed = read_key() == 'q');
377 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
382 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
385 /* copy stream format */
386 s->nb_streams = ic->nb_streams;
387 for(i=0;i<ic->nb_streams;i++) {
390 // FIXME: a more elegant solution is needed
391 st = av_mallocz(sizeof(AVStream));
392 memcpy(st, ic->streams[i], sizeof(AVStream));
393 st->codec = avcodec_alloc_context();
394 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
398 av_close_input_file(ic);
403 get_sync_ipts(const AVOutputStream *ost)
405 const AVInputStream *ist = ost->sync_ist;
406 return (double)(ist->pts - start_time)/AV_TIME_BASE;
409 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
413 AVPacket new_pkt= *pkt;
414 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
415 &new_pkt.data, &new_pkt.size,
416 pkt->data, pkt->size,
417 pkt->flags & PKT_FLAG_KEY);
420 new_pkt.destruct= av_destruct_packet;
427 ret= av_interleaved_write_frame(s, pkt);
429 print_error("av_interleaved_write_frame()", ret);
434 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
436 static void do_audio_out(AVFormatContext *s,
439 unsigned char *buf, int size)
442 static uint8_t *audio_buf = NULL;
443 static uint8_t *audio_out = NULL;
444 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
446 int size_out, frame_bytes, ret;
447 AVCodecContext *enc= ost->st->codec;
449 /* SC: dynamic allocation of buffers */
451 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
453 audio_out = av_malloc(audio_out_size);
454 if (!audio_buf || !audio_out)
455 return; /* Should signal an error ! */
457 if(audio_sync_method){
458 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
459 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
460 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
461 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
463 //FIXME resample delay
464 if(fabs(delta) > 50){
465 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
467 byte_delta= FFMAX(byte_delta, -size);
471 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
476 static uint8_t *input_tmp= NULL;
477 input_tmp= av_realloc(input_tmp, byte_delta + size);
479 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
482 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
484 memset(input_tmp, 0, byte_delta);
485 memcpy(input_tmp + byte_delta, buf, size);
489 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
491 }else if(audio_sync_method>1){
492 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
493 assert(ost->audio_resample);
495 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
496 // fprintf(stderr, "drift:%f len:%d opts:%"PRId64" ipts:%"PRId64" fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2));
497 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
501 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
502 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
504 if (ost->audio_resample) {
506 size_out = audio_resample(ost->resample,
507 (short *)buftmp, (short *)buf,
508 size / (ist->st->codec->channels * 2));
509 size_out = size_out * enc->channels * 2;
515 /* now encode as many frames as possible */
516 if (enc->frame_size > 1) {
517 /* output resampled raw samples */
518 av_fifo_write(&ost->fifo, buftmp, size_out);
520 frame_bytes = enc->frame_size * 2 * enc->channels;
522 while (av_fifo_read(&ost->fifo, audio_buf, frame_bytes) == 0) {
524 av_init_packet(&pkt);
526 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
529 pkt.stream_index= ost->index;
532 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
533 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
534 pkt.flags |= PKT_FLAG_KEY;
535 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
537 ost->sync_opts += enc->frame_size;
541 av_init_packet(&pkt);
543 ost->sync_opts += size_out / (2 * enc->channels);
545 /* output a pcm frame */
546 /* XXX: change encoding codec API to avoid this ? */
547 switch(enc->codec->id) {
548 case CODEC_ID_PCM_S32LE:
549 case CODEC_ID_PCM_S32BE:
550 case CODEC_ID_PCM_U32LE:
551 case CODEC_ID_PCM_U32BE:
552 size_out = size_out << 1;
554 case CODEC_ID_PCM_S24LE:
555 case CODEC_ID_PCM_S24BE:
556 case CODEC_ID_PCM_U24LE:
557 case CODEC_ID_PCM_U24BE:
558 case CODEC_ID_PCM_S24DAUD:
559 size_out = size_out / 2 * 3;
561 case CODEC_ID_PCM_S16LE:
562 case CODEC_ID_PCM_S16BE:
563 case CODEC_ID_PCM_U16LE:
564 case CODEC_ID_PCM_U16BE:
567 size_out = size_out >> 1;
570 ret = avcodec_encode_audio(enc, audio_out, size_out,
573 pkt.stream_index= ost->index;
576 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
577 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
578 pkt.flags |= PKT_FLAG_KEY;
579 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
583 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
587 AVPicture picture_tmp;
590 dec = ist->st->codec;
592 /* deinterlace : must be done before any resize */
593 if (do_deinterlace || using_vhook) {
596 /* create temporary picture */
597 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
598 buf = av_malloc(size);
602 picture2 = &picture_tmp;
603 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
606 if(avpicture_deinterlace(picture2, picture,
607 dec->pix_fmt, dec->width, dec->height) < 0) {
608 /* if error, do not deinterlace */
614 av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
621 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,
622 1000000 * ist->pts / AV_TIME_BASE);
624 if (picture != picture2)
625 *picture = *picture2;
629 /* we begin to correct av delay at this threshold */
630 #define AV_DELAY_MAX 0.100
632 static void do_subtitle_out(AVFormatContext *s,
638 static uint8_t *subtitle_out = NULL;
639 int subtitle_out_max_size = 65536;
640 int subtitle_out_size, nb, i;
644 if (pts == AV_NOPTS_VALUE) {
645 fprintf(stderr, "Subtitle packets must have a pts\n");
649 enc = ost->st->codec;
652 subtitle_out = av_malloc(subtitle_out_max_size);
655 /* Note: DVB subtitle need one packet to draw them and one other
656 packet to clear them */
657 /* XXX: signal it in the codec context ? */
658 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
663 for(i = 0; i < nb; i++) {
664 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
665 subtitle_out_max_size, sub);
667 av_init_packet(&pkt);
668 pkt.stream_index = ost->index;
669 pkt.data = subtitle_out;
670 pkt.size = subtitle_out_size;
671 pkt.pts = av_rescale_q(pts, ist->st->time_base, ost->st->time_base);
672 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
673 /* XXX: the pts correction is handled here. Maybe handling
674 it in the codec would be better */
676 pkt.pts += 90 * sub->start_display_time;
678 pkt.pts += 90 * sub->end_display_time;
680 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
684 static int bit_buffer_size= 1024*256;
685 static uint8_t *bit_buffer= NULL;
687 static void do_video_out(AVFormatContext *s,
693 int nb_frames, i, ret;
694 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
695 AVFrame picture_crop_temp, picture_pad_temp;
696 AVCodecContext *enc, *dec;
698 avcodec_get_frame_defaults(&picture_crop_temp);
699 avcodec_get_frame_defaults(&picture_pad_temp);
701 enc = ost->st->codec;
702 dec = ist->st->codec;
704 /* by default, we output a single frame */
709 if(video_sync_method){
711 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
712 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
715 else if (vdelta > 1.1)
716 nb_frames = lrintf(vdelta);
717 //fprintf(stderr, "vdelta:%f, ost->sync_opts:%"PRId64", ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, ost->sync_ipts, nb_frames);
721 fprintf(stderr, "*** drop!\n");
722 }else if (nb_frames > 1) {
723 nb_frames_dup += nb_frames;
725 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
728 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
730 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
734 if (ost->video_crop) {
735 if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
736 av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
739 formatted_picture = &picture_crop_temp;
741 formatted_picture = in_picture;
744 final_picture = formatted_picture;
745 padding_src = formatted_picture;
746 resampling_dst = &ost->pict_tmp;
747 if (ost->video_pad) {
748 final_picture = &ost->pict_tmp;
749 if (ost->video_resample) {
750 if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
751 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
754 resampling_dst = &picture_pad_temp;
758 if (ost->video_resample) {
760 final_picture = &ost->pict_tmp;
761 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
762 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
765 if (ost->video_pad) {
766 av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
767 enc->height, enc->width, enc->pix_fmt,
768 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
771 /* duplicates frame if needed */
772 for(i=0;i<nb_frames;i++) {
774 av_init_packet(&pkt);
775 pkt.stream_index= ost->index;
777 if (s->oformat->flags & AVFMT_RAWPICTURE) {
778 /* raw pictures are written as AVPicture structure to
779 avoid any copies. We support temorarily the older
781 AVFrame* old_frame = enc->coded_frame;
782 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
783 pkt.data= (uint8_t *)final_picture;
784 pkt.size= sizeof(AVPicture);
785 if(dec->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
786 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
787 if(dec->coded_frame && dec->coded_frame->key_frame)
788 pkt.flags |= PKT_FLAG_KEY;
790 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
791 enc->coded_frame = old_frame;
795 big_picture= *final_picture;
796 /* better than nothing: use input picture interlaced
798 big_picture.interlaced_frame = in_picture->interlaced_frame;
799 if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
800 if(top_field_first == -1)
801 big_picture.top_field_first = in_picture->top_field_first;
803 big_picture.top_field_first = top_field_first;
806 /* handles sameq here. This is not correct because it may
807 not be a global option */
809 big_picture.quality = ist->st->quality;
811 big_picture.quality = ost->st->quality;
813 big_picture.pict_type = 0;
814 // big_picture.pts = AV_NOPTS_VALUE;
815 big_picture.pts= ost->sync_opts;
816 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
817 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
818 ret = avcodec_encode_video(enc,
819 bit_buffer, bit_buffer_size,
822 fprintf(stderr, "Video encoding failed\n");
825 //enc->frame_number = enc->real_pict_num;
827 pkt.data= bit_buffer;
829 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
830 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
831 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
832 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
833 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
835 if(enc->coded_frame && enc->coded_frame->key_frame)
836 pkt.flags |= PKT_FLAG_KEY;
837 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
839 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
840 // enc->frame_number-1, enc->real_pict_num, ret,
842 /* if two pass, output log */
843 if (ost->logfile && enc->stats_out) {
844 fprintf(ost->logfile, "%s", enc->stats_out);
853 static double psnr(double d){
854 if(d==0) return INFINITY;
855 return -10.0*log(d)/log(10.0);
858 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
863 double ti1, bitrate, avg_bitrate;
865 /* this is executed just the first time do_video_stats is called */
867 vstats_file = fopen(vstats_filename, "w");
874 enc = ost->st->codec;
875 if (enc->codec_type == CODEC_TYPE_VIDEO) {
876 frame_number = ost->frame_number;
877 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
878 if (enc->flags&CODEC_FLAG_PSNR)
879 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
881 fprintf(vstats_file,"f_size= %6d ", frame_size);
882 /* compute pts value */
883 ti1 = ost->sync_opts * av_q2d(enc->time_base);
887 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
888 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
889 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
890 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
891 fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
895 static void print_report(AVFormatContext **output_files,
896 AVOutputStream **ost_table, int nb_ostreams,
901 AVFormatContext *oc, *os;
904 int frame_number, vid, i;
905 double bitrate, ti1, pts;
906 static int64_t last_time = -1;
907 static int qp_histogram[52];
909 if (!is_last_report) {
911 /* display the report every 0.5 seconds */
912 cur_time = av_gettime();
913 if (last_time == -1) {
914 last_time = cur_time;
917 if ((cur_time - last_time) < 500000)
919 last_time = cur_time;
923 oc = output_files[0];
925 total_size = url_fsize(oc->pb);
926 if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
927 total_size= url_ftell(oc->pb);
932 for(i=0;i<nb_ostreams;i++) {
934 os = output_files[ost->file_index];
935 enc = ost->st->codec;
936 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
937 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
938 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
940 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
941 float t = (av_gettime()-timer_start) / 1000000.0;
943 frame_number = ost->frame_number;
944 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
945 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
946 enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
948 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
949 if(qp_hist && enc->coded_frame){
951 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
952 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
955 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
957 if (enc->flags&CODEC_FLAG_PSNR){
959 double error, error_sum=0;
960 double scale, scale_sum=0;
961 char type[3]= {'Y','U','V'};
962 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
965 error= enc->error[j];
966 scale= enc->width*enc->height*255.0*255.0*frame_number;
968 error= enc->coded_frame->error[j];
969 scale= enc->width*enc->height*255.0*255.0;
974 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
976 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
980 /* compute min output value */
981 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
982 if ((pts < ti1) && (pts > 0))
988 if (verbose || is_last_report) {
989 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
991 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
992 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
993 (double)total_size / 1024, ti1, bitrate);
996 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
997 nb_frames_dup, nb_frames_drop);
1000 fprintf(stderr, "%s \r", buf);
1005 if (is_last_report && verbose >= 0){
1006 int64_t raw= audio_size + video_size + extra_size;
1007 fprintf(stderr, "\n");
1008 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1012 100.0*(total_size - raw)/raw
1017 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1018 static int output_packet(AVInputStream *ist, int ist_index,
1019 AVOutputStream **ost_table, int nb_ostreams,
1020 const AVPacket *pkt)
1022 AVFormatContext *os;
1023 AVOutputStream *ost;
1027 int data_size, got_picture;
1029 void *buffer_to_free;
1030 static unsigned int samples_size= 0;
1031 static short *samples= NULL;
1032 AVSubtitle subtitle, *subtitle_to_free;
1036 ist->pts= ist->next_pts; // needed for last packet if vsync=0
1037 } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1038 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1040 // assert(ist->pts == ist->next_pts);
1054 /* decode the packet if needed */
1055 data_buf = NULL; /* fail safe */
1057 subtitle_to_free = NULL;
1058 if (ist->decoding_needed) {
1059 switch(ist->st->codec->codec_type) {
1060 case CODEC_TYPE_AUDIO:{
1062 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE));
1063 data_size= samples_size;
1064 /* XXX: could avoid copy if PCM 16 bits with same
1065 endianness as CPU */
1066 ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1072 /* Some bug in mpeg audio decoder gives */
1073 /* data_size < 0, it seems they are overflows */
1074 if (data_size <= 0) {
1075 /* no audio frame */
1078 data_buf = (uint8_t *)samples;
1079 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1080 (ist->st->codec->sample_rate * ist->st->codec->channels);
1082 case CODEC_TYPE_VIDEO:
1083 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1084 /* XXX: allocate picture correctly */
1085 avcodec_get_frame_defaults(&picture);
1087 ret = avcodec_decode_video(ist->st->codec,
1088 &picture, &got_picture, ptr, len);
1089 ist->st->quality= picture.quality;
1093 /* no picture yet */
1094 goto discard_packet;
1096 if (ist->st->codec->time_base.num != 0) {
1097 ist->next_pts += ((int64_t)AV_TIME_BASE *
1098 ist->st->codec->time_base.num) /
1099 ist->st->codec->time_base.den;
1103 case CODEC_TYPE_SUBTITLE:
1104 ret = avcodec_decode_subtitle(ist->st->codec,
1105 &subtitle, &got_subtitle, ptr, len);
1108 if (!got_subtitle) {
1109 goto discard_packet;
1111 subtitle_to_free = &subtitle;
1118 switch(ist->st->codec->codec_type) {
1119 case CODEC_TYPE_AUDIO:
1120 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1121 ist->st->codec->sample_rate;
1123 case CODEC_TYPE_VIDEO:
1124 if (ist->st->codec->time_base.num != 0) {
1125 ist->next_pts += ((int64_t)AV_TIME_BASE *
1126 ist->st->codec->time_base.num) /
1127 ist->st->codec->time_base.den;
1137 buffer_to_free = NULL;
1138 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1139 pre_process_video_frame(ist, (AVPicture *)&picture,
1143 // preprocess audio (volume)
1144 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1145 if (audio_volume != 256) {
1148 for(i=0;i<(data_size / sizeof(short));i++) {
1149 int v = ((*volp) * audio_volume + 128) >> 8;
1150 if (v < -32768) v = -32768;
1151 if (v > 32767) v = 32767;
1157 /* frame rate emulation */
1158 if (ist->st->codec->rate_emu) {
1159 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1160 int64_t now = av_gettime() - ist->start;
1168 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1169 is the one of the next displayed one */
1170 /* XXX: add mpeg4 too ? */
1171 if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1172 if (ist->st->codec->pict_type != B_TYPE) {
1174 tmp = ist->last_ip_pts;
1175 ist->last_ip_pts = ist->frac_pts.val;
1176 ist->frac_pts.val = tmp;
1180 /* if output time reached then transcode raw format,
1181 encode packets and output them */
1182 if (start_time == 0 || ist->pts >= start_time)
1183 for(i=0;i<nb_ostreams;i++) {
1187 if (ost->source_index == ist_index) {
1188 os = output_files[ost->file_index];
1191 printf("%d: got pts=%0.3f %0.3f\n", i,
1192 (double)pkt->pts / AV_TIME_BASE,
1193 ((double)ist->pts / AV_TIME_BASE) -
1194 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1196 /* set the input output pts pairs */
1197 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1199 if (ost->encoding_needed) {
1200 switch(ost->st->codec->codec_type) {
1201 case CODEC_TYPE_AUDIO:
1202 do_audio_out(os, ost, ist, data_buf, data_size);
1204 case CODEC_TYPE_VIDEO:
1205 do_video_out(os, ost, ist, &picture, &frame_size);
1206 video_size += frame_size;
1207 if (vstats_filename && frame_size)
1208 do_video_stats(os, ost, frame_size);
1210 case CODEC_TYPE_SUBTITLE:
1211 do_subtitle_out(os, ost, ist, &subtitle,
1218 AVFrame avframe; //FIXME/XXX remove this
1220 av_init_packet(&opkt);
1222 if (!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY))
1225 /* no reencoding needed : output the packet directly */
1226 /* force the input stream PTS */
1228 avcodec_get_frame_defaults(&avframe);
1229 ost->st->codec->coded_frame= &avframe;
1230 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1232 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1233 audio_size += data_size;
1234 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1235 video_size += data_size;
1239 opkt.stream_index= ost->index;
1240 if(pkt->pts != AV_NOPTS_VALUE)
1241 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1243 opkt.pts= AV_NOPTS_VALUE;
1245 if (pkt->dts == AV_NOPTS_VALUE)
1246 opkt.dts = av_rescale_q(ist->next_pts, AV_TIME_BASE_Q, ost->st->time_base);
1248 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1250 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1251 opkt.flags= pkt->flags;
1253 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1254 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1255 opkt.destruct= av_destruct_packet;
1257 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
1258 ost->st->codec->frame_number++;
1259 ost->frame_number++;
1260 av_free_packet(&opkt);
1264 av_free(buffer_to_free);
1265 /* XXX: allocate the subtitles in the codec ? */
1266 if (subtitle_to_free) {
1267 if (subtitle_to_free->rects != NULL) {
1268 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1269 av_free(subtitle_to_free->rects[i].bitmap);
1270 av_free(subtitle_to_free->rects[i].rgba_palette);
1272 av_freep(&subtitle_to_free->rects);
1274 subtitle_to_free->num_rects = 0;
1275 subtitle_to_free = NULL;
1282 for(i=0;i<nb_ostreams;i++) {
1284 if (ost->source_index == ist_index) {
1285 AVCodecContext *enc= ost->st->codec;
1286 os = output_files[ost->file_index];
1288 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1290 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1293 if (ost->encoding_needed) {
1297 av_init_packet(&pkt);
1298 pkt.stream_index= ost->index;
1300 switch(ost->st->codec->codec_type) {
1301 case CODEC_TYPE_AUDIO:
1302 fifo_bytes = av_fifo_size(&ost->fifo);
1304 /* encode any samples remaining in fifo */
1305 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1306 int fs_tmp = enc->frame_size;
1307 enc->frame_size = fifo_bytes / (2 * enc->channels);
1308 if(av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes) == 0) {
1309 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1311 enc->frame_size = fs_tmp;
1314 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1317 pkt.flags |= PKT_FLAG_KEY;
1319 case CODEC_TYPE_VIDEO:
1320 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1322 if(enc->coded_frame && enc->coded_frame->key_frame)
1323 pkt.flags |= PKT_FLAG_KEY;
1324 if (ost->logfile && enc->stats_out) {
1325 fprintf(ost->logfile, "%s", enc->stats_out);
1334 pkt.data= bit_buffer;
1336 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1337 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1338 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1350 static void print_sdp(AVFormatContext **avc, int n)
1354 avf_sdp_create(avc, n, sdp, sizeof(sdp));
1355 printf("SDP:\n%s\n", sdp);
1358 static int stream_index_from_inputs(AVFormatContext **input_files,
1360 AVInputFile *file_table,
1361 AVInputStream **ist_table,
1362 enum CodecType type,
1366 for(z=0; z<nb_input_files; z++) {
1367 AVFormatContext *ic = input_files[z];
1368 for(p=0; p<ic->nb_programs; p++) {
1369 AVProgram *program = ic->programs[p];
1370 if(program->id != programid)
1372 for(q=0; q<program->nb_stream_indexes; q++) {
1373 int sidx = program->stream_index[q];
1374 int ris = file_table[z].ist_index + sidx;
1375 if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1385 * The following code is the main loop of the file converter
1387 static int av_encode(AVFormatContext **output_files,
1388 int nb_output_files,
1389 AVFormatContext **input_files,
1391 AVStreamMap *stream_maps, int nb_stream_maps)
1393 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1394 AVFormatContext *is, *os;
1395 AVCodecContext *codec, *icodec;
1396 AVOutputStream *ost, **ost_table = NULL;
1397 AVInputStream *ist, **ist_table = NULL;
1398 AVInputFile *file_table;
1402 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1406 /* input stream init */
1408 for(i=0;i<nb_input_files;i++) {
1409 is = input_files[i];
1410 file_table[i].ist_index = j;
1411 file_table[i].nb_streams = is->nb_streams;
1412 j += is->nb_streams;
1416 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1420 for(i=0;i<nb_istreams;i++) {
1421 ist = av_mallocz(sizeof(AVInputStream));
1427 for(i=0;i<nb_input_files;i++) {
1428 is = input_files[i];
1429 for(k=0;k<is->nb_streams;k++) {
1430 ist = ist_table[j++];
1431 ist->st = is->streams[k];
1432 ist->file_index = i;
1434 ist->discard = 1; /* the stream is discarded by default
1437 if (ist->st->codec->rate_emu) {
1438 ist->start = av_gettime();
1444 /* output stream init */
1446 for(i=0;i<nb_output_files;i++) {
1447 os = output_files[i];
1448 if (!os->nb_streams) {
1449 fprintf(stderr, "Output file does not contain any stream\n");
1452 nb_ostreams += os->nb_streams;
1454 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1455 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1459 /* Sanity check the mapping args -- do the input files & streams exist? */
1460 for(i=0;i<nb_stream_maps;i++) {
1461 int fi = stream_maps[i].file_index;
1462 int si = stream_maps[i].stream_index;
1464 if (fi < 0 || fi > nb_input_files - 1 ||
1465 si < 0 || si > file_table[fi].nb_streams - 1) {
1466 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1469 fi = stream_maps[i].sync_file_index;
1470 si = stream_maps[i].sync_stream_index;
1471 if (fi < 0 || fi > nb_input_files - 1 ||
1472 si < 0 || si > file_table[fi].nb_streams - 1) {
1473 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1478 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1481 for(i=0;i<nb_ostreams;i++) {
1482 ost = av_mallocz(sizeof(AVOutputStream));
1489 for(k=0;k<nb_output_files;k++) {
1490 os = output_files[k];
1491 for(i=0;i<os->nb_streams;i++) {
1493 ost = ost_table[n++];
1494 ost->file_index = k;
1496 ost->st = os->streams[i];
1497 if (nb_stream_maps > 0) {
1498 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1499 stream_maps[n-1].stream_index;
1501 /* Sanity check that the stream types match */
1502 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1503 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1504 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1505 ost->file_index, ost->index);
1512 j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1514 ost->source_index = j;
1518 /* get corresponding input stream index : we select the first one with the right type */
1520 for(j=0;j<nb_istreams;j++) {
1523 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1524 ost->source_index = j;
1532 if(! opt_programid) {
1533 /* try again and reuse existing stream */
1534 for(j=0;j<nb_istreams;j++) {
1536 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1537 ost->source_index = j;
1543 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1544 ost->file_index, ost->index);
1549 ist = ist_table[ost->source_index];
1551 ost->sync_ist = (nb_stream_maps > 0) ?
1552 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1553 stream_maps[n-1].sync_stream_index] : ist;
1557 /* for each output stream, we compute the right encoding parameters */
1558 for(i=0;i<nb_ostreams;i++) {
1560 os = output_files[ost->file_index];
1561 ist = ist_table[ost->source_index];
1563 codec = ost->st->codec;
1564 icodec = ist->st->codec;
1566 if (!ost->st->language[0])
1567 av_strlcpy(ost->st->language, ist->st->language,
1568 sizeof(ost->st->language));
1570 if (ost->st->stream_copy) {
1571 /* if stream_copy is selected, no need to decode or encode */
1572 codec->codec_id = icodec->codec_id;
1573 codec->codec_type = icodec->codec_type;
1575 if(!codec->codec_tag){
1576 if( !os->oformat->codec_tag
1577 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1578 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1579 codec->codec_tag = icodec->codec_tag;
1582 codec->bit_rate = icodec->bit_rate;
1583 codec->extradata= icodec->extradata;
1584 codec->extradata_size= icodec->extradata_size;
1585 if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1586 codec->time_base = icodec->time_base;
1588 codec->time_base = ist->st->time_base;
1589 switch(codec->codec_type) {
1590 case CODEC_TYPE_AUDIO:
1591 codec->sample_rate = icodec->sample_rate;
1592 codec->channels = icodec->channels;
1593 codec->frame_size = icodec->frame_size;
1594 codec->block_align= icodec->block_align;
1595 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1596 codec->block_align= 0;
1598 case CODEC_TYPE_VIDEO:
1600 fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1603 codec->pix_fmt = icodec->pix_fmt;
1604 codec->width = icodec->width;
1605 codec->height = icodec->height;
1606 codec->has_b_frames = icodec->has_b_frames;
1608 case CODEC_TYPE_SUBTITLE:
1614 switch(codec->codec_type) {
1615 case CODEC_TYPE_AUDIO:
1616 if (av_fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1619 if (codec->channels == icodec->channels &&
1620 codec->sample_rate == icodec->sample_rate) {
1621 ost->audio_resample = 0;
1623 if (codec->channels != icodec->channels &&
1624 (icodec->codec_id == CODEC_ID_AC3 ||
1625 icodec->codec_id == CODEC_ID_DTS)) {
1626 /* Special case for 5:1 AC3 and DTS input */
1627 /* and mono or stereo output */
1628 /* Request specific number of channels */
1629 icodec->channels = codec->channels;
1630 if (codec->sample_rate == icodec->sample_rate)
1631 ost->audio_resample = 0;
1633 ost->audio_resample = 1;
1636 ost->audio_resample = 1;
1639 if(audio_sync_method>1)
1640 ost->audio_resample = 1;
1642 if(ost->audio_resample){
1643 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1644 codec->sample_rate, icodec->sample_rate);
1646 printf("Can't resample. Aborting.\n");
1650 ist->decoding_needed = 1;
1651 ost->encoding_needed = 1;
1653 case CODEC_TYPE_VIDEO:
1654 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1655 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1656 ost->video_resample = ((codec->width != icodec->width -
1657 (frame_leftBand + frame_rightBand) +
1658 (frame_padleft + frame_padright)) ||
1659 (codec->height != icodec->height -
1660 (frame_topBand + frame_bottomBand) +
1661 (frame_padtop + frame_padbottom)) ||
1662 (codec->pix_fmt != icodec->pix_fmt));
1663 if (ost->video_crop) {
1664 ost->topBand = frame_topBand;
1665 ost->leftBand = frame_leftBand;
1667 if (ost->video_pad) {
1668 ost->padtop = frame_padtop;
1669 ost->padleft = frame_padleft;
1670 ost->padbottom = frame_padbottom;
1671 ost->padright = frame_padright;
1672 if (!ost->video_resample) {
1673 avcodec_get_frame_defaults(&ost->pict_tmp);
1674 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1675 codec->width, codec->height ) )
1679 if (ost->video_resample) {
1680 avcodec_get_frame_defaults(&ost->pict_tmp);
1681 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1682 codec->width, codec->height ) ) {
1683 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1686 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1687 ost->img_resample_ctx = sws_getContext(
1688 icodec->width - (frame_leftBand + frame_rightBand),
1689 icodec->height - (frame_topBand + frame_bottomBand),
1691 codec->width - (frame_padleft + frame_padright),
1692 codec->height - (frame_padtop + frame_padbottom),
1694 sws_flags, NULL, NULL, NULL);
1695 if (ost->img_resample_ctx == NULL) {
1696 fprintf(stderr, "Cannot get resampling context\n");
1699 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1701 ost->encoding_needed = 1;
1702 ist->decoding_needed = 1;
1704 case CODEC_TYPE_SUBTITLE:
1705 ost->encoding_needed = 1;
1706 ist->decoding_needed = 1;
1713 if (ost->encoding_needed &&
1714 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1715 char logfilename[1024];
1720 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1722 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1723 if (codec->flags & CODEC_FLAG_PASS1) {
1724 f = fopen(logfilename, "w");
1726 perror(logfilename);
1731 /* read the log file */
1732 f = fopen(logfilename, "r");
1734 perror(logfilename);
1737 fseek(f, 0, SEEK_END);
1739 fseek(f, 0, SEEK_SET);
1740 logbuffer = av_malloc(size + 1);
1742 fprintf(stderr, "Could not allocate log buffer\n");
1745 size = fread(logbuffer, 1, size, f);
1747 logbuffer[size] = '\0';
1748 codec->stats_in = logbuffer;
1752 if(codec->codec_type == CODEC_TYPE_VIDEO){
1753 int size= codec->width * codec->height;
1754 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1759 bit_buffer = av_malloc(bit_buffer_size);
1763 /* dump the file output parameters - cannot be done before in case
1765 for(i=0;i<nb_output_files;i++) {
1766 dump_format(output_files[i], i, output_files[i]->filename, 1);
1769 /* dump the stream mapping */
1771 fprintf(stderr, "Stream mapping:\n");
1772 for(i=0;i<nb_ostreams;i++) {
1774 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1775 ist_table[ost->source_index]->file_index,
1776 ist_table[ost->source_index]->index,
1779 if (ost->sync_ist != ist_table[ost->source_index])
1780 fprintf(stderr, " [sync #%d.%d]",
1781 ost->sync_ist->file_index,
1782 ost->sync_ist->index);
1783 fprintf(stderr, "\n");
1787 /* open each encoder */
1788 for(i=0;i<nb_ostreams;i++) {
1790 if (ost->encoding_needed) {
1792 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1794 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1795 ost->file_index, ost->index);
1798 if (avcodec_open(ost->st->codec, codec) < 0) {
1799 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1800 ost->file_index, ost->index);
1803 extra_size += ost->st->codec->extradata_size;
1807 /* open each decoder */
1808 for(i=0;i<nb_istreams;i++) {
1810 if (ist->decoding_needed) {
1812 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1814 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1815 ist->st->codec->codec_id, ist->file_index, ist->index);
1818 if (avcodec_open(ist->st->codec, codec) < 0) {
1819 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1820 ist->file_index, ist->index);
1823 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1824 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1829 for(i=0;i<nb_istreams;i++) {
1831 is = input_files[ist->file_index];
1834 if( input_files_ts_offset[ist->file_index] != -is->start_time
1835 && !(is->start_time == AV_NOPTS_VALUE && input_files_ts_offset[ist->file_index]==0))
1836 ist->next_pts= AV_NOPTS_VALUE;
1840 /* set meta data information from input file if required */
1841 for (i=0;i<nb_meta_data_maps;i++) {
1842 AVFormatContext *out_file;
1843 AVFormatContext *in_file;
1845 int out_file_index = meta_data_maps[i].out_file;
1846 int in_file_index = meta_data_maps[i].in_file;
1847 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1848 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1849 ret = AVERROR(EINVAL);
1852 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1853 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1854 ret = AVERROR(EINVAL);
1858 out_file = output_files[out_file_index];
1859 in_file = input_files[in_file_index];
1861 strcpy(out_file->title, in_file->title);
1862 strcpy(out_file->author, in_file->author);
1863 strcpy(out_file->copyright, in_file->copyright);
1864 strcpy(out_file->comment, in_file->comment);
1865 strcpy(out_file->album, in_file->album);
1866 out_file->year = in_file->year;
1867 out_file->track = in_file->track;
1868 strcpy(out_file->genre, in_file->genre);
1871 /* open files and write file headers */
1872 for(i=0;i<nb_output_files;i++) {
1873 os = output_files[i];
1874 if (av_write_header(os) < 0) {
1875 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1876 ret = AVERROR(EINVAL);
1879 if (strcmp(output_files[i]->oformat->name, "rtp")) {
1884 print_sdp(output_files, nb_output_files);
1887 if ( !using_stdin && verbose >= 0) {
1888 fprintf(stderr, "Press [q] to stop encoding\n");
1889 url_set_interrupt_cb(decode_interrupt_cb);
1894 timer_start = av_gettime();
1896 for(; received_sigterm == 0;) {
1897 int file_index, ist_index;
1905 /* if 'q' pressed, exits */
1909 /* read_key() returns 0 on EOF */
1915 /* select the stream that we must read now by looking at the
1916 smallest output pts */
1918 for(i=0;i<nb_ostreams;i++) {
1921 os = output_files[ost->file_index];
1922 ist = ist_table[ost->source_index];
1923 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1924 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1926 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1927 ipts = (double)ist->pts;
1928 if (!file_table[ist->file_index].eof_reached){
1929 if(ipts < ipts_min) {
1931 if(input_sync ) file_index = ist->file_index;
1933 if(opts < opts_min) {
1935 if(!input_sync) file_index = ist->file_index;
1938 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1943 /* if none, if is finished */
1944 if (file_index < 0) {
1948 /* finish if recording time exhausted */
1949 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1952 /* finish if limit size exhausted */
1953 if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
1956 /* read a frame from it and output it in the fifo */
1957 is = input_files[file_index];
1958 if (av_read_frame(is, &pkt) < 0) {
1959 file_table[file_index].eof_reached = 1;
1967 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
1969 /* the following test is needed in case new streams appear
1970 dynamically in stream : we ignore them */
1971 if (pkt.stream_index >= file_table[file_index].nb_streams)
1972 goto discard_packet;
1973 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1974 ist = ist_table[ist_index];
1976 goto discard_packet;
1978 if (pkt.dts != AV_NOPTS_VALUE)
1979 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
1980 if (pkt.pts != AV_NOPTS_VALUE)
1981 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
1983 // fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec->codec_type);
1984 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1985 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
1986 int64_t delta= pkt_dts - ist->next_pts;
1987 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
1988 input_files_ts_offset[ist->file_index]-= delta;
1990 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1991 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
1992 if(pkt.pts != AV_NOPTS_VALUE)
1993 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
1997 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1998 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2001 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2002 ist->file_index, ist->index);
2004 av_free_packet(&pkt);
2009 av_free_packet(&pkt);
2011 /* dump report by using the output first video and audio streams */
2012 print_report(output_files, ost_table, nb_ostreams, 0);
2015 /* at the end of stream, we must flush the decoder buffers */
2016 for(i=0;i<nb_istreams;i++) {
2018 if (ist->decoding_needed) {
2019 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2025 /* write the trailer if needed and close file */
2026 for(i=0;i<nb_output_files;i++) {
2027 os = output_files[i];
2028 av_write_trailer(os);
2031 /* dump report by using the first video and audio streams */
2032 print_report(output_files, ost_table, nb_ostreams, 1);
2034 /* close each encoder */
2035 for(i=0;i<nb_ostreams;i++) {
2037 if (ost->encoding_needed) {
2038 av_freep(&ost->st->codec->stats_in);
2039 avcodec_close(ost->st->codec);
2043 /* close each decoder */
2044 for(i=0;i<nb_istreams;i++) {
2046 if (ist->decoding_needed) {
2047 avcodec_close(ist->st->codec);
2055 av_freep(&bit_buffer);
2056 av_free(file_table);
2059 for(i=0;i<nb_istreams;i++) {
2066 for(i=0;i<nb_ostreams;i++) {
2070 fclose(ost->logfile);
2071 ost->logfile = NULL;
2073 av_fifo_free(&ost->fifo); /* works even if fifo is not
2074 initialized but set to zero */
2075 av_free(ost->pict_tmp.data[0]);
2076 if (ost->video_resample)
2077 sws_freeContext(ost->img_resample_ctx);
2078 if (ost->audio_resample)
2079 audio_resample_close(ost->resample);
2087 ret = AVERROR(ENOMEM);
2092 int file_read(const char *filename)
2095 unsigned char buffer[1024];
2098 if (url_open(&h, filename, O_RDONLY) < 0) {
2099 printf("could not open '%s'\n", filename);
2103 len = url_read(h, buffer, sizeof(buffer));
2106 for(i=0;i<len;i++) putchar(buffer[i]);
2113 static void opt_format(const char *arg)
2115 /* compatibility stuff for pgmyuv */
2116 if (!strcmp(arg, "pgmyuv")) {
2117 pgmyuv_compatibility_hack=1;
2118 // opt_image_format(arg);
2120 fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2123 file_iformat = av_find_input_format(arg);
2124 file_oformat = guess_format(arg, NULL, NULL);
2125 if (!file_iformat && !file_oformat) {
2126 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2131 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
2132 extern int ffm_nopts;
2135 static int opt_default(const char *opt, const char *arg){
2137 const AVOption *o= NULL;
2138 int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
2140 for(type=0; type<CODEC_TYPE_NB; type++){
2141 const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
2143 o = av_set_string(avctx_opts[type], opt, arg);
2146 o = av_set_string(avformat_opts, opt, arg);
2148 o = av_set_string(sws_opts, opt, arg);
2151 o = av_set_string(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg);
2152 else if(opt[0] == 'v')
2153 o = av_set_string(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg);
2154 else if(opt[0] == 's')
2155 o = av_set_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg);
2160 // 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));
2162 //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
2163 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
2164 opt_names[opt_name_count++]= o->name;
2166 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
2167 /* disable generate of real time pts in ffm (need to be supressed anyway) */
2168 if(avctx_opts[0]->flags & CODEC_FLAG_BITEXACT)
2172 if(avctx_opts[0]->debug)
2173 av_log_level = AV_LOG_DEBUG;
2177 static void opt_video_rc_eq(char *arg)
2182 static void opt_video_rc_override_string(char *arg)
2184 video_rc_override_string = arg;
2187 static void opt_me_threshold(const char *arg)
2189 me_threshold = atoi(arg);
2192 static void opt_verbose(const char *arg)
2194 verbose = atoi(arg);
2195 av_log_level = atoi(arg);
2198 static void opt_frame_rate(const char *arg)
2200 if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2201 fprintf(stderr, "Incorrect frame rate\n");
2206 static void opt_bitrate(const char *opt, const char *arg)
2208 int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2210 opt_default(opt, arg);
2212 if (av_get_int(avctx_opts[codec_type], "b", NULL) < 1000)
2213 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2216 static void opt_frame_crop_top(const char *arg)
2218 frame_topBand = atoi(arg);
2219 if (frame_topBand < 0) {
2220 fprintf(stderr, "Incorrect top crop size\n");
2223 if ((frame_topBand % 2) != 0) {
2224 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2227 if ((frame_topBand) >= frame_height){
2228 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2231 frame_height -= frame_topBand;
2234 static void opt_frame_crop_bottom(const char *arg)
2236 frame_bottomBand = atoi(arg);
2237 if (frame_bottomBand < 0) {
2238 fprintf(stderr, "Incorrect bottom crop size\n");
2241 if ((frame_bottomBand % 2) != 0) {
2242 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2245 if ((frame_bottomBand) >= frame_height){
2246 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2249 frame_height -= frame_bottomBand;
2252 static void opt_frame_crop_left(const char *arg)
2254 frame_leftBand = atoi(arg);
2255 if (frame_leftBand < 0) {
2256 fprintf(stderr, "Incorrect left crop size\n");
2259 if ((frame_leftBand % 2) != 0) {
2260 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2263 if ((frame_leftBand) >= frame_width){
2264 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2267 frame_width -= frame_leftBand;
2270 static void opt_frame_crop_right(const char *arg)
2272 frame_rightBand = atoi(arg);
2273 if (frame_rightBand < 0) {
2274 fprintf(stderr, "Incorrect right crop size\n");
2277 if ((frame_rightBand % 2) != 0) {
2278 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2281 if ((frame_rightBand) >= frame_width){
2282 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2285 frame_width -= frame_rightBand;
2288 static void opt_frame_size(const char *arg)
2290 if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2291 fprintf(stderr, "Incorrect frame size\n");
2294 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2295 fprintf(stderr, "Frame size must be a multiple of 2\n");
2301 #define SCALEBITS 10
2302 #define ONE_HALF (1 << (SCALEBITS - 1))
2303 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2305 #define RGB_TO_Y(r, g, b) \
2306 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2307 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2309 #define RGB_TO_U(r1, g1, b1, shift)\
2310 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2311 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2313 #define RGB_TO_V(r1, g1, b1, shift)\
2314 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2315 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2317 static void opt_pad_color(const char *arg) {
2318 /* Input is expected to be six hex digits similar to
2319 how colors are expressed in html tags (but without the #) */
2320 int rgb = strtol(arg, NULL, 16);
2324 g = ((rgb >> 8) & 255);
2327 padcolor[0] = RGB_TO_Y(r,g,b);
2328 padcolor[1] = RGB_TO_U(r,g,b,0);
2329 padcolor[2] = RGB_TO_V(r,g,b,0);
2332 static void opt_frame_pad_top(const char *arg)
2334 frame_padtop = atoi(arg);
2335 if (frame_padtop < 0) {
2336 fprintf(stderr, "Incorrect top pad size\n");
2339 if ((frame_padtop % 2) != 0) {
2340 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2345 static void opt_frame_pad_bottom(const char *arg)
2347 frame_padbottom = atoi(arg);
2348 if (frame_padbottom < 0) {
2349 fprintf(stderr, "Incorrect bottom pad size\n");
2352 if ((frame_padbottom % 2) != 0) {
2353 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2359 static void opt_frame_pad_left(const char *arg)
2361 frame_padleft = atoi(arg);
2362 if (frame_padleft < 0) {
2363 fprintf(stderr, "Incorrect left pad size\n");
2366 if ((frame_padleft % 2) != 0) {
2367 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2373 static void opt_frame_pad_right(const char *arg)
2375 frame_padright = atoi(arg);
2376 if (frame_padright < 0) {
2377 fprintf(stderr, "Incorrect right pad size\n");
2380 if ((frame_padright % 2) != 0) {
2381 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2386 void list_pix_fmts(void)
2389 char pix_fmt_str[128];
2390 for (i=-1; i < PIX_FMT_NB; i++) {
2391 avcodec_pix_fmt_string (pix_fmt_str, sizeof(pix_fmt_str), i);
2392 fprintf(stdout, "%s\n", pix_fmt_str);
2396 static void opt_frame_pix_fmt(const char *arg)
2398 if (strcmp(arg, "list"))
2399 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2406 static void opt_frame_aspect_ratio(const char *arg)
2412 p = strchr(arg, ':');
2414 x = strtol(arg, (char **)&arg, 10);
2416 y = strtol(arg+1, (char **)&arg, 10);
2418 ar = (double)x / (double)y;
2420 ar = strtod(arg, (char **)&arg);
2423 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2426 frame_aspect_ratio = ar;
2429 static void opt_qscale(const char *arg)
2431 video_qscale = atof(arg);
2432 if (video_qscale <= 0 ||
2433 video_qscale > 255) {
2434 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2439 static void opt_qdiff(const char *arg)
2441 video_qdiff = atoi(arg);
2442 if (video_qdiff < 0 ||
2444 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2449 static void opt_strict(const char *arg)
2454 static void opt_top_field_first(const char *arg)
2456 top_field_first= atoi(arg);
2459 static void opt_thread_count(const char *arg)
2461 thread_count= atoi(arg);
2462 #if !defined(HAVE_THREADS)
2464 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2468 static void opt_audio_rate(const char *arg)
2470 audio_sample_rate = atoi(arg);
2473 static void opt_audio_channels(const char *arg)
2475 audio_channels = atoi(arg);
2478 static void opt_video_channel(const char *arg)
2480 video_channel = strtol(arg, NULL, 0);
2483 static void opt_video_standard(const char *arg)
2485 video_standard = av_strdup(arg);
2488 static void opt_codec(int *pstream_copy, char **pcodec_name,
2489 int codec_type, const char *arg)
2491 av_freep(pcodec_name);
2492 if (!strcmp(arg, "copy")) {
2495 *pcodec_name = av_strdup(arg);
2499 static void opt_audio_codec(const char *arg)
2501 opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2504 static void opt_audio_tag(const char *arg)
2507 audio_codec_tag= strtol(arg, &tail, 0);
2510 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2513 static void opt_video_tag(const char *arg)
2516 video_codec_tag= strtol(arg, &tail, 0);
2519 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2523 static void add_frame_hooker(const char *arg)
2528 char *args = av_strdup(arg);
2532 argv[0] = strtok(args, " ");
2533 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2536 i = frame_hook_add(argc, argv);
2539 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2545 static void opt_video_codec(const char *arg)
2547 opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2550 static void opt_subtitle_codec(const char *arg)
2552 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2555 static void opt_map(const char *arg)
2561 m = &stream_maps[nb_stream_maps++];
2563 m->file_index = strtol(arg, (char **)&p, 0);
2567 m->stream_index = strtol(p, (char **)&p, 0);
2570 m->sync_file_index = strtol(p, (char **)&p, 0);
2573 m->sync_stream_index = strtol(p, (char **)&p, 0);
2575 m->sync_file_index = m->file_index;
2576 m->sync_stream_index = m->stream_index;
2580 static void opt_map_meta_data(const char *arg)
2586 m = &meta_data_maps[nb_meta_data_maps++];
2588 m->out_file = strtol(arg, (char **)&p, 0);
2592 m->in_file = strtol(p, (char **)&p, 0);
2595 static int64_t parse_time_or_die(const char *timestr, int is_duration)
2597 int64_t us = parse_date(timestr, is_duration);
2598 if (us == INT64_MIN) {
2599 fprintf(stderr, "Invalid %s specification: %s\n",
2600 is_duration ? "duration" : "date", timestr);
2606 static void opt_recording_time(const char *arg)
2608 recording_time = parse_time_or_die(arg, 1);
2611 static void opt_start_time(const char *arg)
2613 start_time = parse_time_or_die(arg, 1);
2616 static void opt_rec_timestamp(const char *arg)
2618 rec_timestamp = parse_time_or_die(arg, 0) / 1000000;
2621 static void opt_input_ts_offset(const char *arg)
2623 input_ts_offset = parse_time_or_die(arg, 1);
2626 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2628 char *codec_string = encoder ? "encoder" : "decoder";
2632 return CODEC_ID_NONE;
2634 avcodec_find_encoder_by_name(name) :
2635 avcodec_find_decoder_by_name(name);
2637 av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2640 if(codec->type != type) {
2641 av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2647 static void opt_input_file(const char *filename)
2649 AVFormatContext *ic;
2650 AVFormatParameters params, *ap = ¶ms;
2651 int err, i, ret, rfps, rfps_base;
2654 if (!strcmp(filename, "-"))
2657 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2658 !strcmp( filename, "/dev/stdin" );
2660 /* get default parameters from command line */
2661 ic = av_alloc_format_context();
2663 memset(ap, 0, sizeof(*ap));
2664 ap->prealloced_context = 1;
2665 ap->sample_rate = audio_sample_rate;
2666 ap->channels = audio_channels;
2667 ap->time_base.den = frame_rate.num;
2668 ap->time_base.num = frame_rate.den;
2669 ap->width = frame_width + frame_padleft + frame_padright;
2670 ap->height = frame_height + frame_padtop + frame_padbottom;
2671 ap->pix_fmt = frame_pix_fmt;
2672 ap->channel = video_channel;
2673 ap->standard = video_standard;
2674 ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2675 ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2676 if(pgmyuv_compatibility_hack)
2677 ap->video_codec_id= CODEC_ID_PGMYUV;
2679 for(i=0; i<opt_name_count; i++){
2680 const AVOption *opt;
2681 double d= av_get_double(avformat_opts, opt_names[i], &opt);
2682 if(!isnan(d) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2683 av_set_double(ic, opt_names[i], d);
2685 /* open the input file with generic libav function */
2686 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2688 print_error(filename, err);
2693 for(i=0; i<ic->nb_programs; i++)
2694 if(ic->programs[i]->id != opt_programid)
2695 ic->programs[i]->discard = AVDISCARD_ALL;
2698 ic->loop_input = loop_input;
2700 /* If not enough info to get the stream parameters, we decode the
2701 first frames to get it. (used in mpeg case for example) */
2702 ret = av_find_stream_info(ic);
2703 if (ret < 0 && verbose >= 0) {
2704 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2708 timestamp = start_time;
2709 /* add the stream start time */
2710 if (ic->start_time != AV_NOPTS_VALUE)
2711 timestamp += ic->start_time;
2713 /* if seeking requested, we execute it */
2714 if (start_time != 0) {
2715 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2717 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2718 filename, (double)timestamp / AV_TIME_BASE);
2720 /* reset seek info */
2724 /* update the current parameters so that they match the one of the input stream */
2725 for(i=0;i<ic->nb_streams;i++) {
2727 AVCodecContext *enc = ic->streams[i]->codec;
2729 avcodec_thread_init(enc, thread_count);
2730 enc->thread_count= thread_count;
2731 switch(enc->codec_type) {
2732 case CODEC_TYPE_AUDIO:
2733 for(j=0; j<opt_name_count; j++){
2734 const AVOption *opt;
2735 double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[j], &opt);
2736 if(!isnan(d) && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2737 av_set_double(enc, opt_names[j], d);
2739 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2740 audio_channels = enc->channels;
2741 audio_sample_rate = enc->sample_rate;
2743 ic->streams[i]->discard= AVDISCARD_ALL;
2745 case CODEC_TYPE_VIDEO:
2746 for(j=0; j<opt_name_count; j++){
2747 const AVOption *opt;
2748 double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[j], &opt);
2749 if(!isnan(d) && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2750 av_set_double(enc, opt_names[j], d);
2752 frame_height = enc->height;
2753 frame_width = enc->width;
2754 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2755 frame_pix_fmt = enc->pix_fmt;
2756 rfps = ic->streams[i]->r_frame_rate.num;
2757 rfps_base = ic->streams[i]->r_frame_rate.den;
2758 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2760 enc->debug |= FF_DEBUG_MV;
2762 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2765 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2766 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2768 (float)rfps / rfps_base, rfps, rfps_base);
2770 /* update the current frame rate to match the stream frame rate */
2771 frame_rate.num = rfps;
2772 frame_rate.den = rfps_base;
2774 enc->rate_emu = rate_emu;
2776 ic->streams[i]->discard= AVDISCARD_ALL;
2777 else if(video_discard)
2778 ic->streams[i]->discard= video_discard;
2780 case CODEC_TYPE_DATA:
2782 case CODEC_TYPE_SUBTITLE:
2783 if(subtitle_disable)
2784 ic->streams[i]->discard = AVDISCARD_ALL;
2786 case CODEC_TYPE_UNKNOWN:
2793 input_files[nb_input_files] = ic;
2794 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2795 /* dump the file content */
2797 dump_format(ic, nb_input_files, filename, 0);
2800 file_iformat = NULL;
2801 file_oformat = NULL;
2808 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2809 int *has_subtitle_ptr)
2811 int has_video, has_audio, has_subtitle, i, j;
2812 AVFormatContext *ic;
2817 for(j=0;j<nb_input_files;j++) {
2818 ic = input_files[j];
2819 for(i=0;i<ic->nb_streams;i++) {
2820 AVCodecContext *enc = ic->streams[i]->codec;
2821 switch(enc->codec_type) {
2822 case CODEC_TYPE_AUDIO:
2825 case CODEC_TYPE_VIDEO:
2828 case CODEC_TYPE_SUBTITLE:
2831 case CODEC_TYPE_DATA:
2832 case CODEC_TYPE_UNKNOWN:
2839 *has_video_ptr = has_video;
2840 *has_audio_ptr = has_audio;
2841 *has_subtitle_ptr = has_subtitle;
2844 static void new_video_stream(AVFormatContext *oc)
2847 AVCodecContext *video_enc;
2850 st = av_new_stream(oc, oc->nb_streams);
2852 fprintf(stderr, "Could not alloc stream\n");
2855 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2856 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2857 video_bitstream_filters= NULL;
2860 avcodec_thread_init(st->codec, thread_count);
2862 video_enc = st->codec;
2865 video_enc->codec_tag= video_codec_tag;
2867 if( (video_global_header&1)
2868 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2869 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2870 avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2872 if(video_global_header&2){
2873 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2874 avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2877 if (video_stream_copy) {
2878 st->stream_copy = 1;
2879 video_enc->codec_type = CODEC_TYPE_VIDEO;
2885 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2886 if (video_codec_name)
2887 codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
2889 video_enc->codec_id = codec_id;
2890 codec = avcodec_find_encoder(codec_id);
2892 for(i=0; i<opt_name_count; i++){
2893 const AVOption *opt;
2894 double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt);
2895 if(!isnan(d) && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2896 av_set_double(video_enc, opt_names[i], d);
2899 video_enc->time_base.den = frame_rate.num;
2900 video_enc->time_base.num = frame_rate.den;
2901 if(codec && codec->supported_framerates){
2902 const AVRational *p= codec->supported_framerates;
2903 AVRational req= (AVRational){frame_rate.num, frame_rate.den};
2904 const AVRational *best=NULL;
2905 AVRational best_error= (AVRational){INT_MAX, 1};
2906 for(; p->den!=0; p++){
2907 AVRational error= av_sub_q(req, *p);
2908 if(error.num <0) error.num *= -1;
2909 if(av_cmp_q(error, best_error) < 0){
2914 video_enc->time_base.den= best->num;
2915 video_enc->time_base.num= best->den;
2918 video_enc->width = frame_width + frame_padright + frame_padleft;
2919 video_enc->height = frame_height + frame_padtop + frame_padbottom;
2920 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2921 video_enc->pix_fmt = frame_pix_fmt;
2923 if(codec && codec->pix_fmts){
2924 const enum PixelFormat *p= codec->pix_fmts;
2926 if(*p == video_enc->pix_fmt)
2930 video_enc->pix_fmt = codec->pix_fmts[0];
2934 video_enc->gop_size = 0;
2935 if (video_qscale || same_quality) {
2936 video_enc->flags |= CODEC_FLAG_QSCALE;
2937 video_enc->global_quality=
2938 st->quality = FF_QP2LAMBDA * video_qscale;
2942 video_enc->intra_matrix = intra_matrix;
2944 video_enc->inter_matrix = inter_matrix;
2946 video_enc->max_qdiff = video_qdiff;
2947 video_enc->rc_eq = video_rc_eq;
2948 video_enc->thread_count = thread_count;
2949 p= video_rc_override_string;
2952 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2954 fprintf(stderr, "error parsing rc_override\n");
2957 video_enc->rc_override=
2958 av_realloc(video_enc->rc_override,
2959 sizeof(RcOverride)*(i+1));
2960 video_enc->rc_override[i].start_frame= start;
2961 video_enc->rc_override[i].end_frame = end;
2963 video_enc->rc_override[i].qscale= q;
2964 video_enc->rc_override[i].quality_factor= 1.0;
2967 video_enc->rc_override[i].qscale= 0;
2968 video_enc->rc_override[i].quality_factor= -q/100.0;
2973 video_enc->rc_override_count=i;
2974 if (!video_enc->rc_initial_buffer_occupancy)
2975 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2976 video_enc->me_threshold= me_threshold;
2977 video_enc->intra_dc_precision= intra_dc_precision - 8;
2978 video_enc->strict_std_compliance = strict;
2981 video_enc->flags|= CODEC_FLAG_PSNR;
2986 video_enc->flags |= CODEC_FLAG_PASS1;
2988 video_enc->flags |= CODEC_FLAG_PASS2;
2993 /* reset some key parameters */
2995 av_freep(&video_codec_name);
2996 video_stream_copy = 0;
2999 static void new_audio_stream(AVFormatContext *oc)
3002 AVCodecContext *audio_enc;
3005 st = av_new_stream(oc, oc->nb_streams);
3007 fprintf(stderr, "Could not alloc stream\n");
3010 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3012 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3013 audio_bitstream_filters= NULL;
3016 avcodec_thread_init(st->codec, thread_count);
3018 audio_enc = st->codec;
3019 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3020 audio_enc->strict_std_compliance = strict;
3023 audio_enc->codec_tag= audio_codec_tag;
3025 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3026 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3027 avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3029 if (audio_stream_copy) {
3030 st->stream_copy = 1;
3031 audio_enc->channels = audio_channels;
3033 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3035 for(i=0; i<opt_name_count; i++){
3036 const AVOption *opt;
3037 double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt);
3038 if(!isnan(d) && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3039 av_set_double(audio_enc, opt_names[i], d);
3042 if (audio_codec_name)
3043 codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3044 audio_enc->codec_id = codec_id;
3046 if (audio_qscale > QSCALE_NONE) {
3047 audio_enc->flags |= CODEC_FLAG_QSCALE;
3048 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3050 audio_enc->thread_count = thread_count;
3051 audio_enc->channels = audio_channels;
3053 audio_enc->sample_rate = audio_sample_rate;
3054 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3055 if (audio_language) {
3056 av_strlcpy(st->language, audio_language, sizeof(st->language));
3057 av_free(audio_language);
3058 audio_language = NULL;
3061 /* reset some key parameters */
3063 av_freep(&audio_codec_name);
3064 audio_stream_copy = 0;
3067 static void new_subtitle_stream(AVFormatContext *oc)
3070 AVCodecContext *subtitle_enc;
3073 st = av_new_stream(oc, oc->nb_streams);
3075 fprintf(stderr, "Could not alloc stream\n");
3078 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3080 subtitle_enc = st->codec;
3081 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3082 if (subtitle_stream_copy) {
3083 st->stream_copy = 1;
3085 for(i=0; i<opt_name_count; i++){
3086 const AVOption *opt;
3087 double d= av_get_double(avctx_opts[CODEC_TYPE_SUBTITLE], opt_names[i], &opt);
3088 if(!isnan(d) && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3089 av_set_double(subtitle_enc, opt_names[i], d);
3091 subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3094 if (subtitle_language) {
3095 av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3096 av_free(subtitle_language);
3097 subtitle_language = NULL;
3100 subtitle_disable = 0;
3101 av_freep(&subtitle_codec_name);
3102 subtitle_stream_copy = 0;
3105 static void opt_new_audio_stream(void)
3107 AVFormatContext *oc;
3108 if (nb_output_files <= 0) {
3109 fprintf(stderr, "At least one output file must be specified\n");
3112 oc = output_files[nb_output_files - 1];
3113 new_audio_stream(oc);
3116 static void opt_new_video_stream(void)
3118 AVFormatContext *oc;
3119 if (nb_output_files <= 0) {
3120 fprintf(stderr, "At least one output file must be specified\n");
3123 oc = output_files[nb_output_files - 1];
3124 new_video_stream(oc);
3127 static void opt_new_subtitle_stream(void)
3129 AVFormatContext *oc;
3130 if (nb_output_files <= 0) {
3131 fprintf(stderr, "At least one output file must be specified\n");
3134 oc = output_files[nb_output_files - 1];
3135 new_subtitle_stream(oc);
3138 static void opt_output_file(const char *filename)
3140 AVFormatContext *oc;
3141 int use_video, use_audio, use_subtitle;
3142 int input_has_video, input_has_audio, input_has_subtitle, i;
3143 AVFormatParameters params, *ap = ¶ms;
3145 if (!strcmp(filename, "-"))
3148 oc = av_alloc_format_context();
3150 if (!file_oformat) {
3151 file_oformat = guess_format(NULL, filename, NULL);
3152 if (!file_oformat) {
3153 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3159 oc->oformat = file_oformat;
3160 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3162 if (!strcmp(file_oformat->name, "ffm") &&
3163 av_strstart(filename, "http:", NULL)) {
3164 /* special case for files sent to ffserver: we get the stream
3165 parameters from ffserver */
3166 if (read_ffserver_streams(oc, filename) < 0) {
3167 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3171 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3172 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3173 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3175 /* disable if no corresponding type found and at least one
3177 if (nb_input_files > 0) {
3178 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3179 &input_has_subtitle);
3180 if (!input_has_video)
3182 if (!input_has_audio)
3184 if (!input_has_subtitle)
3188 /* manual disable */
3189 if (audio_disable) {
3192 if (video_disable) {
3195 if (subtitle_disable) {
3200 new_video_stream(oc);
3204 new_audio_stream(oc);
3208 new_subtitle_stream(oc);
3211 oc->timestamp = rec_timestamp;
3214 av_strlcpy(oc->title, str_title, sizeof(oc->title));
3216 av_strlcpy(oc->author, str_author, sizeof(oc->author));
3218 av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3220 av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3222 av_strlcpy(oc->album, str_album, sizeof(oc->album));
3225 output_files[nb_output_files++] = oc;
3227 /* check filename in case of an image number is expected */
3228 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3229 if (!av_filename_number_test(oc->filename)) {
3230 print_error(oc->filename, AVERROR_NUMEXPECTED);
3235 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3236 /* test if it already exists to avoid loosing precious files */
3237 if (!file_overwrite &&
3238 (strchr(filename, ':') == NULL ||
3239 av_strstart(filename, "file:", NULL))) {
3240 if (url_exist(filename)) {
3243 if ( !using_stdin ) {
3244 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3247 if (toupper(c) != 'Y') {
3248 fprintf(stderr, "Not overwriting - exiting\n");
3253 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3260 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3261 fprintf(stderr, "Could not open '%s'\n", filename);
3266 memset(ap, 0, sizeof(*ap));
3267 if (av_set_parameters(oc, ap) < 0) {
3268 fprintf(stderr, "%s: Invalid encoding parameters\n",
3273 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3274 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3275 oc->loop_output = loop_output;
3277 for(i=0; i<opt_name_count; i++){
3278 const AVOption *opt;
3279 double d = av_get_double(avformat_opts, opt_names[i], &opt);
3280 if(!isnan(d) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3281 av_set_double(oc, opt_names[i], d);
3284 /* reset some options */
3285 file_oformat = NULL;
3286 file_iformat = NULL;
3289 /* same option as mencoder */
3290 static void opt_pass(const char *pass_str)
3293 pass = atoi(pass_str);
3294 if (pass != 1 && pass != 2) {
3295 fprintf(stderr, "pass number can be only 1 or 2\n");
3301 static int64_t getutime(void)
3303 #ifdef HAVE_GETRUSAGE
3304 struct rusage rusage;
3306 getrusage(RUSAGE_SELF, &rusage);
3307 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3308 #elif defined(HAVE_GETPROCESSTIMES)
3310 FILETIME c, e, k, u;
3311 proc = GetCurrentProcess();
3312 GetProcessTimes(proc, &c, &e, &k, &u);
3313 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3315 return av_gettime();
3319 static void opt_show_formats(void)
3321 AVInputFormat *ifmt;
3322 AVOutputFormat *ofmt;
3325 const char *last_name;
3327 printf("File formats:\n");
3332 const char *name=NULL;
3333 const char *long_name=NULL;
3335 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3336 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3337 strcmp(ofmt->name, last_name)>0){
3339 long_name= ofmt->long_name;
3343 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3344 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3345 strcmp(ifmt->name, last_name)>0){
3347 long_name= ifmt->long_name;
3350 if(name && strcmp(ifmt->name, name)==0)
3362 long_name ? long_name:" ");
3366 printf("Codecs:\n");
3372 const char *type_str;
3375 for(p = first_avcodec; p != NULL; p = p->next) {
3376 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3377 strcmp(p->name, last_name)>0){
3379 decode= encode= cap=0;
3381 if(p2 && strcmp(p->name, p2->name)==0){
3382 if(p->decode) decode=1;
3383 if(p->encode) encode=1;
3384 cap |= p->capabilities;
3389 last_name= p2->name;
3392 case CODEC_TYPE_VIDEO:
3395 case CODEC_TYPE_AUDIO:
3398 case CODEC_TYPE_SUBTITLE:
3407 decode ? "D": (/*p2->decoder ? "d":*/" "),
3410 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3411 cap & CODEC_CAP_DR1 ? "D":" ",
3412 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3414 /* if(p2->decoder && decode==0)
3415 printf(" use %s for decoding", p2->decoder->name);*/
3420 printf("Supported file protocols:\n");
3421 for(up = first_protocol; up != NULL; up = up->next)
3422 printf(" %s:", up->name);
3425 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3428 "Note, the names of encoders and decoders do not always match, so there are\n"
3429 "several cases where the above table shows encoder only or decoder only entries\n"
3430 "even though both encoding and decoding are supported. For example, the h263\n"
3431 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
3436 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3439 const char *p = str;
3446 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3453 static void opt_inter_matrix(const char *arg)
3455 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3456 parse_matrix_coeffs(inter_matrix, arg);
3459 static void opt_intra_matrix(const char *arg)
3461 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3462 parse_matrix_coeffs(intra_matrix, arg);
3466 * Trivial log callback.
3467 * Only suitable for show_help and similar since it lacks prefix handling.
3469 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3471 vfprintf(stdout, fmt, vl);
3474 static void show_help(void)
3476 av_log_set_callback(log_callback_help);
3477 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3478 "Hyper fast Audio and Video encoder\n");
3480 show_help_options(options, "Main options:\n",
3481 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3482 show_help_options(options, "\nVideo options:\n",
3483 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3485 show_help_options(options, "\nAdvanced Video options:\n",
3486 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3487 OPT_VIDEO | OPT_EXPERT);
3488 show_help_options(options, "\nAudio options:\n",
3489 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3491 show_help_options(options, "\nAdvanced Audio options:\n",
3492 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3493 OPT_AUDIO | OPT_EXPERT);
3494 show_help_options(options, "\nSubtitle options:\n",
3495 OPT_SUBTITLE | OPT_GRAB,
3497 show_help_options(options, "\nAudio/Video grab options:\n",
3500 show_help_options(options, "\nAdvanced options:\n",
3501 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3503 av_opt_show(avctx_opts[0], NULL);
3504 av_opt_show(avformat_opts, NULL);
3505 av_opt_show(sws_opts, NULL);
3508 static void opt_show_help(void)
3514 static void opt_target(const char *arg)
3517 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3519 if(!strncmp(arg, "pal-", 4)) {
3522 } else if(!strncmp(arg, "ntsc-", 5)) {
3525 } else if(!strncmp(arg, "film-", 5)) {
3530 /* Calculate FR via float to avoid int overflow */
3531 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3534 } else if((fr == 29970) || (fr == 23976)) {
3537 /* Try to determine PAL/NTSC by peeking in the input files */
3538 if(nb_input_files) {
3540 for(j = 0; j < nb_input_files; j++) {
3541 for(i = 0; i < input_files[j]->nb_streams; i++) {
3542 AVCodecContext *c = input_files[j]->streams[i]->codec;
3543 if(c->codec_type != CODEC_TYPE_VIDEO)
3545 fr = c->time_base.den * 1000 / c->time_base.num;
3549 } else if((fr == 29970) || (fr == 23976)) {
3559 if(verbose && norm >= 0)
3560 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3564 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3565 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3566 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3570 if(!strcmp(arg, "vcd")) {
3572 opt_video_codec("mpeg1video");
3573 opt_audio_codec("mp2");
3576 opt_frame_size(norm ? "352x240" : "352x288");
3577 opt_frame_rate(frame_rates[norm]);
3578 opt_default("gop", norm ? "18" : "15");
3580 opt_default("b", "1150000");
3581 opt_default("maxrate", "1150000");
3582 opt_default("minrate", "1150000");
3583 opt_default("bufsize", "327680"); // 40*1024*8;
3585 opt_default("ab", "224000");
3586 audio_sample_rate = 44100;
3589 opt_default("packetsize", "2324");
3590 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3592 /* We have to offset the PTS, so that it is consistent with the SCR.
3593 SCR starts at 36000, but the first two packs contain only padding
3594 and the first pack from the other stream, respectively, may also have
3595 been written before.
3596 So the real data starts at SCR 36000+3*1200. */
3597 mux_preload= (36000+3*1200) / 90000.0; //0.44
3598 } else if(!strcmp(arg, "svcd")) {
3600 opt_video_codec("mpeg2video");
3601 opt_audio_codec("mp2");
3604 opt_frame_size(norm ? "480x480" : "480x576");
3605 opt_frame_rate(frame_rates[norm]);
3606 opt_default("gop", norm ? "18" : "15");
3608 opt_default("b", "2040000");
3609 opt_default("maxrate", "2516000");
3610 opt_default("minrate", "0"); //1145000;
3611 opt_default("bufsize", "1835008"); //224*1024*8;
3612 opt_default("flags", "+SCAN_OFFSET");
3615 opt_default("ab", "224000");
3616 audio_sample_rate = 44100;
3618 opt_default("packetsize", "2324");
3620 } else if(!strcmp(arg, "dvd")) {
3622 opt_video_codec("mpeg2video");
3623 opt_audio_codec("ac3");
3626 opt_frame_size(norm ? "720x480" : "720x576");
3627 opt_frame_rate(frame_rates[norm]);
3628 opt_default("gop", norm ? "18" : "15");
3630 opt_default("b", "6000000");
3631 opt_default("maxrate", "9000000");
3632 opt_default("minrate", "0"); //1500000;
3633 opt_default("bufsize", "1835008"); //224*1024*8;
3635 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3636 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3638 opt_default("ab", "448000");
3639 audio_sample_rate = 48000;
3641 } else if(!strncmp(arg, "dv", 2)) {
3645 opt_frame_size(norm ? "720x480" : "720x576");
3646 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3647 (norm ? "yuv411p" : "yuv420p"));
3648 opt_frame_rate(frame_rates[norm]);
3650 audio_sample_rate = 48000;
3654 fprintf(stderr, "Unknown target: %s\n", arg);
3659 static void opt_vstats_file (const char *arg)
3661 av_free (vstats_filename);
3662 vstats_filename=av_strdup (arg);
3665 static void opt_vstats (void)
3668 time_t today2 = time(NULL);
3669 struct tm *today = localtime(&today2);
3671 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3673 opt_vstats_file(filename);
3676 static void opt_bsf(const char *opt, const char *arg)
3678 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3679 AVBitStreamFilterContext **bsfp;
3682 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3686 bsfp= *opt == 'v' ? &video_bitstream_filters : &audio_bitstream_filters;
3688 bsfp= &(*bsfp)->next;
3693 static void opt_show_license(void)
3699 static void opt_show_version(void)
3701 show_version(program_name);
3705 const OptionDef options[] = {
3707 { "L", 0, {(void*)opt_show_license}, "show license" },
3708 { "h", 0, {(void*)opt_show_help}, "show help" },
3709 { "version", 0, {(void*)opt_show_version}, "show version" },
3710 { "formats", 0, {(void*)opt_show_formats}, "show available formats, codecs, protocols, ..." },
3711 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3712 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3713 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3714 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3715 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3716 { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3717 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3718 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3719 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3720 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3721 { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3722 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3723 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3724 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3725 { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3726 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3727 "add timings for benchmarking" },
3728 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3729 "dump each input packet" },
3730 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3731 "when dumping packets, also dump the payload" },
3732 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3733 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3734 { "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)", "" },
3735 { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3736 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3737 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3738 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3739 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3740 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "" },
3741 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3742 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3743 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3744 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
3745 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3748 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "" },
3749 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "" },
3750 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3751 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3752 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3753 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3754 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3755 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format, 'list' as argument shows all the pixel formats supported", "format" },
3756 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3757 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3758 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3759 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3760 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3761 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3762 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3763 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3764 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3765 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3766 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3767 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3768 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3769 { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantizer scale (VBR)", "q" },
3770 { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3771 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3772 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3773 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "" },
3774 { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3775 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3776 "use same video quality as source (implies VBR)" },
3777 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3778 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3779 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3780 "deinterlace pictures" },
3781 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3782 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3783 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3785 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3787 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3788 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3789 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3790 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3791 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3792 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3793 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3796 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "" },
3797 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3798 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3799 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3800 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3801 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3802 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3803 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3804 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3805 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3806 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3808 /* subtitle options */
3809 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3810 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3811 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3812 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3815 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3816 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3817 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3820 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3821 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3823 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" },
3824 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" },
3826 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3830 static int av_exit()
3835 for(i=0;i<nb_output_files;i++) {
3836 /* maybe av_close_output_file ??? */
3837 AVFormatContext *s = output_files[i];
3839 if (!(s->oformat->flags & AVFMT_NOFILE))
3841 for(j=0;j<s->nb_streams;j++) {
3842 av_free(s->streams[j]->codec);
3843 av_free(s->streams[j]);
3847 for(i=0;i<nb_input_files;i++)
3848 av_close_input_file(input_files[i]);
3852 av_free(intra_matrix);
3853 av_free(inter_matrix);
3856 fclose(vstats_file);
3857 av_free(vstats_filename);
3861 av_free(video_codec_name);
3862 av_free(audio_codec_name);
3863 av_free(subtitle_codec_name);
3865 av_free(video_standard);
3867 #ifdef CONFIG_POWERPC_PERF
3868 extern void powerpc_display_perf_report(void);
3869 powerpc_display_perf_report();
3870 #endif /* CONFIG_POWERPC_PERF */
3872 if (received_sigterm) {
3874 "Received signal %d: terminating.\n",
3875 (int) received_sigterm);
3879 exit(0); /* not all OS-es handle main() return value */
3883 int main(int argc, char **argv)
3888 avcodec_register_all();
3889 avdevice_register_all();
3892 for(i=0; i<CODEC_TYPE_NB; i++){
3893 avctx_opts[i]= avcodec_alloc_context2(i);
3895 avformat_opts = av_alloc_format_context();
3896 sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3898 show_banner(program_name, program_birth_year);
3905 parse_options(argc, argv, options, opt_output_file);
3907 /* file converter / grab */
3908 if (nb_output_files <= 0) {
3909 fprintf(stderr, "Must supply at least one output file\n");
3913 if (nb_input_files == 0) {
3914 fprintf(stderr, "Must supply at least one input file\n");
3919 av_encode(output_files, nb_output_files, input_files, nb_input_files,
3920 stream_maps, nb_stream_maps);
3921 ti = getutime() - ti;
3923 printf("bench: utime=%0.3fs\n", ti / 1000000.0);