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) {0,0};
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 const char *video_rc_override_string=NULL;
129 static int video_disable = 0;
130 static int video_discard = 0;
131 static char *video_codec_name = NULL;
132 static int video_codec_tag = 0;
133 static int same_quality = 0;
134 static int do_deinterlace = 0;
135 static int strict = 0;
136 static int top_field_first = -1;
137 static int me_threshold = 0;
138 static int intra_dc_precision = 8;
139 static int loop_input = 0;
140 static int loop_output = AVFMT_NOOUTPUTLOOP;
141 static int qp_hist = 0;
143 static int intra_only = 0;
144 static int audio_sample_rate = 44100;
145 #define QSCALE_NONE -99999
146 static float audio_qscale = QSCALE_NONE;
147 static int audio_disable = 0;
148 static int audio_channels = 1;
149 static char *audio_codec_name = NULL;
150 static int audio_codec_tag = 0;
151 static char *audio_language = NULL;
153 static int subtitle_disable = 0;
154 static char *subtitle_codec_name = NULL;
155 static char *subtitle_language = NULL;
157 static float mux_preload= 0.5;
158 static float mux_max_delay= 0.7;
160 static int64_t recording_time = 0;
161 static int64_t start_time = 0;
162 static int64_t rec_timestamp = 0;
163 static int64_t input_ts_offset = 0;
164 static int file_overwrite = 0;
165 static char *str_title = NULL;
166 static char *str_author = NULL;
167 static char *str_copyright = NULL;
168 static char *str_comment = NULL;
169 static char *str_genre = 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;
448 AVCodecContext *dec= ist->st->codec;
450 /* SC: dynamic allocation of buffers */
452 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
454 audio_out = av_malloc(audio_out_size);
455 if (!audio_buf || !audio_out)
456 return; /* Should signal an error ! */
458 if (enc->channels != dec->channels)
459 ost->audio_resample = 1;
461 if (ost->audio_resample && !ost->resample) {
462 ost->resample = audio_resample_init(enc->channels, dec->channels,
463 enc->sample_rate, dec->sample_rate);
464 if (!ost->resample) {
465 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
466 dec->channels, dec->sample_rate,
467 enc->channels, enc->sample_rate);
472 if(audio_sync_method){
473 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
474 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
475 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
476 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
478 //FIXME resample delay
479 if(fabs(delta) > 50){
480 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
482 byte_delta= FFMAX(byte_delta, -size);
486 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
491 static uint8_t *input_tmp= NULL;
492 input_tmp= av_realloc(input_tmp, byte_delta + size);
494 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
497 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
499 memset(input_tmp, 0, byte_delta);
500 memcpy(input_tmp + byte_delta, buf, size);
504 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
506 }else if(audio_sync_method>1){
507 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
508 assert(ost->audio_resample);
510 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
511 // fprintf(stderr, "drift:%f len:%d opts:%"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));
512 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
516 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
517 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
519 if (ost->audio_resample) {
521 size_out = audio_resample(ost->resample,
522 (short *)buftmp, (short *)buf,
523 size / (ist->st->codec->channels * 2));
524 size_out = size_out * enc->channels * 2;
530 /* now encode as many frames as possible */
531 if (enc->frame_size > 1) {
532 /* output resampled raw samples */
533 av_fifo_write(&ost->fifo, buftmp, size_out);
535 frame_bytes = enc->frame_size * 2 * enc->channels;
537 while (av_fifo_read(&ost->fifo, audio_buf, frame_bytes) == 0) {
539 av_init_packet(&pkt);
541 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
544 pkt.stream_index= ost->index;
547 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
548 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
549 pkt.flags |= PKT_FLAG_KEY;
550 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
552 ost->sync_opts += enc->frame_size;
556 av_init_packet(&pkt);
558 ost->sync_opts += size_out / (2 * enc->channels);
560 /* output a pcm frame */
561 /* XXX: change encoding codec API to avoid this ? */
562 switch(enc->codec->id) {
563 case CODEC_ID_PCM_S32LE:
564 case CODEC_ID_PCM_S32BE:
565 case CODEC_ID_PCM_U32LE:
566 case CODEC_ID_PCM_U32BE:
567 size_out = size_out << 1;
569 case CODEC_ID_PCM_S24LE:
570 case CODEC_ID_PCM_S24BE:
571 case CODEC_ID_PCM_U24LE:
572 case CODEC_ID_PCM_U24BE:
573 case CODEC_ID_PCM_S24DAUD:
574 size_out = size_out / 2 * 3;
576 case CODEC_ID_PCM_S16LE:
577 case CODEC_ID_PCM_S16BE:
578 case CODEC_ID_PCM_U16LE:
579 case CODEC_ID_PCM_U16BE:
582 size_out = size_out >> 1;
585 ret = avcodec_encode_audio(enc, audio_out, size_out,
588 pkt.stream_index= ost->index;
591 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
592 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
593 pkt.flags |= PKT_FLAG_KEY;
594 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
598 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
602 AVPicture picture_tmp;
605 dec = ist->st->codec;
607 /* deinterlace : must be done before any resize */
608 if (do_deinterlace || using_vhook) {
611 /* create temporary picture */
612 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
613 buf = av_malloc(size);
617 picture2 = &picture_tmp;
618 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
621 if(avpicture_deinterlace(picture2, picture,
622 dec->pix_fmt, dec->width, dec->height) < 0) {
623 /* if error, do not deinterlace */
629 av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
636 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,
637 1000000 * ist->pts / AV_TIME_BASE);
639 if (picture != picture2)
640 *picture = *picture2;
644 /* we begin to correct av delay at this threshold */
645 #define AV_DELAY_MAX 0.100
647 static void do_subtitle_out(AVFormatContext *s,
653 static uint8_t *subtitle_out = NULL;
654 int subtitle_out_max_size = 65536;
655 int subtitle_out_size, nb, i;
659 if (pts == AV_NOPTS_VALUE) {
660 fprintf(stderr, "Subtitle packets must have a pts\n");
664 enc = ost->st->codec;
667 subtitle_out = av_malloc(subtitle_out_max_size);
670 /* Note: DVB subtitle need one packet to draw them and one other
671 packet to clear them */
672 /* XXX: signal it in the codec context ? */
673 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
678 for(i = 0; i < nb; i++) {
679 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
680 subtitle_out_max_size, sub);
682 av_init_packet(&pkt);
683 pkt.stream_index = ost->index;
684 pkt.data = subtitle_out;
685 pkt.size = subtitle_out_size;
686 pkt.pts = av_rescale_q(pts, ist->st->time_base, ost->st->time_base);
687 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
688 /* XXX: the pts correction is handled here. Maybe handling
689 it in the codec would be better */
691 pkt.pts += 90 * sub->start_display_time;
693 pkt.pts += 90 * sub->end_display_time;
695 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
699 static int bit_buffer_size= 1024*256;
700 static uint8_t *bit_buffer= NULL;
702 static void do_video_out(AVFormatContext *s,
708 int nb_frames, i, ret;
709 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
710 AVFrame picture_crop_temp, picture_pad_temp;
711 AVCodecContext *enc, *dec;
713 avcodec_get_frame_defaults(&picture_crop_temp);
714 avcodec_get_frame_defaults(&picture_pad_temp);
716 enc = ost->st->codec;
717 dec = ist->st->codec;
719 /* by default, we output a single frame */
724 if(video_sync_method){
726 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
727 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
730 else if (vdelta > 1.1)
731 nb_frames = lrintf(vdelta);
732 //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);
736 fprintf(stderr, "*** drop!\n");
737 }else if (nb_frames > 1) {
738 nb_frames_dup += nb_frames;
740 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
743 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
745 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
749 if (ost->video_crop) {
750 if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
751 av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
754 formatted_picture = &picture_crop_temp;
756 formatted_picture = in_picture;
759 final_picture = formatted_picture;
760 padding_src = formatted_picture;
761 resampling_dst = &ost->pict_tmp;
762 if (ost->video_pad) {
763 final_picture = &ost->pict_tmp;
764 if (ost->video_resample) {
765 if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
766 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
769 resampling_dst = &picture_pad_temp;
773 if (ost->video_resample) {
775 final_picture = &ost->pict_tmp;
776 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
777 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
780 if (ost->video_pad) {
781 av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
782 enc->height, enc->width, enc->pix_fmt,
783 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
786 /* duplicates frame if needed */
787 for(i=0;i<nb_frames;i++) {
789 av_init_packet(&pkt);
790 pkt.stream_index= ost->index;
792 if (s->oformat->flags & AVFMT_RAWPICTURE) {
793 /* raw pictures are written as AVPicture structure to
794 avoid any copies. We support temorarily the older
796 AVFrame* old_frame = enc->coded_frame;
797 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
798 pkt.data= (uint8_t *)final_picture;
799 pkt.size= sizeof(AVPicture);
800 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
801 pkt.flags |= PKT_FLAG_KEY;
803 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
804 enc->coded_frame = old_frame;
808 big_picture= *final_picture;
809 /* better than nothing: use input picture interlaced
811 big_picture.interlaced_frame = in_picture->interlaced_frame;
812 if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
813 if(top_field_first == -1)
814 big_picture.top_field_first = in_picture->top_field_first;
816 big_picture.top_field_first = top_field_first;
819 /* handles sameq here. This is not correct because it may
820 not be a global option */
822 big_picture.quality = ist->st->quality;
824 big_picture.quality = ost->st->quality;
826 big_picture.pict_type = 0;
827 // big_picture.pts = AV_NOPTS_VALUE;
828 big_picture.pts= ost->sync_opts;
829 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
830 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
831 ret = avcodec_encode_video(enc,
832 bit_buffer, bit_buffer_size,
835 fprintf(stderr, "Video encoding failed\n");
838 //enc->frame_number = enc->real_pict_num;
840 pkt.data= bit_buffer;
842 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
843 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
844 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
845 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
846 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
848 if(enc->coded_frame && enc->coded_frame->key_frame)
849 pkt.flags |= PKT_FLAG_KEY;
850 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
852 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
853 // enc->frame_number-1, enc->real_pict_num, ret,
855 /* if two pass, output log */
856 if (ost->logfile && enc->stats_out) {
857 fprintf(ost->logfile, "%s", enc->stats_out);
866 static double psnr(double d){
867 if(d==0) return INFINITY;
868 return -10.0*log(d)/log(10.0);
871 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
876 double ti1, bitrate, avg_bitrate;
878 /* this is executed just the first time do_video_stats is called */
880 vstats_file = fopen(vstats_filename, "w");
887 enc = ost->st->codec;
888 if (enc->codec_type == CODEC_TYPE_VIDEO) {
889 frame_number = ost->frame_number;
890 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
891 if (enc->flags&CODEC_FLAG_PSNR)
892 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
894 fprintf(vstats_file,"f_size= %6d ", frame_size);
895 /* compute pts value */
896 ti1 = ost->sync_opts * av_q2d(enc->time_base);
900 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
901 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
902 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
903 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
904 fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
908 static void print_report(AVFormatContext **output_files,
909 AVOutputStream **ost_table, int nb_ostreams,
914 AVFormatContext *oc, *os;
917 int frame_number, vid, i;
918 double bitrate, ti1, pts;
919 static int64_t last_time = -1;
920 static int qp_histogram[52];
922 if (!is_last_report) {
924 /* display the report every 0.5 seconds */
925 cur_time = av_gettime();
926 if (last_time == -1) {
927 last_time = cur_time;
930 if ((cur_time - last_time) < 500000)
932 last_time = cur_time;
936 oc = output_files[0];
938 total_size = url_fsize(oc->pb);
939 if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
940 total_size= url_ftell(oc->pb);
945 for(i=0;i<nb_ostreams;i++) {
947 os = output_files[ost->file_index];
948 enc = ost->st->codec;
949 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
950 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
951 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
953 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
954 float t = (av_gettime()-timer_start) / 1000000.0;
956 frame_number = ost->frame_number;
957 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
958 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
959 enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
961 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
962 if(qp_hist && enc->coded_frame){
964 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
965 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
968 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
970 if (enc->flags&CODEC_FLAG_PSNR){
972 double error, error_sum=0;
973 double scale, scale_sum=0;
974 char type[3]= {'Y','U','V'};
975 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
978 error= enc->error[j];
979 scale= enc->width*enc->height*255.0*255.0*frame_number;
981 error= enc->coded_frame->error[j];
982 scale= enc->width*enc->height*255.0*255.0;
987 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
989 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
993 /* compute min output value */
994 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
995 if ((pts < ti1) && (pts > 0))
1001 if (verbose || is_last_report) {
1002 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1004 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1005 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1006 (double)total_size / 1024, ti1, bitrate);
1009 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1010 nb_frames_dup, nb_frames_drop);
1013 fprintf(stderr, "%s \r", buf);
1018 if (is_last_report && verbose >= 0){
1019 int64_t raw= audio_size + video_size + extra_size;
1020 fprintf(stderr, "\n");
1021 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1025 100.0*(total_size - raw)/raw
1030 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1031 static int output_packet(AVInputStream *ist, int ist_index,
1032 AVOutputStream **ost_table, int nb_ostreams,
1033 const AVPacket *pkt)
1035 AVFormatContext *os;
1036 AVOutputStream *ost;
1040 int data_size, got_picture;
1042 void *buffer_to_free;
1043 static unsigned int samples_size= 0;
1044 static short *samples= NULL;
1045 AVSubtitle subtitle, *subtitle_to_free;
1049 ist->pts= ist->next_pts; // needed for last packet if vsync=0
1050 } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1051 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1053 // assert(ist->pts == ist->next_pts);
1067 /* decode the packet if needed */
1068 data_buf = NULL; /* fail safe */
1070 subtitle_to_free = NULL;
1071 if (ist->decoding_needed) {
1072 switch(ist->st->codec->codec_type) {
1073 case CODEC_TYPE_AUDIO:{
1075 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE));
1076 data_size= samples_size;
1077 /* XXX: could avoid copy if PCM 16 bits with same
1078 endianness as CPU */
1079 ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1085 /* Some bug in mpeg audio decoder gives */
1086 /* data_size < 0, it seems they are overflows */
1087 if (data_size <= 0) {
1088 /* no audio frame */
1091 data_buf = (uint8_t *)samples;
1092 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1093 (ist->st->codec->sample_rate * ist->st->codec->channels);
1095 case CODEC_TYPE_VIDEO:
1096 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1097 /* XXX: allocate picture correctly */
1098 avcodec_get_frame_defaults(&picture);
1100 ret = avcodec_decode_video(ist->st->codec,
1101 &picture, &got_picture, ptr, len);
1102 ist->st->quality= picture.quality;
1106 /* no picture yet */
1107 goto discard_packet;
1109 if (ist->st->codec->time_base.num != 0) {
1110 ist->next_pts += ((int64_t)AV_TIME_BASE *
1111 ist->st->codec->time_base.num) /
1112 ist->st->codec->time_base.den;
1116 case CODEC_TYPE_SUBTITLE:
1117 ret = avcodec_decode_subtitle(ist->st->codec,
1118 &subtitle, &got_subtitle, ptr, len);
1121 if (!got_subtitle) {
1122 goto discard_packet;
1124 subtitle_to_free = &subtitle;
1131 switch(ist->st->codec->codec_type) {
1132 case CODEC_TYPE_AUDIO:
1133 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1134 ist->st->codec->sample_rate;
1136 case CODEC_TYPE_VIDEO:
1137 if (ist->st->codec->time_base.num != 0) {
1138 ist->next_pts += ((int64_t)AV_TIME_BASE *
1139 ist->st->codec->time_base.num) /
1140 ist->st->codec->time_base.den;
1150 buffer_to_free = NULL;
1151 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1152 pre_process_video_frame(ist, (AVPicture *)&picture,
1156 // preprocess audio (volume)
1157 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1158 if (audio_volume != 256) {
1161 for(i=0;i<(data_size / sizeof(short));i++) {
1162 int v = ((*volp) * audio_volume + 128) >> 8;
1163 if (v < -32768) v = -32768;
1164 if (v > 32767) v = 32767;
1170 /* frame rate emulation */
1171 if (ist->st->codec->rate_emu) {
1172 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1173 int64_t now = av_gettime() - ist->start;
1181 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1182 is the one of the next displayed one */
1183 /* XXX: add mpeg4 too ? */
1184 if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1185 if (ist->st->codec->pict_type != B_TYPE) {
1187 tmp = ist->last_ip_pts;
1188 ist->last_ip_pts = ist->frac_pts.val;
1189 ist->frac_pts.val = tmp;
1193 /* if output time reached then transcode raw format,
1194 encode packets and output them */
1195 if (start_time == 0 || ist->pts >= start_time)
1196 for(i=0;i<nb_ostreams;i++) {
1200 if (ost->source_index == ist_index) {
1201 os = output_files[ost->file_index];
1204 printf("%d: got pts=%0.3f %0.3f\n", i,
1205 (double)pkt->pts / AV_TIME_BASE,
1206 ((double)ist->pts / AV_TIME_BASE) -
1207 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1209 /* set the input output pts pairs */
1210 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1212 if (ost->encoding_needed) {
1213 switch(ost->st->codec->codec_type) {
1214 case CODEC_TYPE_AUDIO:
1215 do_audio_out(os, ost, ist, data_buf, data_size);
1217 case CODEC_TYPE_VIDEO:
1218 do_video_out(os, ost, ist, &picture, &frame_size);
1219 video_size += frame_size;
1220 if (vstats_filename && frame_size)
1221 do_video_stats(os, ost, frame_size);
1223 case CODEC_TYPE_SUBTITLE:
1224 do_subtitle_out(os, ost, ist, &subtitle,
1231 AVFrame avframe; //FIXME/XXX remove this
1233 av_init_packet(&opkt);
1235 if (!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY))
1238 /* no reencoding needed : output the packet directly */
1239 /* force the input stream PTS */
1241 avcodec_get_frame_defaults(&avframe);
1242 ost->st->codec->coded_frame= &avframe;
1243 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1245 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1246 audio_size += data_size;
1247 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1248 video_size += data_size;
1252 opkt.stream_index= ost->index;
1253 if(pkt->pts != AV_NOPTS_VALUE)
1254 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1256 opkt.pts= AV_NOPTS_VALUE;
1258 if (pkt->dts == AV_NOPTS_VALUE)
1259 opkt.dts = av_rescale_q(ist->next_pts, AV_TIME_BASE_Q, ost->st->time_base);
1261 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1263 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1264 opkt.flags= pkt->flags;
1266 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1267 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1268 opkt.destruct= av_destruct_packet;
1270 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1271 ost->st->codec->frame_number++;
1272 ost->frame_number++;
1273 av_free_packet(&opkt);
1277 av_free(buffer_to_free);
1278 /* XXX: allocate the subtitles in the codec ? */
1279 if (subtitle_to_free) {
1280 if (subtitle_to_free->rects != NULL) {
1281 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1282 av_free(subtitle_to_free->rects[i].bitmap);
1283 av_free(subtitle_to_free->rects[i].rgba_palette);
1285 av_freep(&subtitle_to_free->rects);
1287 subtitle_to_free->num_rects = 0;
1288 subtitle_to_free = NULL;
1295 for(i=0;i<nb_ostreams;i++) {
1297 if (ost->source_index == ist_index) {
1298 AVCodecContext *enc= ost->st->codec;
1299 os = output_files[ost->file_index];
1301 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1303 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1306 if (ost->encoding_needed) {
1310 av_init_packet(&pkt);
1311 pkt.stream_index= ost->index;
1313 switch(ost->st->codec->codec_type) {
1314 case CODEC_TYPE_AUDIO:
1315 fifo_bytes = av_fifo_size(&ost->fifo);
1317 /* encode any samples remaining in fifo */
1318 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1319 int fs_tmp = enc->frame_size;
1320 enc->frame_size = fifo_bytes / (2 * enc->channels);
1321 if(av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes) == 0) {
1322 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1324 enc->frame_size = fs_tmp;
1327 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1330 pkt.flags |= PKT_FLAG_KEY;
1332 case CODEC_TYPE_VIDEO:
1333 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1335 if(enc->coded_frame && enc->coded_frame->key_frame)
1336 pkt.flags |= PKT_FLAG_KEY;
1337 if (ost->logfile && enc->stats_out) {
1338 fprintf(ost->logfile, "%s", enc->stats_out);
1347 pkt.data= bit_buffer;
1349 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1350 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1351 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1363 static void print_sdp(AVFormatContext **avc, int n)
1367 avf_sdp_create(avc, n, sdp, sizeof(sdp));
1368 printf("SDP:\n%s\n", sdp);
1371 static int stream_index_from_inputs(AVFormatContext **input_files,
1373 AVInputFile *file_table,
1374 AVInputStream **ist_table,
1375 enum CodecType type,
1379 for(z=0; z<nb_input_files; z++) {
1380 AVFormatContext *ic = input_files[z];
1381 for(p=0; p<ic->nb_programs; p++) {
1382 AVProgram *program = ic->programs[p];
1383 if(program->id != programid)
1385 for(q=0; q<program->nb_stream_indexes; q++) {
1386 int sidx = program->stream_index[q];
1387 int ris = file_table[z].ist_index + sidx;
1388 if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1398 * The following code is the main loop of the file converter
1400 static int av_encode(AVFormatContext **output_files,
1401 int nb_output_files,
1402 AVFormatContext **input_files,
1404 AVStreamMap *stream_maps, int nb_stream_maps)
1406 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1407 AVFormatContext *is, *os;
1408 AVCodecContext *codec, *icodec;
1409 AVOutputStream *ost, **ost_table = NULL;
1410 AVInputStream *ist, **ist_table = NULL;
1411 AVInputFile *file_table;
1415 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1419 /* input stream init */
1421 for(i=0;i<nb_input_files;i++) {
1422 is = input_files[i];
1423 file_table[i].ist_index = j;
1424 file_table[i].nb_streams = is->nb_streams;
1425 j += is->nb_streams;
1429 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1433 for(i=0;i<nb_istreams;i++) {
1434 ist = av_mallocz(sizeof(AVInputStream));
1440 for(i=0;i<nb_input_files;i++) {
1441 is = input_files[i];
1442 for(k=0;k<is->nb_streams;k++) {
1443 ist = ist_table[j++];
1444 ist->st = is->streams[k];
1445 ist->file_index = i;
1447 ist->discard = 1; /* the stream is discarded by default
1450 if (ist->st->codec->rate_emu) {
1451 ist->start = av_gettime();
1457 /* output stream init */
1459 for(i=0;i<nb_output_files;i++) {
1460 os = output_files[i];
1461 if (!os->nb_streams) {
1462 fprintf(stderr, "Output file does not contain any stream\n");
1465 nb_ostreams += os->nb_streams;
1467 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1468 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1472 /* Sanity check the mapping args -- do the input files & streams exist? */
1473 for(i=0;i<nb_stream_maps;i++) {
1474 int fi = stream_maps[i].file_index;
1475 int si = stream_maps[i].stream_index;
1477 if (fi < 0 || fi > nb_input_files - 1 ||
1478 si < 0 || si > file_table[fi].nb_streams - 1) {
1479 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1482 fi = stream_maps[i].sync_file_index;
1483 si = stream_maps[i].sync_stream_index;
1484 if (fi < 0 || fi > nb_input_files - 1 ||
1485 si < 0 || si > file_table[fi].nb_streams - 1) {
1486 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1491 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1494 for(i=0;i<nb_ostreams;i++) {
1495 ost = av_mallocz(sizeof(AVOutputStream));
1502 for(k=0;k<nb_output_files;k++) {
1503 os = output_files[k];
1504 for(i=0;i<os->nb_streams;i++) {
1506 ost = ost_table[n++];
1507 ost->file_index = k;
1509 ost->st = os->streams[i];
1510 if (nb_stream_maps > 0) {
1511 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1512 stream_maps[n-1].stream_index;
1514 /* Sanity check that the stream types match */
1515 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1516 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1517 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1518 ost->file_index, ost->index);
1525 j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1527 ost->source_index = j;
1531 /* get corresponding input stream index : we select the first one with the right type */
1533 for(j=0;j<nb_istreams;j++) {
1536 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1537 ost->source_index = j;
1545 if(! opt_programid) {
1546 /* try again and reuse existing stream */
1547 for(j=0;j<nb_istreams;j++) {
1549 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1550 ost->source_index = j;
1556 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1557 ost->file_index, ost->index);
1562 ist = ist_table[ost->source_index];
1564 ost->sync_ist = (nb_stream_maps > 0) ?
1565 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1566 stream_maps[n-1].sync_stream_index] : ist;
1570 /* for each output stream, we compute the right encoding parameters */
1571 for(i=0;i<nb_ostreams;i++) {
1573 os = output_files[ost->file_index];
1574 ist = ist_table[ost->source_index];
1576 codec = ost->st->codec;
1577 icodec = ist->st->codec;
1579 if (!ost->st->language[0])
1580 av_strlcpy(ost->st->language, ist->st->language,
1581 sizeof(ost->st->language));
1583 if (ost->st->stream_copy) {
1584 /* if stream_copy is selected, no need to decode or encode */
1585 codec->codec_id = icodec->codec_id;
1586 codec->codec_type = icodec->codec_type;
1588 if(!codec->codec_tag){
1589 if( !os->oformat->codec_tag
1590 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1591 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1592 codec->codec_tag = icodec->codec_tag;
1595 codec->bit_rate = icodec->bit_rate;
1596 codec->extradata= icodec->extradata;
1597 codec->extradata_size= icodec->extradata_size;
1598 if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1599 codec->time_base = icodec->time_base;
1601 codec->time_base = ist->st->time_base;
1602 switch(codec->codec_type) {
1603 case CODEC_TYPE_AUDIO:
1604 codec->sample_rate = icodec->sample_rate;
1605 codec->channels = icodec->channels;
1606 codec->frame_size = icodec->frame_size;
1607 codec->block_align= icodec->block_align;
1608 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1609 codec->block_align= 0;
1611 case CODEC_TYPE_VIDEO:
1613 fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1616 codec->pix_fmt = icodec->pix_fmt;
1617 codec->width = icodec->width;
1618 codec->height = icodec->height;
1619 codec->has_b_frames = icodec->has_b_frames;
1621 case CODEC_TYPE_SUBTITLE:
1627 switch(codec->codec_type) {
1628 case CODEC_TYPE_AUDIO:
1629 if (av_fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1631 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1632 icodec->request_channels = codec->channels;
1633 ist->decoding_needed = 1;
1634 ost->encoding_needed = 1;
1636 case CODEC_TYPE_VIDEO:
1637 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1638 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1639 ost->video_resample = ((codec->width != icodec->width -
1640 (frame_leftBand + frame_rightBand) +
1641 (frame_padleft + frame_padright)) ||
1642 (codec->height != icodec->height -
1643 (frame_topBand + frame_bottomBand) +
1644 (frame_padtop + frame_padbottom)) ||
1645 (codec->pix_fmt != icodec->pix_fmt));
1646 if (ost->video_crop) {
1647 ost->topBand = frame_topBand;
1648 ost->leftBand = frame_leftBand;
1650 if (ost->video_pad) {
1651 ost->padtop = frame_padtop;
1652 ost->padleft = frame_padleft;
1653 ost->padbottom = frame_padbottom;
1654 ost->padright = frame_padright;
1655 if (!ost->video_resample) {
1656 avcodec_get_frame_defaults(&ost->pict_tmp);
1657 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1658 codec->width, codec->height ) )
1662 if (ost->video_resample) {
1663 avcodec_get_frame_defaults(&ost->pict_tmp);
1664 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1665 codec->width, codec->height ) ) {
1666 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1669 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1670 ost->img_resample_ctx = sws_getContext(
1671 icodec->width - (frame_leftBand + frame_rightBand),
1672 icodec->height - (frame_topBand + frame_bottomBand),
1674 codec->width - (frame_padleft + frame_padright),
1675 codec->height - (frame_padtop + frame_padbottom),
1677 sws_flags, NULL, NULL, NULL);
1678 if (ost->img_resample_ctx == NULL) {
1679 fprintf(stderr, "Cannot get resampling context\n");
1682 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1684 ost->encoding_needed = 1;
1685 ist->decoding_needed = 1;
1687 case CODEC_TYPE_SUBTITLE:
1688 ost->encoding_needed = 1;
1689 ist->decoding_needed = 1;
1696 if (ost->encoding_needed &&
1697 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1698 char logfilename[1024];
1703 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1705 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1706 if (codec->flags & CODEC_FLAG_PASS1) {
1707 f = fopen(logfilename, "w");
1709 perror(logfilename);
1714 /* read the log file */
1715 f = fopen(logfilename, "r");
1717 perror(logfilename);
1720 fseek(f, 0, SEEK_END);
1722 fseek(f, 0, SEEK_SET);
1723 logbuffer = av_malloc(size + 1);
1725 fprintf(stderr, "Could not allocate log buffer\n");
1728 size = fread(logbuffer, 1, size, f);
1730 logbuffer[size] = '\0';
1731 codec->stats_in = logbuffer;
1735 if(codec->codec_type == CODEC_TYPE_VIDEO){
1736 int size= codec->width * codec->height;
1737 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1742 bit_buffer = av_malloc(bit_buffer_size);
1746 /* dump the file output parameters - cannot be done before in case
1748 for(i=0;i<nb_output_files;i++) {
1749 dump_format(output_files[i], i, output_files[i]->filename, 1);
1752 /* dump the stream mapping */
1754 fprintf(stderr, "Stream mapping:\n");
1755 for(i=0;i<nb_ostreams;i++) {
1757 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1758 ist_table[ost->source_index]->file_index,
1759 ist_table[ost->source_index]->index,
1762 if (ost->sync_ist != ist_table[ost->source_index])
1763 fprintf(stderr, " [sync #%d.%d]",
1764 ost->sync_ist->file_index,
1765 ost->sync_ist->index);
1766 fprintf(stderr, "\n");
1770 /* open each encoder */
1771 for(i=0;i<nb_ostreams;i++) {
1773 if (ost->encoding_needed) {
1775 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1777 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1778 ost->file_index, ost->index);
1781 if (avcodec_open(ost->st->codec, codec) < 0) {
1782 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1783 ost->file_index, ost->index);
1786 extra_size += ost->st->codec->extradata_size;
1790 /* open each decoder */
1791 for(i=0;i<nb_istreams;i++) {
1793 if (ist->decoding_needed) {
1795 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1797 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1798 ist->st->codec->codec_id, ist->file_index, ist->index);
1801 if (avcodec_open(ist->st->codec, codec) < 0) {
1802 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1803 ist->file_index, ist->index);
1806 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1807 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1812 for(i=0;i<nb_istreams;i++) {
1814 is = input_files[ist->file_index];
1817 if( input_files_ts_offset[ist->file_index] != -is->start_time
1818 && !(is->start_time == AV_NOPTS_VALUE && input_files_ts_offset[ist->file_index]==0))
1819 ist->next_pts= AV_NOPTS_VALUE;
1823 /* set meta data information from input file if required */
1824 for (i=0;i<nb_meta_data_maps;i++) {
1825 AVFormatContext *out_file;
1826 AVFormatContext *in_file;
1828 int out_file_index = meta_data_maps[i].out_file;
1829 int in_file_index = meta_data_maps[i].in_file;
1830 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1831 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1832 ret = AVERROR(EINVAL);
1835 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1836 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1837 ret = AVERROR(EINVAL);
1841 out_file = output_files[out_file_index];
1842 in_file = input_files[in_file_index];
1844 strcpy(out_file->title, in_file->title);
1845 strcpy(out_file->author, in_file->author);
1846 strcpy(out_file->copyright, in_file->copyright);
1847 strcpy(out_file->comment, in_file->comment);
1848 strcpy(out_file->album, in_file->album);
1849 out_file->year = in_file->year;
1850 out_file->track = in_file->track;
1851 strcpy(out_file->genre, in_file->genre);
1854 /* open files and write file headers */
1855 for(i=0;i<nb_output_files;i++) {
1856 os = output_files[i];
1857 if (av_write_header(os) < 0) {
1858 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1859 ret = AVERROR(EINVAL);
1862 if (strcmp(output_files[i]->oformat->name, "rtp")) {
1867 print_sdp(output_files, nb_output_files);
1870 if ( !using_stdin && verbose >= 0) {
1871 fprintf(stderr, "Press [q] to stop encoding\n");
1872 url_set_interrupt_cb(decode_interrupt_cb);
1877 timer_start = av_gettime();
1879 for(; received_sigterm == 0;) {
1880 int file_index, ist_index;
1888 /* if 'q' pressed, exits */
1892 /* read_key() returns 0 on EOF */
1898 /* select the stream that we must read now by looking at the
1899 smallest output pts */
1901 for(i=0;i<nb_ostreams;i++) {
1904 os = output_files[ost->file_index];
1905 ist = ist_table[ost->source_index];
1906 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1907 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1909 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1910 ipts = (double)ist->pts;
1911 if (!file_table[ist->file_index].eof_reached){
1912 if(ipts < ipts_min) {
1914 if(input_sync ) file_index = ist->file_index;
1916 if(opts < opts_min) {
1918 if(!input_sync) file_index = ist->file_index;
1921 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1926 /* if none, if is finished */
1927 if (file_index < 0) {
1931 /* finish if recording time exhausted */
1932 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1935 /* finish if limit size exhausted */
1936 if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
1939 /* read a frame from it and output it in the fifo */
1940 is = input_files[file_index];
1941 if (av_read_frame(is, &pkt) < 0) {
1942 file_table[file_index].eof_reached = 1;
1950 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
1952 /* the following test is needed in case new streams appear
1953 dynamically in stream : we ignore them */
1954 if (pkt.stream_index >= file_table[file_index].nb_streams)
1955 goto discard_packet;
1956 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1957 ist = ist_table[ist_index];
1959 goto discard_packet;
1961 if (pkt.dts != AV_NOPTS_VALUE)
1962 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
1963 if (pkt.pts != AV_NOPTS_VALUE)
1964 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
1966 // 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);
1967 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1968 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
1969 int64_t delta= pkt_dts - ist->next_pts;
1970 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
1971 input_files_ts_offset[ist->file_index]-= delta;
1973 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1974 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
1975 if(pkt.pts != AV_NOPTS_VALUE)
1976 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
1980 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1981 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1984 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1985 ist->file_index, ist->index);
1987 av_free_packet(&pkt);
1992 av_free_packet(&pkt);
1994 /* dump report by using the output first video and audio streams */
1995 print_report(output_files, ost_table, nb_ostreams, 0);
1998 /* at the end of stream, we must flush the decoder buffers */
1999 for(i=0;i<nb_istreams;i++) {
2001 if (ist->decoding_needed) {
2002 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2008 /* write the trailer if needed and close file */
2009 for(i=0;i<nb_output_files;i++) {
2010 os = output_files[i];
2011 av_write_trailer(os);
2014 /* dump report by using the first video and audio streams */
2015 print_report(output_files, ost_table, nb_ostreams, 1);
2017 /* close each encoder */
2018 for(i=0;i<nb_ostreams;i++) {
2020 if (ost->encoding_needed) {
2021 av_freep(&ost->st->codec->stats_in);
2022 avcodec_close(ost->st->codec);
2026 /* close each decoder */
2027 for(i=0;i<nb_istreams;i++) {
2029 if (ist->decoding_needed) {
2030 avcodec_close(ist->st->codec);
2038 av_freep(&bit_buffer);
2039 av_free(file_table);
2042 for(i=0;i<nb_istreams;i++) {
2049 for(i=0;i<nb_ostreams;i++) {
2053 fclose(ost->logfile);
2054 ost->logfile = NULL;
2056 av_fifo_free(&ost->fifo); /* works even if fifo is not
2057 initialized but set to zero */
2058 av_free(ost->pict_tmp.data[0]);
2059 if (ost->video_resample)
2060 sws_freeContext(ost->img_resample_ctx);
2062 audio_resample_close(ost->resample);
2070 ret = AVERROR(ENOMEM);
2075 int file_read(const char *filename)
2078 unsigned char buffer[1024];
2081 if (url_open(&h, filename, O_RDONLY) < 0) {
2082 printf("could not open '%s'\n", filename);
2086 len = url_read(h, buffer, sizeof(buffer));
2089 for(i=0;i<len;i++) putchar(buffer[i]);
2096 static void opt_format(const char *arg)
2098 /* compatibility stuff for pgmyuv */
2099 if (!strcmp(arg, "pgmyuv")) {
2100 pgmyuv_compatibility_hack=1;
2101 // opt_image_format(arg);
2103 fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2106 file_iformat = av_find_input_format(arg);
2107 file_oformat = guess_format(arg, NULL, NULL);
2108 if (!file_iformat && !file_oformat) {
2109 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2114 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
2115 extern int ffm_nopts;
2118 static int opt_default(const char *opt, const char *arg){
2120 const AVOption *o= NULL;
2121 int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
2123 for(type=0; type<CODEC_TYPE_NB; type++){
2124 const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
2126 o = av_set_string(avctx_opts[type], opt, arg);
2129 o = av_set_string(avformat_opts, opt, arg);
2131 o = av_set_string(sws_opts, opt, arg);
2134 o = av_set_string(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg);
2135 else if(opt[0] == 'v')
2136 o = av_set_string(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg);
2137 else if(opt[0] == 's')
2138 o = av_set_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg);
2143 // 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));
2145 //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
2146 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
2147 opt_names[opt_name_count++]= o->name;
2149 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
2150 /* disable generate of real time pts in ffm (need to be supressed anyway) */
2151 if(avctx_opts[0]->flags & CODEC_FLAG_BITEXACT)
2155 if(avctx_opts[0]->debug)
2156 av_log_set_level(AV_LOG_DEBUG);
2160 static void opt_video_rc_override_string(const char *arg)
2162 video_rc_override_string = arg;
2165 static void opt_me_threshold(const char *arg)
2167 me_threshold = atoi(arg);
2170 static void opt_verbose(const char *arg)
2172 verbose = atoi(arg);
2173 av_log_set_level(atoi(arg));
2176 static void opt_frame_rate(const char *arg)
2178 if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2179 fprintf(stderr, "Incorrect frame rate\n");
2184 static int opt_bitrate(const char *opt, const char *arg)
2186 int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2188 opt_default(opt, arg);
2190 if (av_get_int(avctx_opts[codec_type], "b", NULL) < 1000)
2191 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2196 static void opt_frame_crop_top(const char *arg)
2198 frame_topBand = atoi(arg);
2199 if (frame_topBand < 0) {
2200 fprintf(stderr, "Incorrect top crop size\n");
2203 if ((frame_topBand % 2) != 0) {
2204 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2207 if ((frame_topBand) >= frame_height){
2208 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2211 frame_height -= frame_topBand;
2214 static void opt_frame_crop_bottom(const char *arg)
2216 frame_bottomBand = atoi(arg);
2217 if (frame_bottomBand < 0) {
2218 fprintf(stderr, "Incorrect bottom crop size\n");
2221 if ((frame_bottomBand % 2) != 0) {
2222 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2225 if ((frame_bottomBand) >= frame_height){
2226 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2229 frame_height -= frame_bottomBand;
2232 static void opt_frame_crop_left(const char *arg)
2234 frame_leftBand = atoi(arg);
2235 if (frame_leftBand < 0) {
2236 fprintf(stderr, "Incorrect left crop size\n");
2239 if ((frame_leftBand % 2) != 0) {
2240 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2243 if ((frame_leftBand) >= frame_width){
2244 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2247 frame_width -= frame_leftBand;
2250 static void opt_frame_crop_right(const char *arg)
2252 frame_rightBand = atoi(arg);
2253 if (frame_rightBand < 0) {
2254 fprintf(stderr, "Incorrect right crop size\n");
2257 if ((frame_rightBand % 2) != 0) {
2258 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2261 if ((frame_rightBand) >= frame_width){
2262 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2265 frame_width -= frame_rightBand;
2268 static void opt_frame_size(const char *arg)
2270 if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2271 fprintf(stderr, "Incorrect frame size\n");
2274 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2275 fprintf(stderr, "Frame size must be a multiple of 2\n");
2281 #define SCALEBITS 10
2282 #define ONE_HALF (1 << (SCALEBITS - 1))
2283 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2285 #define RGB_TO_Y(r, g, b) \
2286 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2287 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2289 #define RGB_TO_U(r1, g1, b1, shift)\
2290 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2291 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2293 #define RGB_TO_V(r1, g1, b1, shift)\
2294 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2295 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2297 static void opt_pad_color(const char *arg) {
2298 /* Input is expected to be six hex digits similar to
2299 how colors are expressed in html tags (but without the #) */
2300 int rgb = strtol(arg, NULL, 16);
2304 g = ((rgb >> 8) & 255);
2307 padcolor[0] = RGB_TO_Y(r,g,b);
2308 padcolor[1] = RGB_TO_U(r,g,b,0);
2309 padcolor[2] = RGB_TO_V(r,g,b,0);
2312 static void opt_frame_pad_top(const char *arg)
2314 frame_padtop = atoi(arg);
2315 if (frame_padtop < 0) {
2316 fprintf(stderr, "Incorrect top pad size\n");
2319 if ((frame_padtop % 2) != 0) {
2320 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2325 static void opt_frame_pad_bottom(const char *arg)
2327 frame_padbottom = atoi(arg);
2328 if (frame_padbottom < 0) {
2329 fprintf(stderr, "Incorrect bottom pad size\n");
2332 if ((frame_padbottom % 2) != 0) {
2333 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2339 static void opt_frame_pad_left(const char *arg)
2341 frame_padleft = atoi(arg);
2342 if (frame_padleft < 0) {
2343 fprintf(stderr, "Incorrect left pad size\n");
2346 if ((frame_padleft % 2) != 0) {
2347 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2353 static void opt_frame_pad_right(const char *arg)
2355 frame_padright = atoi(arg);
2356 if (frame_padright < 0) {
2357 fprintf(stderr, "Incorrect right pad size\n");
2360 if ((frame_padright % 2) != 0) {
2361 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2366 void list_pix_fmts(void)
2369 char pix_fmt_str[128];
2370 for (i=-1; i < PIX_FMT_NB; i++) {
2371 avcodec_pix_fmt_string (pix_fmt_str, sizeof(pix_fmt_str), i);
2372 fprintf(stdout, "%s\n", pix_fmt_str);
2376 static void opt_frame_pix_fmt(const char *arg)
2378 if (strcmp(arg, "list"))
2379 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2386 static void opt_frame_aspect_ratio(const char *arg)
2392 p = strchr(arg, ':');
2394 x = strtol(arg, (char **)&arg, 10);
2396 y = strtol(arg+1, (char **)&arg, 10);
2398 ar = (double)x / (double)y;
2400 ar = strtod(arg, (char **)&arg);
2403 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2406 frame_aspect_ratio = ar;
2409 static void opt_qscale(const char *arg)
2411 video_qscale = atof(arg);
2412 if (video_qscale <= 0 ||
2413 video_qscale > 255) {
2414 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2419 static void opt_qdiff(const char *arg)
2421 video_qdiff = atoi(arg);
2422 if (video_qdiff < 0 ||
2424 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2429 static void opt_strict(const char *arg)
2434 static void opt_top_field_first(const char *arg)
2436 top_field_first= atoi(arg);
2439 static void opt_thread_count(const char *arg)
2441 thread_count= atoi(arg);
2442 #if !defined(HAVE_THREADS)
2444 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2448 static void opt_audio_rate(const char *arg)
2450 audio_sample_rate = atoi(arg);
2453 static void opt_audio_channels(const char *arg)
2455 audio_channels = atoi(arg);
2458 static void opt_video_channel(const char *arg)
2460 video_channel = strtol(arg, NULL, 0);
2463 static void opt_video_standard(const char *arg)
2465 video_standard = av_strdup(arg);
2468 static void opt_codec(int *pstream_copy, char **pcodec_name,
2469 int codec_type, const char *arg)
2471 av_freep(pcodec_name);
2472 if (!strcmp(arg, "copy")) {
2475 *pcodec_name = av_strdup(arg);
2479 static void opt_audio_codec(const char *arg)
2481 opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2484 static void opt_audio_tag(const char *arg)
2487 audio_codec_tag= strtol(arg, &tail, 0);
2490 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2493 static void opt_video_tag(const char *arg)
2496 video_codec_tag= strtol(arg, &tail, 0);
2499 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2503 static void add_frame_hooker(const char *arg)
2508 char *args = av_strdup(arg);
2512 argv[0] = strtok(args, " ");
2513 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2516 i = frame_hook_add(argc, argv);
2519 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2525 static void opt_video_codec(const char *arg)
2527 opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2530 static void opt_subtitle_codec(const char *arg)
2532 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2535 static void opt_map(const char *arg)
2541 m = &stream_maps[nb_stream_maps++];
2543 m->file_index = strtol(arg, (char **)&p, 0);
2547 m->stream_index = strtol(p, (char **)&p, 0);
2550 m->sync_file_index = strtol(p, (char **)&p, 0);
2553 m->sync_stream_index = strtol(p, (char **)&p, 0);
2555 m->sync_file_index = m->file_index;
2556 m->sync_stream_index = m->stream_index;
2560 static void opt_map_meta_data(const char *arg)
2566 m = &meta_data_maps[nb_meta_data_maps++];
2568 m->out_file = strtol(arg, (char **)&p, 0);
2572 m->in_file = strtol(p, (char **)&p, 0);
2575 static int64_t parse_time_or_die(const char *timestr, int is_duration)
2577 int64_t us = parse_date(timestr, is_duration);
2578 if (us == INT64_MIN) {
2579 fprintf(stderr, "Invalid %s specification: %s\n",
2580 is_duration ? "duration" : "date", timestr);
2586 static void opt_recording_time(const char *arg)
2588 recording_time = parse_time_or_die(arg, 1);
2591 static void opt_start_time(const char *arg)
2593 start_time = parse_time_or_die(arg, 1);
2596 static void opt_rec_timestamp(const char *arg)
2598 rec_timestamp = parse_time_or_die(arg, 0) / 1000000;
2601 static void opt_input_ts_offset(const char *arg)
2603 input_ts_offset = parse_time_or_die(arg, 1);
2606 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2608 char *codec_string = encoder ? "encoder" : "decoder";
2612 return CODEC_ID_NONE;
2614 avcodec_find_encoder_by_name(name) :
2615 avcodec_find_decoder_by_name(name);
2617 av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2620 if(codec->type != type) {
2621 av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2627 static void opt_input_file(const char *filename)
2629 AVFormatContext *ic;
2630 AVFormatParameters params, *ap = ¶ms;
2631 int err, i, ret, rfps, rfps_base;
2634 if (!strcmp(filename, "-"))
2637 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2638 !strcmp( filename, "/dev/stdin" );
2640 /* get default parameters from command line */
2641 ic = av_alloc_format_context();
2643 memset(ap, 0, sizeof(*ap));
2644 ap->prealloced_context = 1;
2645 ap->sample_rate = audio_sample_rate;
2646 ap->channels = audio_channels;
2647 ap->time_base.den = frame_rate.num;
2648 ap->time_base.num = frame_rate.den;
2649 ap->width = frame_width + frame_padleft + frame_padright;
2650 ap->height = frame_height + frame_padtop + frame_padbottom;
2651 ap->pix_fmt = frame_pix_fmt;
2652 ap->channel = video_channel;
2653 ap->standard = video_standard;
2654 ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2655 ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2656 if(pgmyuv_compatibility_hack)
2657 ap->video_codec_id= CODEC_ID_PGMYUV;
2659 for(i=0; i<opt_name_count; i++){
2661 const AVOption *opt;
2662 const char *str= av_get_string(avformat_opts, opt_names[i], &opt, buf, sizeof(buf));
2663 if(str && (opt->flags & AV_OPT_FLAG_DECODING_PARAM))
2664 av_set_string(ic, opt_names[i], str);
2667 ic->video_codec_id = find_codec_or_die(video_codec_name , CODEC_TYPE_VIDEO , 0);
2668 ic->audio_codec_id = find_codec_or_die(audio_codec_name , CODEC_TYPE_AUDIO , 0);
2669 ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2671 /* open the input file with generic libav function */
2672 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2674 print_error(filename, err);
2679 for(i=0; i<ic->nb_programs; i++)
2680 if(ic->programs[i]->id != opt_programid)
2681 ic->programs[i]->discard = AVDISCARD_ALL;
2684 ic->loop_input = loop_input;
2686 /* If not enough info to get the stream parameters, we decode the
2687 first frames to get it. (used in mpeg case for example) */
2688 ret = av_find_stream_info(ic);
2689 if (ret < 0 && verbose >= 0) {
2690 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2694 timestamp = start_time;
2695 /* add the stream start time */
2696 if (ic->start_time != AV_NOPTS_VALUE)
2697 timestamp += ic->start_time;
2699 /* if seeking requested, we execute it */
2700 if (start_time != 0) {
2701 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2703 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2704 filename, (double)timestamp / AV_TIME_BASE);
2706 /* reset seek info */
2710 /* update the current parameters so that they match the one of the input stream */
2711 for(i=0;i<ic->nb_streams;i++) {
2713 AVCodecContext *enc = ic->streams[i]->codec;
2715 avcodec_thread_init(enc, thread_count);
2716 enc->thread_count= thread_count;
2717 switch(enc->codec_type) {
2718 case CODEC_TYPE_AUDIO:
2719 for(j=0; j<opt_name_count; j++){
2721 const AVOption *opt;
2722 const char *str= av_get_string(avctx_opts[CODEC_TYPE_AUDIO], opt_names[j], &opt, buf, sizeof(buf));
2723 if(str && (opt->flags & AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags & AV_OPT_FLAG_DECODING_PARAM))
2724 av_set_string(enc, opt_names[j], str);
2726 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2727 audio_channels = enc->channels;
2728 audio_sample_rate = enc->sample_rate;
2730 ic->streams[i]->discard= AVDISCARD_ALL;
2732 case CODEC_TYPE_VIDEO:
2733 for(j=0; j<opt_name_count; j++){
2735 const AVOption *opt;
2736 const char *str= av_get_string(avctx_opts[CODEC_TYPE_VIDEO], opt_names[j], &opt, buf, sizeof(buf));
2737 if(str && (opt->flags & AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags & AV_OPT_FLAG_DECODING_PARAM))
2738 av_set_string(enc, opt_names[j], str);
2740 frame_height = enc->height;
2741 frame_width = enc->width;
2742 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2743 frame_pix_fmt = enc->pix_fmt;
2744 rfps = ic->streams[i]->r_frame_rate.num;
2745 rfps_base = ic->streams[i]->r_frame_rate.den;
2746 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2748 enc->debug |= FF_DEBUG_MV;
2750 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2753 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2754 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2756 (float)rfps / rfps_base, rfps, rfps_base);
2758 /* update the current frame rate to match the stream frame rate */
2759 frame_rate.num = rfps;
2760 frame_rate.den = rfps_base;
2762 enc->rate_emu = rate_emu;
2764 ic->streams[i]->discard= AVDISCARD_ALL;
2765 else if(video_discard)
2766 ic->streams[i]->discard= video_discard;
2768 case CODEC_TYPE_DATA:
2770 case CODEC_TYPE_SUBTITLE:
2771 if(subtitle_disable)
2772 ic->streams[i]->discard = AVDISCARD_ALL;
2774 case CODEC_TYPE_UNKNOWN:
2781 input_files[nb_input_files] = ic;
2782 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2783 /* dump the file content */
2785 dump_format(ic, nb_input_files, filename, 0);
2788 file_iformat = NULL;
2789 file_oformat = NULL;
2794 av_freep(&video_codec_name);
2795 av_freep(&audio_codec_name);
2796 av_freep(&subtitle_codec_name);
2799 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2800 int *has_subtitle_ptr)
2802 int has_video, has_audio, has_subtitle, i, j;
2803 AVFormatContext *ic;
2808 for(j=0;j<nb_input_files;j++) {
2809 ic = input_files[j];
2810 for(i=0;i<ic->nb_streams;i++) {
2811 AVCodecContext *enc = ic->streams[i]->codec;
2812 switch(enc->codec_type) {
2813 case CODEC_TYPE_AUDIO:
2816 case CODEC_TYPE_VIDEO:
2819 case CODEC_TYPE_SUBTITLE:
2822 case CODEC_TYPE_DATA:
2823 case CODEC_TYPE_UNKNOWN:
2830 *has_video_ptr = has_video;
2831 *has_audio_ptr = has_audio;
2832 *has_subtitle_ptr = has_subtitle;
2835 static void new_video_stream(AVFormatContext *oc)
2838 AVCodecContext *video_enc;
2841 st = av_new_stream(oc, oc->nb_streams);
2843 fprintf(stderr, "Could not alloc stream\n");
2846 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2847 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2848 video_bitstream_filters= NULL;
2851 avcodec_thread_init(st->codec, thread_count);
2853 video_enc = st->codec;
2856 video_enc->codec_tag= video_codec_tag;
2858 if( (video_global_header&1)
2859 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2860 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2861 avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2863 if(video_global_header&2){
2864 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2865 avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2868 if (video_stream_copy) {
2869 st->stream_copy = 1;
2870 video_enc->codec_type = CODEC_TYPE_VIDEO;
2875 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
2877 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2878 if (video_codec_name)
2879 codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
2881 video_enc->codec_id = codec_id;
2882 codec = avcodec_find_encoder(codec_id);
2884 for(i=0; i<opt_name_count; i++){
2886 const AVOption *opt;
2887 const char *str= av_get_string(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt, buf, sizeof(buf));
2888 if(str && (opt->flags & AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
2889 av_set_string(video_enc, opt_names[i], str);
2892 video_enc->time_base.den = fps.num;
2893 video_enc->time_base.num = fps.den;
2894 if(codec && codec->supported_framerates){
2895 const AVRational *p= codec->supported_framerates;
2896 const AVRational *best=NULL;
2897 AVRational best_error= (AVRational){INT_MAX, 1};
2898 for(; p->den!=0; p++){
2899 AVRational error= av_sub_q(fps, *p);
2900 if(error.num <0) error.num *= -1;
2901 if(av_cmp_q(error, best_error) < 0){
2906 video_enc->time_base.den= best->num;
2907 video_enc->time_base.num= best->den;
2910 video_enc->width = frame_width + frame_padright + frame_padleft;
2911 video_enc->height = frame_height + frame_padtop + frame_padbottom;
2912 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2913 video_enc->pix_fmt = frame_pix_fmt;
2915 if(codec && codec->pix_fmts){
2916 const enum PixelFormat *p= codec->pix_fmts;
2918 if(*p == video_enc->pix_fmt)
2922 video_enc->pix_fmt = codec->pix_fmts[0];
2926 video_enc->gop_size = 0;
2927 if (video_qscale || same_quality) {
2928 video_enc->flags |= CODEC_FLAG_QSCALE;
2929 video_enc->global_quality=
2930 st->quality = FF_QP2LAMBDA * video_qscale;
2934 video_enc->intra_matrix = intra_matrix;
2936 video_enc->inter_matrix = inter_matrix;
2938 video_enc->max_qdiff = video_qdiff;
2939 video_enc->thread_count = thread_count;
2940 p= video_rc_override_string;
2943 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2945 fprintf(stderr, "error parsing rc_override\n");
2948 video_enc->rc_override=
2949 av_realloc(video_enc->rc_override,
2950 sizeof(RcOverride)*(i+1));
2951 video_enc->rc_override[i].start_frame= start;
2952 video_enc->rc_override[i].end_frame = end;
2954 video_enc->rc_override[i].qscale= q;
2955 video_enc->rc_override[i].quality_factor= 1.0;
2958 video_enc->rc_override[i].qscale= 0;
2959 video_enc->rc_override[i].quality_factor= -q/100.0;
2964 video_enc->rc_override_count=i;
2965 if (!video_enc->rc_initial_buffer_occupancy)
2966 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2967 video_enc->me_threshold= me_threshold;
2968 video_enc->intra_dc_precision= intra_dc_precision - 8;
2969 video_enc->strict_std_compliance = strict;
2972 video_enc->flags|= CODEC_FLAG_PSNR;
2977 video_enc->flags |= CODEC_FLAG_PASS1;
2979 video_enc->flags |= CODEC_FLAG_PASS2;
2984 /* reset some key parameters */
2986 av_freep(&video_codec_name);
2987 video_stream_copy = 0;
2990 static void new_audio_stream(AVFormatContext *oc)
2993 AVCodecContext *audio_enc;
2996 st = av_new_stream(oc, oc->nb_streams);
2998 fprintf(stderr, "Could not alloc stream\n");
3001 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3003 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3004 audio_bitstream_filters= NULL;
3007 avcodec_thread_init(st->codec, thread_count);
3009 audio_enc = st->codec;
3010 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3011 audio_enc->strict_std_compliance = strict;
3014 audio_enc->codec_tag= audio_codec_tag;
3016 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3017 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3018 avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3020 if (audio_stream_copy) {
3021 st->stream_copy = 1;
3022 audio_enc->channels = audio_channels;
3024 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3026 for(i=0; i<opt_name_count; i++){
3028 const AVOption *opt;
3029 const char *str= av_get_string(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt, buf, sizeof(buf));
3030 if(str && (opt->flags & AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3031 av_set_string(audio_enc, opt_names[i], str);
3034 if (audio_codec_name)
3035 codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3036 audio_enc->codec_id = codec_id;
3038 if (audio_qscale > QSCALE_NONE) {
3039 audio_enc->flags |= CODEC_FLAG_QSCALE;
3040 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3042 audio_enc->thread_count = thread_count;
3043 audio_enc->channels = audio_channels;
3045 audio_enc->sample_rate = audio_sample_rate;
3046 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3047 if (audio_language) {
3048 av_strlcpy(st->language, audio_language, sizeof(st->language));
3049 av_free(audio_language);
3050 audio_language = NULL;
3053 /* reset some key parameters */
3055 av_freep(&audio_codec_name);
3056 audio_stream_copy = 0;
3059 static void new_subtitle_stream(AVFormatContext *oc)
3062 AVCodecContext *subtitle_enc;
3065 st = av_new_stream(oc, oc->nb_streams);
3067 fprintf(stderr, "Could not alloc stream\n");
3070 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3072 subtitle_enc = st->codec;
3073 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3074 if (subtitle_stream_copy) {
3075 st->stream_copy = 1;
3077 for(i=0; i<opt_name_count; i++){
3079 const AVOption *opt;
3080 const char *str= av_get_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt_names[i], &opt, buf, sizeof(buf));
3081 if(str && (opt->flags & AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3082 av_set_string(subtitle_enc, opt_names[i], str);
3084 subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3087 if (subtitle_language) {
3088 av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3089 av_free(subtitle_language);
3090 subtitle_language = NULL;
3093 subtitle_disable = 0;
3094 av_freep(&subtitle_codec_name);
3095 subtitle_stream_copy = 0;
3098 static void opt_new_audio_stream(void)
3100 AVFormatContext *oc;
3101 if (nb_output_files <= 0) {
3102 fprintf(stderr, "At least one output file must be specified\n");
3105 oc = output_files[nb_output_files - 1];
3106 new_audio_stream(oc);
3109 static void opt_new_video_stream(void)
3111 AVFormatContext *oc;
3112 if (nb_output_files <= 0) {
3113 fprintf(stderr, "At least one output file must be specified\n");
3116 oc = output_files[nb_output_files - 1];
3117 new_video_stream(oc);
3120 static void opt_new_subtitle_stream(void)
3122 AVFormatContext *oc;
3123 if (nb_output_files <= 0) {
3124 fprintf(stderr, "At least one output file must be specified\n");
3127 oc = output_files[nb_output_files - 1];
3128 new_subtitle_stream(oc);
3131 static void opt_output_file(const char *filename)
3133 AVFormatContext *oc;
3134 int use_video, use_audio, use_subtitle;
3135 int input_has_video, input_has_audio, input_has_subtitle, i;
3136 AVFormatParameters params, *ap = ¶ms;
3138 if (!strcmp(filename, "-"))
3141 oc = av_alloc_format_context();
3143 if (!file_oformat) {
3144 file_oformat = guess_format(NULL, filename, NULL);
3145 if (!file_oformat) {
3146 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3152 oc->oformat = file_oformat;
3153 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3155 if (!strcmp(file_oformat->name, "ffm") &&
3156 av_strstart(filename, "http:", NULL)) {
3157 /* special case for files sent to ffserver: we get the stream
3158 parameters from ffserver */
3159 if (read_ffserver_streams(oc, filename) < 0) {
3160 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3164 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3165 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3166 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3168 /* disable if no corresponding type found and at least one
3170 if (nb_input_files > 0) {
3171 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3172 &input_has_subtitle);
3173 if (!input_has_video)
3175 if (!input_has_audio)
3177 if (!input_has_subtitle)
3181 /* manual disable */
3182 if (audio_disable) {
3185 if (video_disable) {
3188 if (subtitle_disable) {
3193 new_video_stream(oc);
3197 new_audio_stream(oc);
3201 new_subtitle_stream(oc);
3204 oc->timestamp = rec_timestamp;
3207 av_strlcpy(oc->title, str_title, sizeof(oc->title));
3209 av_strlcpy(oc->author, str_author, sizeof(oc->author));
3211 av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3213 av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3215 av_strlcpy(oc->album, str_album, sizeof(oc->album));
3217 av_strlcpy(oc->genre, str_genre, sizeof(oc->genre));
3220 output_files[nb_output_files++] = oc;
3222 /* check filename in case of an image number is expected */
3223 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3224 if (!av_filename_number_test(oc->filename)) {
3225 print_error(oc->filename, AVERROR_NUMEXPECTED);
3230 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3231 /* test if it already exists to avoid loosing precious files */
3232 if (!file_overwrite &&
3233 (strchr(filename, ':') == NULL ||
3234 filename[1] == ':' ||
3235 av_strstart(filename, "file:", NULL))) {
3236 if (url_exist(filename)) {
3239 if ( !using_stdin ) {
3240 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3243 if (toupper(c) != 'Y') {
3244 fprintf(stderr, "Not overwriting - exiting\n");
3249 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3256 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3257 fprintf(stderr, "Could not open '%s'\n", filename);
3262 memset(ap, 0, sizeof(*ap));
3263 if (av_set_parameters(oc, ap) < 0) {
3264 fprintf(stderr, "%s: Invalid encoding parameters\n",
3269 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3270 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3271 oc->loop_output = loop_output;
3273 for(i=0; i<opt_name_count; i++){
3275 const AVOption *opt;
3276 const char *str= av_get_string(avformat_opts, opt_names[i], &opt, buf, sizeof(buf));
3277 if(str && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3278 av_set_string(oc, opt_names[i], str);
3281 /* reset some options */
3282 file_oformat = NULL;
3283 file_iformat = NULL;
3286 /* same option as mencoder */
3287 static void opt_pass(const char *pass_str)
3290 pass = atoi(pass_str);
3291 if (pass != 1 && pass != 2) {
3292 fprintf(stderr, "pass number can be only 1 or 2\n");
3298 static int64_t getutime(void)
3300 #ifdef HAVE_GETRUSAGE
3301 struct rusage rusage;
3303 getrusage(RUSAGE_SELF, &rusage);
3304 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3305 #elif defined(HAVE_GETPROCESSTIMES)
3307 FILETIME c, e, k, u;
3308 proc = GetCurrentProcess();
3309 GetProcessTimes(proc, &c, &e, &k, &u);
3310 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3312 return av_gettime();
3316 static void opt_show_formats(void)
3318 AVInputFormat *ifmt=NULL;
3319 AVOutputFormat *ofmt=NULL;
3320 URLProtocol *up=NULL;
3321 AVCodec *p=NULL, *p2;
3322 AVBitStreamFilter *bsf=NULL;
3323 const char *last_name;
3325 printf("File formats:\n");
3330 const char *name=NULL;
3331 const char *long_name=NULL;
3333 while((ofmt= av_oformat_next(ofmt))) {
3334 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3335 strcmp(ofmt->name, last_name)>0){
3337 long_name= ofmt->long_name;
3341 while((ifmt= av_iformat_next(ifmt))) {
3342 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3343 strcmp(ifmt->name, last_name)>0){
3345 long_name= ifmt->long_name;
3348 if(name && strcmp(ifmt->name, name)==0)
3360 long_name ? long_name:" ");
3364 printf("Codecs:\n");
3370 const char *type_str;
3373 while((p= av_codec_next(p))) {
3374 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3375 strcmp(p->name, last_name)>0){
3377 decode= encode= cap=0;
3379 if(p2 && strcmp(p->name, p2->name)==0){
3380 if(p->decode) decode=1;
3381 if(p->encode) encode=1;
3382 cap |= p->capabilities;
3387 last_name= p2->name;
3390 case CODEC_TYPE_VIDEO:
3393 case CODEC_TYPE_AUDIO:
3396 case CODEC_TYPE_SUBTITLE:
3405 decode ? "D": (/*p2->decoder ? "d":*/" "),
3408 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3409 cap & CODEC_CAP_DR1 ? "D":" ",
3410 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3412 /* if(p2->decoder && decode==0)
3413 printf(" use %s for decoding", p2->decoder->name);*/
3418 printf("Bitstream filters:\n");
3419 while((bsf = av_bitstream_filter_next(bsf)))
3420 printf(" %s", bsf->name);
3423 printf("Supported file protocols:\n");
3424 while((up = av_protocol_next(up)))
3425 printf(" %s:", up->name);
3428 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3431 "Note, the names of encoders and decoders do not always match, so there are\n"
3432 "several cases where the above table shows encoder only or decoder only entries\n"
3433 "even though both encoding and decoding are supported. For example, the h263\n"
3434 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
3439 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3442 const char *p = str;
3449 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3456 static void opt_inter_matrix(const char *arg)
3458 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3459 parse_matrix_coeffs(inter_matrix, arg);
3462 static void opt_intra_matrix(const char *arg)
3464 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3465 parse_matrix_coeffs(intra_matrix, arg);
3469 * Trivial log callback.
3470 * Only suitable for show_help and similar since it lacks prefix handling.
3472 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3474 vfprintf(stdout, fmt, vl);
3477 static void show_help(void)
3479 av_log_set_callback(log_callback_help);
3480 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3481 "Hyper fast Audio and Video encoder\n");
3483 show_help_options(options, "Main options:\n",
3484 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3485 show_help_options(options, "\nVideo options:\n",
3486 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3488 show_help_options(options, "\nAdvanced Video options:\n",
3489 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3490 OPT_VIDEO | OPT_EXPERT);
3491 show_help_options(options, "\nAudio options:\n",
3492 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3494 show_help_options(options, "\nAdvanced Audio options:\n",
3495 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3496 OPT_AUDIO | OPT_EXPERT);
3497 show_help_options(options, "\nSubtitle options:\n",
3498 OPT_SUBTITLE | OPT_GRAB,
3500 show_help_options(options, "\nAudio/Video grab options:\n",
3503 show_help_options(options, "\nAdvanced options:\n",
3504 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3506 av_opt_show(avctx_opts[0], NULL);
3507 av_opt_show(avformat_opts, NULL);
3508 av_opt_show(sws_opts, NULL);
3511 static void opt_show_help(void)
3517 static void opt_target(const char *arg)
3520 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3522 if(!strncmp(arg, "pal-", 4)) {
3525 } else if(!strncmp(arg, "ntsc-", 5)) {
3528 } else if(!strncmp(arg, "film-", 5)) {
3533 /* Calculate FR via float to avoid int overflow */
3534 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3537 } else if((fr == 29970) || (fr == 23976)) {
3540 /* Try to determine PAL/NTSC by peeking in the input files */
3541 if(nb_input_files) {
3543 for(j = 0; j < nb_input_files; j++) {
3544 for(i = 0; i < input_files[j]->nb_streams; i++) {
3545 AVCodecContext *c = input_files[j]->streams[i]->codec;
3546 if(c->codec_type != CODEC_TYPE_VIDEO)
3548 fr = c->time_base.den * 1000 / c->time_base.num;
3552 } else if((fr == 29970) || (fr == 23976)) {
3562 if(verbose && norm >= 0)
3563 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3567 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3568 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3569 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3573 if(!strcmp(arg, "vcd")) {
3575 opt_video_codec("mpeg1video");
3576 opt_audio_codec("mp2");
3579 opt_frame_size(norm ? "352x240" : "352x288");
3580 opt_frame_rate(frame_rates[norm]);
3581 opt_default("gop", norm ? "18" : "15");
3583 opt_default("b", "1150000");
3584 opt_default("maxrate", "1150000");
3585 opt_default("minrate", "1150000");
3586 opt_default("bufsize", "327680"); // 40*1024*8;
3588 opt_default("ab", "224000");
3589 audio_sample_rate = 44100;
3592 opt_default("packetsize", "2324");
3593 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3595 /* We have to offset the PTS, so that it is consistent with the SCR.
3596 SCR starts at 36000, but the first two packs contain only padding
3597 and the first pack from the other stream, respectively, may also have
3598 been written before.
3599 So the real data starts at SCR 36000+3*1200. */
3600 mux_preload= (36000+3*1200) / 90000.0; //0.44
3601 } else if(!strcmp(arg, "svcd")) {
3603 opt_video_codec("mpeg2video");
3604 opt_audio_codec("mp2");
3607 opt_frame_size(norm ? "480x480" : "480x576");
3608 opt_frame_rate(frame_rates[norm]);
3609 opt_default("gop", norm ? "18" : "15");
3611 opt_default("b", "2040000");
3612 opt_default("maxrate", "2516000");
3613 opt_default("minrate", "0"); //1145000;
3614 opt_default("bufsize", "1835008"); //224*1024*8;
3615 opt_default("flags", "+SCAN_OFFSET");
3618 opt_default("ab", "224000");
3619 audio_sample_rate = 44100;
3621 opt_default("packetsize", "2324");
3623 } else if(!strcmp(arg, "dvd")) {
3625 opt_video_codec("mpeg2video");
3626 opt_audio_codec("ac3");
3629 opt_frame_size(norm ? "720x480" : "720x576");
3630 opt_frame_rate(frame_rates[norm]);
3631 opt_default("gop", norm ? "18" : "15");
3633 opt_default("b", "6000000");
3634 opt_default("maxrate", "9000000");
3635 opt_default("minrate", "0"); //1500000;
3636 opt_default("bufsize", "1835008"); //224*1024*8;
3638 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3639 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3641 opt_default("ab", "448000");
3642 audio_sample_rate = 48000;
3644 } else if(!strncmp(arg, "dv", 2)) {
3648 opt_frame_size(norm ? "720x480" : "720x576");
3649 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3650 (norm ? "yuv411p" : "yuv420p"));
3651 opt_frame_rate(frame_rates[norm]);
3653 audio_sample_rate = 48000;
3657 fprintf(stderr, "Unknown target: %s\n", arg);
3662 static void opt_vstats_file (const char *arg)
3664 av_free (vstats_filename);
3665 vstats_filename=av_strdup (arg);
3668 static void opt_vstats (void)
3671 time_t today2 = time(NULL);
3672 struct tm *today = localtime(&today2);
3674 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3676 opt_vstats_file(filename);
3679 static int opt_bsf(const char *opt, const char *arg)
3681 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3682 AVBitStreamFilterContext **bsfp;
3685 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3689 bsfp= *opt == 'v' ? &video_bitstream_filters : &audio_bitstream_filters;
3691 bsfp= &(*bsfp)->next;
3698 static void opt_show_license(void)
3704 static void opt_show_version(void)
3706 show_version(program_name);
3710 const OptionDef options[] = {
3712 { "L", 0, {(void*)opt_show_license}, "show license" },
3713 { "h", 0, {(void*)opt_show_help}, "show help" },
3714 { "version", 0, {(void*)opt_show_version}, "show version" },
3715 { "formats", 0, {(void*)opt_show_formats}, "show available formats, codecs, protocols, ..." },
3716 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3717 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3718 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3719 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3720 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3721 { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3722 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //