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
64 static const char program_name[] = "FFmpeg";
65 static const int program_birth_year = 2000;
67 /* select an input stream for an output stream */
68 typedef struct AVStreamMap {
72 int sync_stream_index;
75 /** select an input file for an output file */
76 typedef struct AVMetaDataMap {
81 extern const OptionDef options[];
85 static AVFormatContext *input_files[MAX_FILES];
86 static int64_t input_files_ts_offset[MAX_FILES];
87 static int nb_input_files = 0;
89 static AVFormatContext *output_files[MAX_FILES];
90 static int nb_output_files = 0;
92 static AVStreamMap stream_maps[MAX_FILES];
93 static int nb_stream_maps;
95 static AVMetaDataMap meta_data_maps[MAX_FILES];
96 static int nb_meta_data_maps;
98 static AVInputFormat *file_iformat;
99 static AVOutputFormat *file_oformat;
100 static int frame_width = 0;
101 static int frame_height = 0;
102 static float frame_aspect_ratio = 0;
103 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
104 static int frame_padtop = 0;
105 static int frame_padbottom = 0;
106 static int frame_padleft = 0;
107 static int frame_padright = 0;
108 static int padcolor[3] = {16,128,128}; /* default to black */
109 static int frame_topBand = 0;
110 static int frame_bottomBand = 0;
111 static int frame_leftBand = 0;
112 static int frame_rightBand = 0;
113 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
114 static AVRational frame_rate = (AVRational) {0,0};
115 static float video_qscale = 0;
116 static int video_qdiff = 3;
117 static uint16_t *intra_matrix = NULL;
118 static uint16_t *inter_matrix = NULL;
119 #if 0 //experimental, (can be removed)
120 static float video_rc_qsquish=1.0;
121 static float video_rc_qmod_amp=0;
122 static int video_rc_qmod_freq=0;
124 static const char *video_rc_override_string=NULL;
125 static int video_disable = 0;
126 static int video_discard = 0;
127 static char *video_codec_name = NULL;
128 static int video_codec_tag = 0;
129 static int same_quality = 0;
130 static int do_deinterlace = 0;
131 static int strict = 0;
132 static int top_field_first = -1;
133 static int me_threshold = 0;
134 static int intra_dc_precision = 8;
135 static int loop_input = 0;
136 static int loop_output = AVFMT_NOOUTPUTLOOP;
137 static int qp_hist = 0;
139 static int intra_only = 0;
140 static int audio_sample_rate = 44100;
141 #define QSCALE_NONE -99999
142 static float audio_qscale = QSCALE_NONE;
143 static int audio_disable = 0;
144 static int audio_channels = 1;
145 static char *audio_codec_name = NULL;
146 static int audio_codec_tag = 0;
147 static char *audio_language = NULL;
149 static int subtitle_disable = 0;
150 static char *subtitle_codec_name = NULL;
151 static char *subtitle_language = NULL;
153 static float mux_preload= 0.5;
154 static float mux_max_delay= 0.7;
156 static int64_t recording_time = 0;
157 static int64_t start_time = 0;
158 static int64_t rec_timestamp = 0;
159 static int64_t input_ts_offset = 0;
160 static int file_overwrite = 0;
161 static char *str_title = NULL;
162 static char *str_author = NULL;
163 static char *str_copyright = NULL;
164 static char *str_comment = NULL;
165 static char *str_genre = NULL;
166 static char *str_album = NULL;
167 static int do_benchmark = 0;
168 static int do_hex_dump = 0;
169 static int do_pkt_dump = 0;
170 static int do_psnr = 0;
171 static int do_pass = 0;
172 static char *pass_logfilename = NULL;
173 static int audio_stream_copy = 0;
174 static int video_stream_copy = 0;
175 static int subtitle_stream_copy = 0;
176 static int video_sync_method= 1;
177 static int audio_sync_method= 0;
178 static float audio_drift_threshold= 0.1;
179 static int copy_ts= 0;
180 static int opt_shortest = 0; //
181 static int video_global_header = 0;
182 static char *vstats_filename;
183 static FILE *vstats_file;
184 static int opt_programid = 0;
186 static int rate_emu = 0;
188 static int video_channel = 0;
189 static char *video_standard;
191 static int audio_volume = 256;
193 static int using_stdin = 0;
194 static int using_vhook = 0;
195 static int verbose = 1;
196 static int thread_count= 1;
197 static int q_pressed = 0;
198 static int64_t video_size = 0;
199 static int64_t audio_size = 0;
200 static int64_t extra_size = 0;
201 static int nb_frames_dup = 0;
202 static int nb_frames_drop = 0;
203 static int input_sync;
204 static uint64_t limit_filesize = 0; //
206 static int pgmyuv_compatibility_hack=0;
207 static float dts_delta_threshold = 10;
209 static unsigned int sws_flags = SWS_BICUBIC;
211 static const char **opt_names;
212 static int opt_name_count;
213 static AVCodecContext *avctx_opts[CODEC_TYPE_NB];
214 static AVFormatContext *avformat_opts;
215 static struct SwsContext *sws_opts;
216 static int64_t timer_start;
218 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
219 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
220 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
221 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
223 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
225 struct AVInputStream;
227 typedef struct AVOutputStream {
228 int file_index; /* file index */
229 int index; /* stream index in the output file */
230 int source_index; /* AVInputStream index */
231 AVStream *st; /* stream in the output file */
232 int encoding_needed; /* true if encoding needed for this stream */
234 /* input pts and corresponding output pts
236 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
237 struct AVInputStream *sync_ist; /* input stream to sync against */
238 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
241 AVFrame pict_tmp; /* temporary image for resampling */
242 struct SwsContext *img_resample_ctx; /* for image resampling */
246 int topBand; /* cropping area sizes */
250 int padtop; /* padding area sizes */
257 ReSampleContext *resample; /* for audio resampling */
258 AVFifoBuffer fifo; /* for compression: one audio fifo per codec */
262 typedef struct AVInputStream {
266 int discard; /* true if stream data should be discarded */
267 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
268 int64_t sample_index; /* current sample */
270 int64_t start; /* time when read started */
271 unsigned long frame; /* current frame */
272 int64_t next_pts; /* synthetic pts for cases where pkt.pts
274 int64_t pts; /* current pts */
275 int is_start; /* is 1 at the start and after a discontinuity */
278 typedef struct AVInputFile {
279 int eof_reached; /* true if eof reached */
280 int ist_index; /* index of first stream in ist_table */
281 int buffer_size; /* current total buffer size */
282 int nb_streams; /* nb streams we are aware of */
285 #ifdef HAVE_TERMIOS_H
287 /* init terminal so that we can grab keys */
288 static struct termios oldtty;
291 static void term_exit(void)
293 #ifdef HAVE_TERMIOS_H
294 tcsetattr (0, TCSANOW, &oldtty);
298 static volatile sig_atomic_t received_sigterm = 0;
301 sigterm_handler(int sig)
303 received_sigterm = sig;
307 static void term_init(void)
309 #ifdef HAVE_TERMIOS_H
315 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
316 |INLCR|IGNCR|ICRNL|IXON);
317 tty.c_oflag |= OPOST;
318 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
319 tty.c_cflag &= ~(CSIZE|PARENB);
324 tcsetattr (0, TCSANOW, &tty);
325 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
328 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
329 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
331 register a function to be called at normal program termination
334 #ifdef CONFIG_BEOS_NETSERVER
335 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
339 /* read a key without blocking */
340 static int read_key(void)
342 #if defined(HAVE_TERMIOS_H)
345 #ifndef CONFIG_BEOS_NETSERVER
353 n = select(1, &rfds, NULL, NULL, &tv);
362 #elif defined(HAVE_CONIO_H)
369 static int decode_interrupt_cb(void)
371 return q_pressed || (q_pressed = read_key() == 'q');
374 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
379 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
382 /* copy stream format */
383 s->nb_streams = ic->nb_streams;
384 for(i=0;i<ic->nb_streams;i++) {
387 // FIXME: a more elegant solution is needed
388 st = av_mallocz(sizeof(AVStream));
389 memcpy(st, ic->streams[i], sizeof(AVStream));
390 st->codec = avcodec_alloc_context();
391 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
395 av_close_input_file(ic);
400 get_sync_ipts(const AVOutputStream *ost)
402 const AVInputStream *ist = ost->sync_ist;
403 return (double)(ist->pts - start_time)/AV_TIME_BASE;
406 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
410 AVPacket new_pkt= *pkt;
411 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
412 &new_pkt.data, &new_pkt.size,
413 pkt->data, pkt->size,
414 pkt->flags & PKT_FLAG_KEY);
417 new_pkt.destruct= av_destruct_packet;
419 fprintf(stderr, "%s failed for stream %d, codec %s",
420 bsfc->filter->name, pkt->stream_index,
421 avctx->codec ? avctx->codec->name : "copy");
429 ret= av_interleaved_write_frame(s, pkt);
431 print_error("av_interleaved_write_frame()", ret);
436 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
438 static void do_audio_out(AVFormatContext *s,
441 unsigned char *buf, int size)
444 static uint8_t *audio_buf = NULL;
445 static uint8_t *audio_out = NULL;
446 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
448 int size_out, frame_bytes, ret;
449 AVCodecContext *enc= ost->st->codec;
450 AVCodecContext *dec= ist->st->codec;
452 /* SC: dynamic allocation of buffers */
454 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
456 audio_out = av_malloc(audio_out_size);
457 if (!audio_buf || !audio_out)
458 return; /* Should signal an error ! */
460 if (enc->channels != dec->channels)
461 ost->audio_resample = 1;
463 if (ost->audio_resample && !ost->resample) {
464 ost->resample = audio_resample_init(enc->channels, dec->channels,
465 enc->sample_rate, dec->sample_rate);
466 if (!ost->resample) {
467 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
468 dec->channels, dec->sample_rate,
469 enc->channels, enc->sample_rate);
474 if(audio_sync_method){
475 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
476 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
477 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
478 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
480 //FIXME resample delay
481 if(fabs(delta) > 50){
482 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
484 byte_delta= FFMAX(byte_delta, -size);
488 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
493 static uint8_t *input_tmp= NULL;
494 input_tmp= av_realloc(input_tmp, byte_delta + size);
496 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
499 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
501 memset(input_tmp, 0, byte_delta);
502 memcpy(input_tmp + byte_delta, buf, size);
506 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
508 }else if(audio_sync_method>1){
509 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
510 assert(ost->audio_resample);
512 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
513 // 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));
514 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
518 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
519 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
521 if (ost->audio_resample) {
523 size_out = audio_resample(ost->resample,
524 (short *)buftmp, (short *)buf,
525 size / (ist->st->codec->channels * 2));
526 size_out = size_out * enc->channels * 2;
532 /* now encode as many frames as possible */
533 if (enc->frame_size > 1) {
534 /* output resampled raw samples */
535 av_fifo_realloc(&ost->fifo, av_fifo_size(&ost->fifo) + size_out + 1);
536 av_fifo_write(&ost->fifo, buftmp, size_out);
538 frame_bytes = enc->frame_size * 2 * enc->channels;
540 while (av_fifo_read(&ost->fifo, audio_buf, frame_bytes) == 0) {
542 av_init_packet(&pkt);
544 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
546 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
549 pkt.stream_index= ost->index;
552 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
553 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
554 pkt.flags |= PKT_FLAG_KEY;
555 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
557 ost->sync_opts += enc->frame_size;
561 av_init_packet(&pkt);
563 ost->sync_opts += size_out / (2 * enc->channels);
565 /* output a pcm frame */
566 /* XXX: change encoding codec API to avoid this ? */
567 switch(enc->codec->id) {
568 case CODEC_ID_PCM_S32LE:
569 case CODEC_ID_PCM_S32BE:
570 case CODEC_ID_PCM_U32LE:
571 case CODEC_ID_PCM_U32BE:
572 size_out = size_out << 1;
574 case CODEC_ID_PCM_S24LE:
575 case CODEC_ID_PCM_S24BE:
576 case CODEC_ID_PCM_U24LE:
577 case CODEC_ID_PCM_U24BE:
578 case CODEC_ID_PCM_S24DAUD:
579 size_out = size_out / 2 * 3;
581 case CODEC_ID_PCM_S16LE:
582 case CODEC_ID_PCM_S16BE:
583 case CODEC_ID_PCM_U16LE:
584 case CODEC_ID_PCM_U16BE:
587 size_out = size_out >> 1;
590 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
591 ret = avcodec_encode_audio(enc, audio_out, size_out,
594 pkt.stream_index= ost->index;
597 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
598 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
599 pkt.flags |= PKT_FLAG_KEY;
600 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
604 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
608 AVPicture picture_tmp;
611 dec = ist->st->codec;
613 /* deinterlace : must be done before any resize */
614 if (do_deinterlace || using_vhook) {
617 /* create temporary picture */
618 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
619 buf = av_malloc(size);
623 picture2 = &picture_tmp;
624 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
627 if(avpicture_deinterlace(picture2, picture,
628 dec->pix_fmt, dec->width, dec->height) < 0) {
629 /* if error, do not deinterlace */
635 av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
642 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,
643 1000000 * ist->pts / AV_TIME_BASE);
645 if (picture != picture2)
646 *picture = *picture2;
650 /* we begin to correct av delay at this threshold */
651 #define AV_DELAY_MAX 0.100
653 static void do_subtitle_out(AVFormatContext *s,
659 static uint8_t *subtitle_out = NULL;
660 int subtitle_out_max_size = 65536;
661 int subtitle_out_size, nb, i;
665 if (pts == AV_NOPTS_VALUE) {
666 fprintf(stderr, "Subtitle packets must have a pts\n");
670 enc = ost->st->codec;
673 subtitle_out = av_malloc(subtitle_out_max_size);
676 /* Note: DVB subtitle need one packet to draw them and one other
677 packet to clear them */
678 /* XXX: signal it in the codec context ? */
679 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
684 for(i = 0; i < nb; i++) {
685 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
686 subtitle_out_max_size, sub);
688 av_init_packet(&pkt);
689 pkt.stream_index = ost->index;
690 pkt.data = subtitle_out;
691 pkt.size = subtitle_out_size;
692 pkt.pts = av_rescale_q(pts, ist->st->time_base, ost->st->time_base);
693 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
694 /* XXX: the pts correction is handled here. Maybe handling
695 it in the codec would be better */
697 pkt.pts += 90 * sub->start_display_time;
699 pkt.pts += 90 * sub->end_display_time;
701 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
705 static int bit_buffer_size= 1024*256;
706 static uint8_t *bit_buffer= NULL;
708 static void do_video_out(AVFormatContext *s,
714 int nb_frames, i, ret;
715 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
716 AVFrame picture_crop_temp, picture_pad_temp;
717 AVCodecContext *enc, *dec;
719 avcodec_get_frame_defaults(&picture_crop_temp);
720 avcodec_get_frame_defaults(&picture_pad_temp);
722 enc = ost->st->codec;
723 dec = ist->st->codec;
725 /* by default, we output a single frame */
730 if(video_sync_method){
732 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
733 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
736 else if (video_sync_method == 2)
737 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
738 else if (vdelta > 1.1)
739 nb_frames = lrintf(vdelta);
740 //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);
744 fprintf(stderr, "*** drop!\n");
745 }else if (nb_frames > 1) {
746 nb_frames_dup += nb_frames;
748 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
751 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
753 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
757 if (ost->video_crop) {
758 if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
759 av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
762 formatted_picture = &picture_crop_temp;
764 formatted_picture = in_picture;
767 final_picture = formatted_picture;
768 padding_src = formatted_picture;
769 resampling_dst = &ost->pict_tmp;
770 if (ost->video_pad) {
771 final_picture = &ost->pict_tmp;
772 if (ost->video_resample) {
773 if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
774 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
777 resampling_dst = &picture_pad_temp;
781 if (ost->video_resample) {
783 final_picture = &ost->pict_tmp;
784 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
785 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
788 if (ost->video_pad) {
789 av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
790 enc->height, enc->width, enc->pix_fmt,
791 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
794 /* duplicates frame if needed */
795 for(i=0;i<nb_frames;i++) {
797 av_init_packet(&pkt);
798 pkt.stream_index= ost->index;
800 if (s->oformat->flags & AVFMT_RAWPICTURE) {
801 /* raw pictures are written as AVPicture structure to
802 avoid any copies. We support temorarily the older
804 AVFrame* old_frame = enc->coded_frame;
805 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
806 pkt.data= (uint8_t *)final_picture;
807 pkt.size= sizeof(AVPicture);
808 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
809 pkt.flags |= PKT_FLAG_KEY;
811 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
812 enc->coded_frame = old_frame;
816 big_picture= *final_picture;
817 /* better than nothing: use input picture interlaced
819 big_picture.interlaced_frame = in_picture->interlaced_frame;
820 if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
821 if(top_field_first == -1)
822 big_picture.top_field_first = in_picture->top_field_first;
824 big_picture.top_field_first = top_field_first;
827 /* handles sameq here. This is not correct because it may
828 not be a global option */
830 big_picture.quality = ist->st->quality;
832 big_picture.quality = ost->st->quality;
834 big_picture.pict_type = 0;
835 // big_picture.pts = AV_NOPTS_VALUE;
836 big_picture.pts= ost->sync_opts;
837 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
838 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
839 ret = avcodec_encode_video(enc,
840 bit_buffer, bit_buffer_size,
843 fprintf(stderr, "Video encoding failed\n");
846 //enc->frame_number = enc->real_pict_num;
848 pkt.data= bit_buffer;
850 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
851 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
852 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
853 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
854 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
856 if(enc->coded_frame && enc->coded_frame->key_frame)
857 pkt.flags |= PKT_FLAG_KEY;
858 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
860 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
861 // enc->frame_number-1, enc->real_pict_num, ret,
863 /* if two pass, output log */
864 if (ost->logfile && enc->stats_out) {
865 fprintf(ost->logfile, "%s", enc->stats_out);
874 static double psnr(double d){
875 return -10.0*log(d)/log(10.0);
878 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
883 double ti1, bitrate, avg_bitrate;
885 /* this is executed just the first time do_video_stats is called */
887 vstats_file = fopen(vstats_filename, "w");
894 enc = ost->st->codec;
895 if (enc->codec_type == CODEC_TYPE_VIDEO) {
896 frame_number = ost->frame_number;
897 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
898 if (enc->flags&CODEC_FLAG_PSNR)
899 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
901 fprintf(vstats_file,"f_size= %6d ", frame_size);
902 /* compute pts value */
903 ti1 = ost->sync_opts * av_q2d(enc->time_base);
907 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
908 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
909 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
910 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
911 fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
915 static void print_report(AVFormatContext **output_files,
916 AVOutputStream **ost_table, int nb_ostreams,
921 AVFormatContext *oc, *os;
924 int frame_number, vid, i;
925 double bitrate, ti1, pts;
926 static int64_t last_time = -1;
927 static int qp_histogram[52];
929 if (!is_last_report) {
931 /* display the report every 0.5 seconds */
932 cur_time = av_gettime();
933 if (last_time == -1) {
934 last_time = cur_time;
937 if ((cur_time - last_time) < 500000)
939 last_time = cur_time;
943 oc = output_files[0];
945 total_size = url_fsize(oc->pb);
946 if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
947 total_size= url_ftell(oc->pb);
952 for(i=0;i<nb_ostreams;i++) {
954 os = output_files[ost->file_index];
955 enc = ost->st->codec;
956 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
957 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
958 enc->coded_frame && !ost->st->stream_copy ?
959 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
961 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
962 float t = (av_gettime()-timer_start) / 1000000.0;
964 frame_number = ost->frame_number;
965 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
966 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
967 enc->coded_frame && !ost->st->stream_copy ?
968 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
970 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
971 if(qp_hist && enc->coded_frame){
973 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
974 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
977 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
979 if (enc->flags&CODEC_FLAG_PSNR){
981 double error, error_sum=0;
982 double scale, scale_sum=0;
983 char type[3]= {'Y','U','V'};
984 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
987 error= enc->error[j];
988 scale= enc->width*enc->height*255.0*255.0*frame_number;
990 error= enc->coded_frame->error[j];
991 scale= enc->width*enc->height*255.0*255.0;
996 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
998 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1002 /* compute min output value */
1003 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1004 if ((pts < ti1) && (pts > 0))
1010 if (verbose || is_last_report) {
1011 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1013 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1014 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1015 (double)total_size / 1024, ti1, bitrate);
1018 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1019 nb_frames_dup, nb_frames_drop);
1022 fprintf(stderr, "%s \r", buf);
1027 if (is_last_report && verbose >= 0){
1028 int64_t raw= audio_size + video_size + extra_size;
1029 fprintf(stderr, "\n");
1030 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1034 100.0*(total_size - raw)/raw
1039 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1040 static int output_packet(AVInputStream *ist, int ist_index,
1041 AVOutputStream **ost_table, int nb_ostreams,
1042 const AVPacket *pkt)
1044 AVFormatContext *os;
1045 AVOutputStream *ost;
1049 int data_size, got_picture;
1051 void *buffer_to_free;
1052 static unsigned int samples_size= 0;
1053 static short *samples= NULL;
1054 AVSubtitle subtitle, *subtitle_to_free;
1057 if(ist->next_pts == AV_NOPTS_VALUE)
1058 ist->next_pts= ist->pts;
1067 if(pkt->dts != AV_NOPTS_VALUE)
1068 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1074 ist->pts= ist->next_pts;
1076 if(len && len != pkt->size && verbose>0)
1077 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1079 /* decode the packet if needed */
1080 data_buf = NULL; /* fail safe */
1082 subtitle_to_free = NULL;
1083 if (ist->decoding_needed) {
1084 switch(ist->st->codec->codec_type) {
1085 case CODEC_TYPE_AUDIO:{
1087 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE));
1088 data_size= samples_size;
1089 /* XXX: could avoid copy if PCM 16 bits with same
1090 endianness as CPU */
1091 ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1097 /* Some bug in mpeg audio decoder gives */
1098 /* data_size < 0, it seems they are overflows */
1099 if (data_size <= 0) {
1100 /* no audio frame */
1103 data_buf = (uint8_t *)samples;
1104 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1105 (ist->st->codec->sample_rate * ist->st->codec->channels);
1107 case CODEC_TYPE_VIDEO:
1108 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1109 /* XXX: allocate picture correctly */
1110 avcodec_get_frame_defaults(&picture);
1112 ret = avcodec_decode_video(ist->st->codec,
1113 &picture, &got_picture, ptr, len);
1114 ist->st->quality= picture.quality;
1118 /* no picture yet */
1119 goto discard_packet;
1121 if (ist->st->codec->time_base.num != 0) {
1122 ist->next_pts += ((int64_t)AV_TIME_BASE *
1123 ist->st->codec->time_base.num) /
1124 ist->st->codec->time_base.den;
1128 case CODEC_TYPE_SUBTITLE:
1129 ret = avcodec_decode_subtitle(ist->st->codec,
1130 &subtitle, &got_subtitle, ptr, len);
1133 if (!got_subtitle) {
1134 goto discard_packet;
1136 subtitle_to_free = &subtitle;
1143 switch(ist->st->codec->codec_type) {
1144 case CODEC_TYPE_AUDIO:
1145 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1146 ist->st->codec->sample_rate;
1148 case CODEC_TYPE_VIDEO:
1149 if (ist->st->codec->time_base.num != 0) {
1150 ist->next_pts += ((int64_t)AV_TIME_BASE *
1151 ist->st->codec->time_base.num) /
1152 ist->st->codec->time_base.den;
1162 buffer_to_free = NULL;
1163 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1164 pre_process_video_frame(ist, (AVPicture *)&picture,
1168 // preprocess audio (volume)
1169 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1170 if (audio_volume != 256) {
1173 for(i=0;i<(data_size / sizeof(short));i++) {
1174 int v = ((*volp) * audio_volume + 128) >> 8;
1175 if (v < -32768) v = -32768;
1176 if (v > 32767) v = 32767;
1182 /* frame rate emulation */
1183 if (ist->st->codec->rate_emu) {
1184 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1185 int64_t now = av_gettime() - ist->start;
1193 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1194 is the one of the next displayed one */
1195 /* XXX: add mpeg4 too ? */
1196 if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1197 if (ist->st->codec->pict_type != B_TYPE) {
1199 tmp = ist->last_ip_pts;
1200 ist->last_ip_pts = ist->frac_pts.val;
1201 ist->frac_pts.val = tmp;
1205 /* if output time reached then transcode raw format,
1206 encode packets and output them */
1207 if (start_time == 0 || ist->pts >= start_time)
1208 for(i=0;i<nb_ostreams;i++) {
1212 if (ost->source_index == ist_index) {
1213 os = output_files[ost->file_index];
1216 printf("%d: got pts=%0.3f %0.3f\n", i,
1217 (double)pkt->pts / AV_TIME_BASE,
1218 ((double)ist->pts / AV_TIME_BASE) -
1219 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1221 /* set the input output pts pairs */
1222 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1224 if (ost->encoding_needed) {
1225 switch(ost->st->codec->codec_type) {
1226 case CODEC_TYPE_AUDIO:
1227 do_audio_out(os, ost, ist, data_buf, data_size);
1229 case CODEC_TYPE_VIDEO:
1230 do_video_out(os, ost, ist, &picture, &frame_size);
1231 video_size += frame_size;
1232 if (vstats_filename && frame_size)
1233 do_video_stats(os, ost, frame_size);
1235 case CODEC_TYPE_SUBTITLE:
1236 do_subtitle_out(os, ost, ist, &subtitle,
1243 AVFrame avframe; //FIXME/XXX remove this
1245 av_init_packet(&opkt);
1247 if (!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY))
1250 /* no reencoding needed : output the packet directly */
1251 /* force the input stream PTS */
1253 avcodec_get_frame_defaults(&avframe);
1254 ost->st->codec->coded_frame= &avframe;
1255 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1257 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1258 audio_size += data_size;
1259 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1260 video_size += data_size;
1264 opkt.stream_index= ost->index;
1265 if(pkt->pts != AV_NOPTS_VALUE)
1266 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1268 opkt.pts= AV_NOPTS_VALUE;
1270 if (pkt->dts == AV_NOPTS_VALUE)
1271 opkt.dts = av_rescale_q(ist->next_pts, AV_TIME_BASE_Q, ost->st->time_base);
1273 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1275 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1276 opkt.flags= pkt->flags;
1278 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1279 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1280 opkt.destruct= av_destruct_packet;
1282 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1283 ost->st->codec->frame_number++;
1284 ost->frame_number++;
1285 av_free_packet(&opkt);
1289 av_free(buffer_to_free);
1290 /* XXX: allocate the subtitles in the codec ? */
1291 if (subtitle_to_free) {
1292 if (subtitle_to_free->rects != NULL) {
1293 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1294 av_free(subtitle_to_free->rects[i].bitmap);
1295 av_free(subtitle_to_free->rects[i].rgba_palette);
1297 av_freep(&subtitle_to_free->rects);
1299 subtitle_to_free->num_rects = 0;
1300 subtitle_to_free = NULL;
1307 for(i=0;i<nb_ostreams;i++) {
1309 if (ost->source_index == ist_index) {
1310 AVCodecContext *enc= ost->st->codec;
1311 os = output_files[ost->file_index];
1313 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1315 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1318 if (ost->encoding_needed) {
1322 av_init_packet(&pkt);
1323 pkt.stream_index= ost->index;
1325 switch(ost->st->codec->codec_type) {
1326 case CODEC_TYPE_AUDIO:
1327 fifo_bytes = av_fifo_size(&ost->fifo);
1329 /* encode any samples remaining in fifo */
1330 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1331 int fs_tmp = enc->frame_size;
1332 enc->frame_size = fifo_bytes / (2 * enc->channels);
1333 if(av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes) == 0) {
1334 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1336 enc->frame_size = fs_tmp;
1339 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1342 pkt.flags |= PKT_FLAG_KEY;
1344 case CODEC_TYPE_VIDEO:
1345 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1347 if(enc->coded_frame && enc->coded_frame->key_frame)
1348 pkt.flags |= PKT_FLAG_KEY;
1349 if (ost->logfile && enc->stats_out) {
1350 fprintf(ost->logfile, "%s", enc->stats_out);
1359 pkt.data= bit_buffer;
1361 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1362 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1363 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1375 static void print_sdp(AVFormatContext **avc, int n)
1379 avf_sdp_create(avc, n, sdp, sizeof(sdp));
1380 printf("SDP:\n%s\n", sdp);
1383 static int stream_index_from_inputs(AVFormatContext **input_files,
1385 AVInputFile *file_table,
1386 AVInputStream **ist_table,
1387 enum CodecType type,
1391 for(z=0; z<nb_input_files; z++) {
1392 AVFormatContext *ic = input_files[z];
1393 for(p=0; p<ic->nb_programs; p++) {
1394 AVProgram *program = ic->programs[p];
1395 if(program->id != programid)
1397 for(q=0; q<program->nb_stream_indexes; q++) {
1398 int sidx = program->stream_index[q];
1399 int ris = file_table[z].ist_index + sidx;
1400 if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1410 * The following code is the main loop of the file converter
1412 static int av_encode(AVFormatContext **output_files,
1413 int nb_output_files,
1414 AVFormatContext **input_files,
1416 AVStreamMap *stream_maps, int nb_stream_maps)
1418 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1419 AVFormatContext *is, *os;
1420 AVCodecContext *codec, *icodec;
1421 AVOutputStream *ost, **ost_table = NULL;
1422 AVInputStream *ist, **ist_table = NULL;
1423 AVInputFile *file_table;
1427 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1431 /* input stream init */
1433 for(i=0;i<nb_input_files;i++) {
1434 is = input_files[i];
1435 file_table[i].ist_index = j;
1436 file_table[i].nb_streams = is->nb_streams;
1437 j += is->nb_streams;
1441 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1445 for(i=0;i<nb_istreams;i++) {
1446 ist = av_mallocz(sizeof(AVInputStream));
1452 for(i=0;i<nb_input_files;i++) {
1453 is = input_files[i];
1454 for(k=0;k<is->nb_streams;k++) {
1455 ist = ist_table[j++];
1456 ist->st = is->streams[k];
1457 ist->file_index = i;
1459 ist->discard = 1; /* the stream is discarded by default
1462 if (ist->st->codec->rate_emu) {
1463 ist->start = av_gettime();
1469 /* output stream init */
1471 for(i=0;i<nb_output_files;i++) {
1472 os = output_files[i];
1473 if (!os->nb_streams) {
1474 fprintf(stderr, "Output file does not contain any stream\n");
1477 nb_ostreams += os->nb_streams;
1479 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1480 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1484 /* Sanity check the mapping args -- do the input files & streams exist? */
1485 for(i=0;i<nb_stream_maps;i++) {
1486 int fi = stream_maps[i].file_index;
1487 int si = stream_maps[i].stream_index;
1489 if (fi < 0 || fi > nb_input_files - 1 ||
1490 si < 0 || si > file_table[fi].nb_streams - 1) {
1491 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1494 fi = stream_maps[i].sync_file_index;
1495 si = stream_maps[i].sync_stream_index;
1496 if (fi < 0 || fi > nb_input_files - 1 ||
1497 si < 0 || si > file_table[fi].nb_streams - 1) {
1498 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1503 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1506 for(i=0;i<nb_ostreams;i++) {
1507 ost = av_mallocz(sizeof(AVOutputStream));
1514 for(k=0;k<nb_output_files;k++) {
1515 os = output_files[k];
1516 for(i=0;i<os->nb_streams;i++) {
1518 ost = ost_table[n++];
1519 ost->file_index = k;
1521 ost->st = os->streams[i];
1522 if (nb_stream_maps > 0) {
1523 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1524 stream_maps[n-1].stream_index;
1526 /* Sanity check that the stream types match */
1527 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1528 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1529 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1530 ost->file_index, ost->index);
1537 j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1539 ost->source_index = j;
1543 /* get corresponding input stream index : we select the first one with the right type */
1545 for(j=0;j<nb_istreams;j++) {
1548 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1549 ost->source_index = j;
1557 if(! opt_programid) {
1558 /* try again and reuse existing stream */
1559 for(j=0;j<nb_istreams;j++) {
1561 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1562 ost->source_index = j;
1568 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1569 ost->file_index, ost->index);
1574 ist = ist_table[ost->source_index];
1576 ost->sync_ist = (nb_stream_maps > 0) ?
1577 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1578 stream_maps[n-1].sync_stream_index] : ist;
1582 /* for each output stream, we compute the right encoding parameters */
1583 for(i=0;i<nb_ostreams;i++) {
1585 os = output_files[ost->file_index];
1586 ist = ist_table[ost->source_index];
1588 codec = ost->st->codec;
1589 icodec = ist->st->codec;
1591 if (!ost->st->language[0])
1592 av_strlcpy(ost->st->language, ist->st->language,
1593 sizeof(ost->st->language));
1595 ost->st->disposition = ist->st->disposition;
1597 if (ost->st->stream_copy) {
1598 /* if stream_copy is selected, no need to decode or encode */
1599 codec->codec_id = icodec->codec_id;
1600 codec->codec_type = icodec->codec_type;
1602 if(!codec->codec_tag){
1603 if( !os->oformat->codec_tag
1604 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1605 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1606 codec->codec_tag = icodec->codec_tag;
1609 codec->bit_rate = icodec->bit_rate;
1610 codec->extradata= icodec->extradata;
1611 codec->extradata_size= icodec->extradata_size;
1612 if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1613 codec->time_base = icodec->time_base;
1615 codec->time_base = ist->st->time_base;
1616 switch(codec->codec_type) {
1617 case CODEC_TYPE_AUDIO:
1618 codec->sample_rate = icodec->sample_rate;
1619 codec->channels = icodec->channels;
1620 codec->frame_size = icodec->frame_size;
1621 codec->block_align= icodec->block_align;
1622 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1623 codec->block_align= 0;
1625 case CODEC_TYPE_VIDEO:
1627 fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1630 codec->pix_fmt = icodec->pix_fmt;
1631 codec->width = icodec->width;
1632 codec->height = icodec->height;
1633 codec->has_b_frames = icodec->has_b_frames;
1635 case CODEC_TYPE_SUBTITLE:
1641 switch(codec->codec_type) {
1642 case CODEC_TYPE_AUDIO:
1643 if (av_fifo_init(&ost->fifo, 1024))
1645 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1646 icodec->request_channels = codec->channels;
1647 ist->decoding_needed = 1;
1648 ost->encoding_needed = 1;
1650 case CODEC_TYPE_VIDEO:
1651 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1652 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1653 ost->video_resample = ((codec->width != icodec->width -
1654 (frame_leftBand + frame_rightBand) +
1655 (frame_padleft + frame_padright)) ||
1656 (codec->height != icodec->height -
1657 (frame_topBand + frame_bottomBand) +
1658 (frame_padtop + frame_padbottom)) ||
1659 (codec->pix_fmt != icodec->pix_fmt));
1660 if (ost->video_crop) {
1661 ost->topBand = frame_topBand;
1662 ost->leftBand = frame_leftBand;
1664 if (ost->video_pad) {
1665 ost->padtop = frame_padtop;
1666 ost->padleft = frame_padleft;
1667 ost->padbottom = frame_padbottom;
1668 ost->padright = frame_padright;
1669 if (!ost->video_resample) {
1670 avcodec_get_frame_defaults(&ost->pict_tmp);
1671 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1672 codec->width, codec->height ) )
1676 if (ost->video_resample) {
1677 avcodec_get_frame_defaults(&ost->pict_tmp);
1678 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1679 codec->width, codec->height ) ) {
1680 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1683 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1684 ost->img_resample_ctx = sws_getContext(
1685 icodec->width - (frame_leftBand + frame_rightBand),
1686 icodec->height - (frame_topBand + frame_bottomBand),
1688 codec->width - (frame_padleft + frame_padright),
1689 codec->height - (frame_padtop + frame_padbottom),
1691 sws_flags, NULL, NULL, NULL);
1692 if (ost->img_resample_ctx == NULL) {
1693 fprintf(stderr, "Cannot get resampling context\n");
1696 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1698 ost->encoding_needed = 1;
1699 ist->decoding_needed = 1;
1701 case CODEC_TYPE_SUBTITLE:
1702 ost->encoding_needed = 1;
1703 ist->decoding_needed = 1;
1710 if (ost->encoding_needed &&
1711 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1712 char logfilename[1024];
1717 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1719 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1720 if (codec->flags & CODEC_FLAG_PASS1) {
1721 f = fopen(logfilename, "w");
1723 perror(logfilename);
1728 /* read the log file */
1729 f = fopen(logfilename, "r");
1731 perror(logfilename);
1734 fseek(f, 0, SEEK_END);
1736 fseek(f, 0, SEEK_SET);
1737 logbuffer = av_malloc(size + 1);
1739 fprintf(stderr, "Could not allocate log buffer\n");
1742 size = fread(logbuffer, 1, size, f);
1744 logbuffer[size] = '\0';
1745 codec->stats_in = logbuffer;
1749 if(codec->codec_type == CODEC_TYPE_VIDEO){
1750 int size= codec->width * codec->height;
1751 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1756 bit_buffer = av_malloc(bit_buffer_size);
1760 /* dump the file output parameters - cannot be done before in case
1762 for(i=0;i<nb_output_files;i++) {
1763 dump_format(output_files[i], i, output_files[i]->filename, 1);
1766 /* dump the stream mapping */
1768 fprintf(stderr, "Stream mapping:\n");
1769 for(i=0;i<nb_ostreams;i++) {
1771 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1772 ist_table[ost->source_index]->file_index,
1773 ist_table[ost->source_index]->index,
1776 if (ost->sync_ist != ist_table[ost->source_index])
1777 fprintf(stderr, " [sync #%d.%d]",
1778 ost->sync_ist->file_index,
1779 ost->sync_ist->index);
1780 fprintf(stderr, "\n");
1784 /* open each encoder */
1785 for(i=0;i<nb_ostreams;i++) {
1787 if (ost->encoding_needed) {
1789 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1791 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1792 ost->file_index, ost->index);
1795 if (avcodec_open(ost->st->codec, codec) < 0) {
1796 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1797 ost->file_index, ost->index);
1800 extra_size += ost->st->codec->extradata_size;
1804 /* open each decoder */
1805 for(i=0;i<nb_istreams;i++) {
1807 if (ist->decoding_needed) {
1809 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1811 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1812 ist->st->codec->codec_id, ist->file_index, ist->index);
1815 if (avcodec_open(ist->st->codec, codec) < 0) {
1816 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1817 ist->file_index, ist->index);
1820 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1821 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1826 for(i=0;i<nb_istreams;i++) {
1828 is = input_files[ist->file_index];
1830 ist->next_pts = AV_NOPTS_VALUE;
1834 /* set meta data information from input file if required */
1835 for (i=0;i<nb_meta_data_maps;i++) {
1836 AVFormatContext *out_file;
1837 AVFormatContext *in_file;
1839 int out_file_index = meta_data_maps[i].out_file;
1840 int in_file_index = meta_data_maps[i].in_file;
1841 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1842 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1843 ret = AVERROR(EINVAL);
1846 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1847 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1848 ret = AVERROR(EINVAL);
1852 out_file = output_files[out_file_index];
1853 in_file = input_files[in_file_index];
1855 strcpy(out_file->title, in_file->title);
1856 strcpy(out_file->author, in_file->author);
1857 strcpy(out_file->copyright, in_file->copyright);
1858 strcpy(out_file->comment, in_file->comment);
1859 strcpy(out_file->album, in_file->album);
1860 out_file->year = in_file->year;
1861 out_file->track = in_file->track;
1862 strcpy(out_file->genre, in_file->genre);
1865 /* open files and write file headers */
1866 for(i=0;i<nb_output_files;i++) {
1867 os = output_files[i];
1868 if (av_write_header(os) < 0) {
1869 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1870 ret = AVERROR(EINVAL);
1873 if (strcmp(output_files[i]->oformat->name, "rtp")) {
1878 print_sdp(output_files, nb_output_files);
1881 if ( !using_stdin && verbose >= 0) {
1882 fprintf(stderr, "Press [q] to stop encoding\n");
1883 url_set_interrupt_cb(decode_interrupt_cb);
1888 timer_start = av_gettime();
1890 for(; received_sigterm == 0;) {
1891 int file_index, ist_index;
1899 /* if 'q' pressed, exits */
1903 /* read_key() returns 0 on EOF */
1909 /* select the stream that we must read now by looking at the
1910 smallest output pts */
1912 for(i=0;i<nb_ostreams;i++) {
1915 os = output_files[ost->file_index];
1916 ist = ist_table[ost->source_index];
1917 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1918 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1920 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1921 ipts = (double)ist->pts;
1922 if (!file_table[ist->file_index].eof_reached){
1923 if(ipts < ipts_min) {
1925 if(input_sync ) file_index = ist->file_index;
1927 if(opts < opts_min) {
1929 if(!input_sync) file_index = ist->file_index;
1932 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1937 /* if none, if is finished */
1938 if (file_index < 0) {
1942 /* finish if recording time exhausted */
1943 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1946 /* finish if limit size exhausted */
1947 if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
1950 /* read a frame from it and output it in the fifo */
1951 is = input_files[file_index];
1952 if (av_read_frame(is, &pkt) < 0) {
1953 file_table[file_index].eof_reached = 1;
1961 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
1963 /* the following test is needed in case new streams appear
1964 dynamically in stream : we ignore them */
1965 if (pkt.stream_index >= file_table[file_index].nb_streams)
1966 goto discard_packet;
1967 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1968 ist = ist_table[ist_index];
1970 goto discard_packet;
1972 if (pkt.dts != AV_NOPTS_VALUE)
1973 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
1974 if (pkt.pts != AV_NOPTS_VALUE)
1975 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
1977 // 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);
1978 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1979 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
1980 int64_t delta= pkt_dts - ist->next_pts;
1981 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
1982 input_files_ts_offset[ist->file_index]-= delta;
1984 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1985 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
1986 if(pkt.pts != AV_NOPTS_VALUE)
1987 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
1991 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1992 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1995 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1996 ist->file_index, ist->index);
1998 av_free_packet(&pkt);
2003 av_free_packet(&pkt);
2005 /* dump report by using the output first video and audio streams */
2006 print_report(output_files, ost_table, nb_ostreams, 0);
2009 /* at the end of stream, we must flush the decoder buffers */
2010 for(i=0;i<nb_istreams;i++) {
2012 if (ist->decoding_needed) {
2013 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2019 /* write the trailer if needed and close file */
2020 for(i=0;i<nb_output_files;i++) {
2021 os = output_files[i];
2022 av_write_trailer(os);
2025 /* dump report by using the first video and audio streams */
2026 print_report(output_files, ost_table, nb_ostreams, 1);
2028 /* close each encoder */
2029 for(i=0;i<nb_ostreams;i++) {
2031 if (ost->encoding_needed) {
2032 av_freep(&ost->st->codec->stats_in);
2033 avcodec_close(ost->st->codec);
2037 /* close each decoder */
2038 for(i=0;i<nb_istreams;i++) {
2040 if (ist->decoding_needed) {
2041 avcodec_close(ist->st->codec);
2049 av_freep(&bit_buffer);
2050 av_free(file_table);
2053 for(i=0;i<nb_istreams;i++) {
2060 for(i=0;i<nb_ostreams;i++) {
2064 fclose(ost->logfile);
2065 ost->logfile = NULL;
2067 av_fifo_free(&ost->fifo); /* works even if fifo is not
2068 initialized but set to zero */
2069 av_free(ost->pict_tmp.data[0]);
2070 if (ost->video_resample)
2071 sws_freeContext(ost->img_resample_ctx);
2073 audio_resample_close(ost->resample);
2081 ret = AVERROR(ENOMEM);
2086 int file_read(const char *filename)
2089 unsigned char buffer[1024];
2092 if (url_open(&h, filename, O_RDONLY) < 0) {
2093 printf("could not open '%s'\n", filename);
2097 len = url_read(h, buffer, sizeof(buffer));
2100 for(i=0;i<len;i++) putchar(buffer[i]);
2107 static void opt_format(const char *arg)
2109 /* compatibility stuff for pgmyuv */
2110 if (!strcmp(arg, "pgmyuv")) {
2111 pgmyuv_compatibility_hack=1;
2112 // opt_image_format(arg);
2114 fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2117 file_iformat = av_find_input_format(arg);
2118 file_oformat = guess_format(arg, NULL, NULL);
2119 if (!file_iformat && !file_oformat) {
2120 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2125 extern int ffm_nopts;
2127 static int opt_default(const char *opt, const char *arg){
2129 const AVOption *o= NULL;
2130 int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
2132 for(type=0; type<CODEC_TYPE_NB; type++){
2133 const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
2135 o = av_set_string(avctx_opts[type], opt, arg);
2138 o = av_set_string(avformat_opts, opt, arg);
2140 o = av_set_string(sws_opts, opt, arg);
2143 o = av_set_string(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg);
2144 else if(opt[0] == 'v')
2145 o = av_set_string(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg);
2146 else if(opt[0] == 's')
2147 o = av_set_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg);
2152 // 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));
2154 //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
2155 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
2156 opt_names[opt_name_count++]= o->name;
2158 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
2159 /* disable generate of real time pts in ffm (need to be supressed anyway) */
2160 if(avctx_opts[0]->flags & CODEC_FLAG_BITEXACT)
2164 if(avctx_opts[0]->debug)
2165 av_log_set_level(AV_LOG_DEBUG);
2169 static void opt_video_rc_override_string(const char *arg)
2171 video_rc_override_string = arg;
2174 static void opt_me_threshold(const char *arg)
2176 me_threshold = atoi(arg);
2179 static void opt_verbose(const char *arg)
2181 verbose = atoi(arg);
2182 av_log_set_level(verbose);
2185 static void opt_frame_rate(const char *arg)
2187 if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2188 fprintf(stderr, "Incorrect frame rate\n");
2193 static int opt_bitrate(const char *opt, const char *arg)
2195 int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2197 opt_default(opt, arg);
2199 if (av_get_int(avctx_opts[codec_type], "b", NULL) < 1000)
2200 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2205 static void opt_frame_crop_top(const char *arg)
2207 frame_topBand = atoi(arg);
2208 if (frame_topBand < 0) {
2209 fprintf(stderr, "Incorrect top crop size\n");
2212 if ((frame_topBand % 2) != 0) {
2213 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2216 if ((frame_topBand) >= frame_height){
2217 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2220 frame_height -= frame_topBand;
2223 static void opt_frame_crop_bottom(const char *arg)
2225 frame_bottomBand = atoi(arg);
2226 if (frame_bottomBand < 0) {
2227 fprintf(stderr, "Incorrect bottom crop size\n");
2230 if ((frame_bottomBand % 2) != 0) {
2231 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2234 if ((frame_bottomBand) >= frame_height){
2235 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2238 frame_height -= frame_bottomBand;
2241 static void opt_frame_crop_left(const char *arg)
2243 frame_leftBand = atoi(arg);
2244 if (frame_leftBand < 0) {
2245 fprintf(stderr, "Incorrect left crop size\n");
2248 if ((frame_leftBand % 2) != 0) {
2249 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2252 if ((frame_leftBand) >= frame_width){
2253 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2256 frame_width -= frame_leftBand;
2259 static void opt_frame_crop_right(const char *arg)
2261 frame_rightBand = atoi(arg);
2262 if (frame_rightBand < 0) {
2263 fprintf(stderr, "Incorrect right crop size\n");
2266 if ((frame_rightBand % 2) != 0) {
2267 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2270 if ((frame_rightBand) >= frame_width){
2271 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2274 frame_width -= frame_rightBand;
2277 static void opt_frame_size(const char *arg)
2279 if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2280 fprintf(stderr, "Incorrect frame size\n");
2283 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2284 fprintf(stderr, "Frame size must be a multiple of 2\n");
2290 #define SCALEBITS 10
2291 #define ONE_HALF (1 << (SCALEBITS - 1))
2292 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2294 #define RGB_TO_Y(r, g, b) \
2295 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2296 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2298 #define RGB_TO_U(r1, g1, b1, shift)\
2299 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2300 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2302 #define RGB_TO_V(r1, g1, b1, shift)\
2303 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2304 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2306 static void opt_pad_color(const char *arg) {
2307 /* Input is expected to be six hex digits similar to
2308 how colors are expressed in html tags (but without the #) */
2309 int rgb = strtol(arg, NULL, 16);
2313 g = ((rgb >> 8) & 255);
2316 padcolor[0] = RGB_TO_Y(r,g,b);
2317 padcolor[1] = RGB_TO_U(r,g,b,0);
2318 padcolor[2] = RGB_TO_V(r,g,b,0);
2321 static void opt_frame_pad_top(const char *arg)
2323 frame_padtop = atoi(arg);
2324 if (frame_padtop < 0) {
2325 fprintf(stderr, "Incorrect top pad size\n");
2328 if ((frame_padtop % 2) != 0) {
2329 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2334 static void opt_frame_pad_bottom(const char *arg)
2336 frame_padbottom = atoi(arg);
2337 if (frame_padbottom < 0) {
2338 fprintf(stderr, "Incorrect bottom pad size\n");
2341 if ((frame_padbottom % 2) != 0) {
2342 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2348 static void opt_frame_pad_left(const char *arg)
2350 frame_padleft = atoi(arg);
2351 if (frame_padleft < 0) {
2352 fprintf(stderr, "Incorrect left pad size\n");
2355 if ((frame_padleft % 2) != 0) {
2356 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2362 static void opt_frame_pad_right(const char *arg)
2364 frame_padright = atoi(arg);
2365 if (frame_padright < 0) {
2366 fprintf(stderr, "Incorrect right pad size\n");
2369 if ((frame_padright % 2) != 0) {
2370 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2375 void list_pix_fmts(void)
2378 char pix_fmt_str[128];
2379 for (i=-1; i < PIX_FMT_NB; i++) {
2380 avcodec_pix_fmt_string (pix_fmt_str, sizeof(pix_fmt_str), i);
2381 fprintf(stdout, "%s\n", pix_fmt_str);
2385 static void opt_frame_pix_fmt(const char *arg)
2387 if (strcmp(arg, "list"))
2388 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2395 static void opt_frame_aspect_ratio(const char *arg)
2402 p = strchr(arg, ':');
2404 x = strtol(arg, &end, 10);
2406 y = strtol(end+1, &end, 10);
2408 ar = (double)x / (double)y;
2410 ar = strtod(arg, NULL);
2413 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2416 frame_aspect_ratio = ar;
2419 static void opt_qscale(const char *arg)
2421 video_qscale = atof(arg);
2422 if (video_qscale <= 0 ||
2423 video_qscale > 255) {
2424 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2429 static void opt_qdiff(const char *arg)
2431 video_qdiff = atoi(arg);
2432 if (video_qdiff < 0 ||
2434 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2439 static void opt_strict(const char *arg)
2444 static void opt_top_field_first(const char *arg)
2446 top_field_first= atoi(arg);
2449 static void opt_thread_count(const char *arg)
2451 thread_count= atoi(arg);
2452 #if !defined(HAVE_THREADS)
2454 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2458 static void opt_audio_rate(const char *arg)
2460 audio_sample_rate = atoi(arg);
2463 static void opt_audio_channels(const char *arg)
2465 audio_channels = atoi(arg);
2468 static void opt_video_channel(const char *arg)
2470 video_channel = strtol(arg, NULL, 0);
2473 static void opt_video_standard(const char *arg)
2475 video_standard = av_strdup(arg);
2478 static void opt_codec(int *pstream_copy, char **pcodec_name,
2479 int codec_type, const char *arg)
2481 av_freep(pcodec_name);
2482 if (!strcmp(arg, "copy")) {
2485 *pcodec_name = av_strdup(arg);
2489 static void opt_audio_codec(const char *arg)
2491 opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2494 static void opt_audio_tag(const char *arg)
2497 audio_codec_tag= strtol(arg, &tail, 0);
2500 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2503 static void opt_video_tag(const char *arg)
2506 video_codec_tag= strtol(arg, &tail, 0);
2509 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2513 static void add_frame_hooker(const char *arg)
2518 char *args = av_strdup(arg);
2522 argv[0] = strtok(args, " ");
2523 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2526 i = frame_hook_add(argc, argv);
2529 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2535 static void opt_video_codec(const char *arg)
2537 opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2540 static void opt_subtitle_codec(const char *arg)
2542 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2545 static void opt_map(const char *arg)
2550 m = &stream_maps[nb_stream_maps++];
2552 m->file_index = strtol(arg, &p, 0);
2556 m->stream_index = strtol(p, &p, 0);
2559 m->sync_file_index = strtol(p, &p, 0);
2562 m->sync_stream_index = strtol(p, &p, 0);
2564 m->sync_file_index = m->file_index;
2565 m->sync_stream_index = m->stream_index;
2569 static void opt_map_meta_data(const char *arg)
2574 m = &meta_data_maps[nb_meta_data_maps++];
2576 m->out_file = strtol(arg, &p, 0);
2580 m->in_file = strtol(p, &p, 0);
2583 static int opt_recording_time(const char *opt, const char *arg)
2585 recording_time = parse_time_or_die(opt, arg, 1);
2589 static int opt_start_time(const char *opt, const char *arg)
2591 start_time = parse_time_or_die(opt, arg, 1);
2595 static int opt_rec_timestamp(const char *opt, const char *arg)
2597 rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2601 static int opt_input_ts_offset(const char *opt, const char *arg)
2603 input_ts_offset = parse_time_or_die(opt, arg, 1);
2607 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2609 const char *codec_string = encoder ? "encoder" : "decoder";
2613 return CODEC_ID_NONE;
2615 avcodec_find_encoder_by_name(name) :
2616 avcodec_find_decoder_by_name(name);
2618 av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2621 if(codec->type != type) {
2622 av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2628 static void opt_input_file(const char *filename)
2630 AVFormatContext *ic;
2631 AVFormatParameters params, *ap = ¶ms;
2632 int err, i, ret, rfps, rfps_base;
2635 if (!strcmp(filename, "-"))
2638 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2639 !strcmp( filename, "/dev/stdin" );
2641 /* get default parameters from command line */
2642 ic = av_alloc_format_context();
2644 memset(ap, 0, sizeof(*ap));
2645 ap->prealloced_context = 1;
2646 ap->sample_rate = audio_sample_rate;
2647 ap->channels = audio_channels;
2648 ap->time_base.den = frame_rate.num;
2649 ap->time_base.num = frame_rate.den;
2650 ap->width = frame_width + frame_padleft + frame_padright;
2651 ap->height = frame_height + frame_padtop + frame_padbottom;
2652 ap->pix_fmt = frame_pix_fmt;
2653 ap->channel = video_channel;
2654 ap->standard = video_standard;
2655 ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2656 ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2657 if(pgmyuv_compatibility_hack)
2658 ap->video_codec_id= CODEC_ID_PGMYUV;
2660 for(i=0; i<opt_name_count; i++){
2662 const AVOption *opt;
2663 const char *str= av_get_string(avformat_opts, opt_names[i], &opt, buf, sizeof(buf));
2664 if(str && (opt->flags & AV_OPT_FLAG_DECODING_PARAM))
2665 av_set_string(ic, opt_names[i], str);
2668 ic->video_codec_id = find_codec_or_die(video_codec_name , CODEC_TYPE_VIDEO , 0);
2669 ic->audio_codec_id = find_codec_or_die(audio_codec_name , CODEC_TYPE_AUDIO , 0);
2670 ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2672 /* open the input file with generic libav function */
2673 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2675 print_error(filename, err);
2680 for(i=0; i<ic->nb_programs; i++)
2681 if(ic->programs[i]->id != opt_programid)
2682 ic->programs[i]->discard = AVDISCARD_ALL;
2685 ic->loop_input = loop_input;
2687 /* If not enough info to get the stream parameters, we decode the
2688 first frames to get it. (used in mpeg case for example) */
2689 ret = av_find_stream_info(ic);
2690 if (ret < 0 && verbose >= 0) {
2691 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2695 timestamp = start_time;
2696 /* add the stream start time */
2697 if (ic->start_time != AV_NOPTS_VALUE)
2698 timestamp += ic->start_time;
2700 /* if seeking requested, we execute it */
2701 if (start_time != 0) {
2702 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2704 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2705 filename, (double)timestamp / AV_TIME_BASE);
2707 /* reset seek info */
2711 /* update the current parameters so that they match the one of the input stream */
2712 for(i=0;i<ic->nb_streams;i++) {
2714 AVCodecContext *enc = ic->streams[i]->codec;
2716 avcodec_thread_init(enc, thread_count);
2717 enc->thread_count= thread_count;
2718 switch(enc->codec_type) {
2719 case CODEC_TYPE_AUDIO:
2720 for(j=0; j<opt_name_count; j++){
2722 const AVOption *opt;
2723 const char *str= av_get_string(avctx_opts[CODEC_TYPE_AUDIO], opt_names[j], &opt, buf, sizeof(buf));
2724 if(str && (opt->flags & AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags & AV_OPT_FLAG_DECODING_PARAM))
2725 av_set_string(enc, opt_names[j], str);
2727 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2728 audio_channels = enc->channels;
2729 audio_sample_rate = enc->sample_rate;
2731 ic->streams[i]->discard= AVDISCARD_ALL;
2733 case CODEC_TYPE_VIDEO:
2734 for(j=0; j<opt_name_count; j++){
2736 const AVOption *opt;
2737 const char *str= av_get_string(avctx_opts[CODEC_TYPE_VIDEO], opt_names[j], &opt, buf, sizeof(buf));
2738 if(str && (opt->flags & AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags & AV_OPT_FLAG_DECODING_PARAM))
2739 av_set_string(enc, opt_names[j], str);
2741 frame_height = enc->height;
2742 frame_width = enc->width;
2743 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2744 frame_pix_fmt = enc->pix_fmt;
2745 rfps = ic->streams[i]->r_frame_rate.num;
2746 rfps_base = ic->streams[i]->r_frame_rate.den;
2747 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2749 enc->debug |= FF_DEBUG_MV;
2751 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2754 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2755 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2757 (float)rfps / rfps_base, rfps, rfps_base);
2759 /* update the current frame rate to match the stream frame rate */
2760 frame_rate.num = rfps;
2761 frame_rate.den = rfps_base;
2763 enc->rate_emu = rate_emu;
2765 ic->streams[i]->discard= AVDISCARD_ALL;
2766 else if(video_discard)
2767 ic->streams[i]->discard= video_discard;
2769 case CODEC_TYPE_DATA:
2771 case CODEC_TYPE_SUBTITLE:
2772 if(subtitle_disable)
2773 ic->streams[i]->discard = AVDISCARD_ALL;
2775 case CODEC_TYPE_ATTACHMENT:
2776 case CODEC_TYPE_UNKNOWN:
2783 input_files[nb_input_files] = ic;
2784 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2785 /* dump the file content */
2787 dump_format(ic, nb_input_files, filename, 0);
2790 file_iformat = NULL;
2791 file_oformat = NULL;
2796 av_freep(&video_codec_name);
2797 av_freep(&audio_codec_name);
2798 av_freep(&subtitle_codec_name);
2801 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2802 int *has_subtitle_ptr)
2804 int has_video, has_audio, has_subtitle, i, j;
2805 AVFormatContext *ic;
2810 for(j=0;j<nb_input_files;j++) {
2811 ic = input_files[j];
2812 for(i=0;i<ic->nb_streams;i++) {
2813 AVCodecContext *enc = ic->streams[i]->codec;
2814 switch(enc->codec_type) {
2815 case CODEC_TYPE_AUDIO:
2818 case CODEC_TYPE_VIDEO:
2821 case CODEC_TYPE_SUBTITLE:
2824 case CODEC_TYPE_DATA:
2825 case CODEC_TYPE_ATTACHMENT:
2826 case CODEC_TYPE_UNKNOWN:
2833 *has_video_ptr = has_video;
2834 *has_audio_ptr = has_audio;
2835 *has_subtitle_ptr = has_subtitle;
2838 static void new_video_stream(AVFormatContext *oc)
2841 AVCodecContext *video_enc;
2844 st = av_new_stream(oc, oc->nb_streams);
2846 fprintf(stderr, "Could not alloc stream\n");
2849 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2850 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2851 video_bitstream_filters= NULL;
2854 avcodec_thread_init(st->codec, thread_count);
2856 video_enc = st->codec;
2859 video_enc->codec_tag= video_codec_tag;
2861 if( (video_global_header&1)
2862 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2863 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2864 avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2866 if(video_global_header&2){
2867 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2868 avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2871 if (video_stream_copy) {
2872 st->stream_copy = 1;
2873 video_enc->codec_type = CODEC_TYPE_VIDEO;
2878 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
2880 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2881 if (video_codec_name)
2882 codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
2884 video_enc->codec_id = codec_id;
2885 codec = avcodec_find_encoder(codec_id);
2887 for(i=0; i<opt_name_count; i++){
2889 const AVOption *opt;
2890 const char *str= av_get_string(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt, buf, sizeof(buf));
2891 if(str && (opt->flags & AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
2892 av_set_string(video_enc, opt_names[i], str);
2895 video_enc->time_base.den = fps.num;
2896 video_enc->time_base.num = fps.den;
2897 if(codec && codec->supported_framerates){
2898 const AVRational *p= codec->supported_framerates;
2899 const AVRational *best=NULL;
2900 AVRational best_error= (AVRational){INT_MAX, 1};
2901 for(; p->den!=0; p++){
2902 AVRational error= av_sub_q(fps, *p);
2903 if(error.num <0) error.num *= -1;
2904 if(av_cmp_q(error, best_error) < 0){
2909 video_enc->time_base.den= best->num;
2910 video_enc->time_base.num= best->den;
2913 video_enc->width = frame_width + frame_padright + frame_padleft;
2914 video_enc->height = frame_height + frame_padtop + frame_padbottom;
2915 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2916 video_enc->pix_fmt = frame_pix_fmt;
2918 if(codec && codec->pix_fmts){
2919 const enum PixelFormat *p= codec->pix_fmts;
2921 if(*p == video_enc->pix_fmt)
2925 video_enc->pix_fmt = codec->pix_fmts[0];
2929 video_enc->gop_size = 0;
2930 if (video_qscale || same_quality) {
2931 video_enc->flags |= CODEC_FLAG_QSCALE;
2932 video_enc->global_quality=
2933 st->quality = FF_QP2LAMBDA * video_qscale;
2937 video_enc->intra_matrix = intra_matrix;
2939 video_enc->inter_matrix = inter_matrix;
2941 video_enc->max_qdiff = video_qdiff;
2942 video_enc->thread_count = thread_count;
2943 p= video_rc_override_string;
2946 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2948 fprintf(stderr, "error parsing rc_override\n");
2951 video_enc->rc_override=
2952 av_realloc(video_enc->rc_override,
2953 sizeof(RcOverride)*(i+1));
2954 video_enc->rc_override[i].start_frame= start;
2955 video_enc->rc_override[i].end_frame = end;
2957 video_enc->rc_override[i].qscale= q;
2958 video_enc->rc_override[i].quality_factor= 1.0;
2961 video_enc->rc_override[i].qscale= 0;
2962 video_enc->rc_override[i].quality_factor= -q/100.0;
2967 video_enc->rc_override_count=i;
2968 if (!video_enc->rc_initial_buffer_occupancy)
2969 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2970 video_enc->me_threshold= me_threshold;
2971 video_enc->intra_dc_precision= intra_dc_precision - 8;
2972 video_enc->strict_std_compliance = strict;
2975 video_enc->flags|= CODEC_FLAG_PSNR;
2980 video_enc->flags |= CODEC_FLAG_PASS1;
2982 video_enc->flags |= CODEC_FLAG_PASS2;
2987 /* reset some key parameters */
2989 av_freep(&video_codec_name);
2990 video_stream_copy = 0;
2993 static void new_audio_stream(AVFormatContext *oc)
2996 AVCodecContext *audio_enc;
2999 st = av_new_stream(oc, oc->nb_streams);
3001 fprintf(stderr, "Could not alloc stream\n");
3004 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3006 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3007 audio_bitstream_filters= NULL;
3010 avcodec_thread_init(st->codec, thread_count);
3012 audio_enc = st->codec;
3013 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3014 audio_enc->strict_std_compliance = strict;
3017 audio_enc->codec_tag= audio_codec_tag;
3019 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3020 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3021 avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3023 if (audio_stream_copy) {
3024 st->stream_copy = 1;
3025 audio_enc->channels = audio_channels;
3027 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3029 for(i=0; i<opt_name_count; i++){
3031 const AVOption *opt;
3032 const char *str= av_get_string(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt, buf, sizeof(buf));
3033 if(str && (opt->flags & AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3034 av_set_string(audio_enc, opt_names[i], str);
3037 if (audio_codec_name)
3038 codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3039 audio_enc->codec_id = codec_id;
3041 if (audio_qscale > QSCALE_NONE) {
3042 audio_enc->flags |= CODEC_FLAG_QSCALE;
3043 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3045 audio_enc->thread_count = thread_count;
3046 audio_enc->channels = audio_channels;
3048 audio_enc->sample_rate = audio_sample_rate;
3049 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3050 if (audio_language) {
3051 av_strlcpy(st->language, audio_language, sizeof(st->language));
3052 av_free(audio_language);
3053 audio_language = NULL;
3056 /* reset some key parameters */
3058 av_freep(&audio_codec_name);
3059 audio_stream_copy = 0;
3062 static void new_subtitle_stream(AVFormatContext *oc)
3065 AVCodecContext *subtitle_enc;
3068 st = av_new_stream(oc, oc->nb_streams);
3070 fprintf(stderr, "Could not alloc stream\n");
3073 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3075 bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3076 subtitle_bitstream_filters= NULL;
3078 subtitle_enc = st->codec;
3079 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3080 if (subtitle_stream_copy) {
3081 st->stream_copy = 1;
3083 for(i=0; i<opt_name_count; i++){
3085 const AVOption *opt;
3086 const char *str= av_get_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt_names[i], &opt, buf, sizeof(buf));
3087 if(str && (opt->flags & AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3088 av_set_string(subtitle_enc, opt_names[i], str);
3090 subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3093 if (subtitle_language) {
3094 av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3095 av_free(subtitle_language);
3096 subtitle_language = NULL;
3099 subtitle_disable = 0;
3100 av_freep(&subtitle_codec_name);
3101 subtitle_stream_copy = 0;
3104 static void opt_new_audio_stream(void)
3106 AVFormatContext *oc;
3107 if (nb_output_files <= 0) {
3108 fprintf(stderr, "At least one output file must be specified\n");
3111 oc = output_files[nb_output_files - 1];
3112 new_audio_stream(oc);
3115 static void opt_new_video_stream(void)
3117 AVFormatContext *oc;
3118 if (nb_output_files <= 0) {
3119 fprintf(stderr, "At least one output file must be specified\n");
3122 oc = output_files[nb_output_files - 1];
3123 new_video_stream(oc);
3126 static void opt_new_subtitle_stream(void)
3128 AVFormatContext *oc;
3129 if (nb_output_files <= 0) {
3130 fprintf(stderr, "At least one output file must be specified\n");
3133 oc = output_files[nb_output_files - 1];
3134 new_subtitle_stream(oc);
3137 static void opt_output_file(const char *filename)
3139 AVFormatContext *oc;
3140 int use_video, use_audio, use_subtitle;
3141 int input_has_video, input_has_audio, input_has_subtitle, i;
3142 AVFormatParameters params, *ap = ¶ms;
3144 if (!strcmp(filename, "-"))
3147 oc = av_alloc_format_context();
3149 if (!file_oformat) {
3150 file_oformat = guess_format(NULL, filename, NULL);
3151 if (!file_oformat) {
3152 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3158 oc->oformat = file_oformat;
3159 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3161 if (!strcmp(file_oformat->name, "ffm") &&
3162 av_strstart(filename, "http:", NULL)) {
3163 /* special case for files sent to ffserver: we get the stream
3164 parameters from ffserver */
3165 if (read_ffserver_streams(oc, filename) < 0) {
3166 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3170 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3171 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3172 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3174 /* disable if no corresponding type found and at least one
3176 if (nb_input_files > 0) {
3177 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3178 &input_has_subtitle);
3179 if (!input_has_video)
3181 if (!input_has_audio)
3183 if (!input_has_subtitle)
3187 /* manual disable */
3188 if (audio_disable) {
3191 if (video_disable) {
3194 if (subtitle_disable) {
3199 new_video_stream(oc);
3203 new_audio_stream(oc);
3207 new_subtitle_stream(oc);
3210 oc->timestamp = rec_timestamp;
3213 av_strlcpy(oc->title, str_title, sizeof(oc->title));
3215 av_strlcpy(oc->author, str_author, sizeof(oc->author));
3217 av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3219 av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3221 av_strlcpy(oc->album, str_album, sizeof(oc->album));
3223 av_strlcpy(oc->genre, str_genre, sizeof(oc->genre));
3226 output_files[nb_output_files++] = oc;
3228 /* check filename in case of an image number is expected */
3229 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3230 if (!av_filename_number_test(oc->filename)) {
3231 print_error(oc->filename, AVERROR_NUMEXPECTED);
3236 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3237 /* test if it already exists to avoid loosing precious files */
3238 if (!file_overwrite &&
3239 (strchr(filename, ':') == NULL ||
3240 filename[1] == ':' ||
3241 av_strstart(filename, "file:", NULL))) {
3242 if (url_exist(filename)) {
3245 if ( !using_stdin ) {
3246 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3249 if (toupper(c) != 'Y') {
3250 fprintf(stderr, "Not overwriting - exiting\n");
3255 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3262 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3263 fprintf(stderr, "Could not open '%s'\n", filename);
3268 memset(ap, 0, sizeof(*ap));
3269 if (av_set_parameters(oc, ap) < 0) {
3270 fprintf(stderr, "%s: Invalid encoding parameters\n",
3275 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3276 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3277 oc->loop_output = loop_output;
3279 for(i=0; i<opt_name_count; i++){
3281 const AVOption *opt;
3282 const char *str= av_get_string(avformat_opts, opt_names[i], &opt, buf, sizeof(buf));
3283 if(str && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3284 av_set_string(oc, opt_names[i], str);
3287 /* reset some options */
3288 file_oformat = NULL;
3289 file_iformat = NULL;
3292 /* same option as mencoder */
3293 static void opt_pass(const char *pass_str)
3296 pass = atoi(pass_str);
3297 if (pass != 1 && pass != 2) {
3298 fprintf(stderr, "pass number can be only 1 or 2\n");
3304 static int64_t getutime(void)
3306 #ifdef HAVE_GETRUSAGE
3307 struct rusage rusage;
3309 getrusage(RUSAGE_SELF, &rusage);
3310 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3311 #elif defined(HAVE_GETPROCESSTIMES)
3313 FILETIME c, e, k, u;
3314 proc = GetCurrentProcess();
3315 GetProcessTimes(proc, &c, &e, &k, &u);
3316 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3318 return av_gettime();
3322 static void opt_show_formats(void)
3324 AVInputFormat *ifmt=NULL;
3325 AVOutputFormat *ofmt=NULL;
3326 URLProtocol *up=NULL;
3327 AVCodec *p=NULL, *p2;
3328 AVBitStreamFilter *bsf=NULL;
3329 const char *last_name;
3331 printf("File formats:\n");
3336 const char *name=NULL;
3337 const char *long_name=NULL;
3339 while((ofmt= av_oformat_next(ofmt))) {
3340 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3341 strcmp(ofmt->name, last_name)>0){
3343 long_name= ofmt->long_name;
3347 while((ifmt= av_iformat_next(ifmt))) {
3348 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3349 strcmp(ifmt->name, last_name)>0){
3351 long_name= ifmt->long_name;
3354 if(name && strcmp(ifmt->name, name)==0)
3366 long_name ? long_name:" ");
3370 printf("Codecs:\n");
3376 const char *type_str;
3379 while((p= av_codec_next(p))) {
3380 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3381 strcmp(p->name, last_name)>0){
3383 decode= encode= cap=0;
3385 if(p2 && strcmp(p->name, p2->name)==0){
3386 if(p->decode) decode=1;
3387 if(p->encode) encode=1;
3388 cap |= p->capabilities;
3393 last_name= p2->name;
3396 case CODEC_TYPE_VIDEO:
3399 case CODEC_TYPE_AUDIO:
3402 case CODEC_TYPE_SUBTITLE:
3411 decode ? "D": (/*p2->decoder ? "d":*/" "),
3414 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3415 cap & CODEC_CAP_DR1 ? "D":" ",
3416 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3418 /* if(p2->decoder && decode==0)
3419 printf(" use %s for decoding", p2->decoder->name);*/
3424 printf("Bitstream filters:\n");
3425 while((bsf = av_bitstream_filter_next(bsf)))
3426 printf(" %s", bsf->name);
3429 printf("Supported file protocols:\n");
3430 while((up = av_protocol_next(up)))
3431 printf(" %s:", up->name);
3434 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3437 "Note, the names of encoders and decoders do not always match, so there are\n"
3438 "several cases where the above table shows encoder only or decoder only entries\n"
3439 "even though both encoding and decoding are supported. For example, the h263\n"
3440 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
3445 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3448 const char *p = str;
3455 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3462 static void opt_inter_matrix(const char *arg)
3464 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3465 parse_matrix_coeffs(inter_matrix, arg);
3468 static void opt_intra_matrix(const char *arg)
3470 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3471 parse_matrix_coeffs(intra_matrix, arg);
3475 * Trivial log callback.
3476 * Only suitable for show_help and similar since it lacks prefix handling.
3478 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3480 vfprintf(stdout, fmt, vl);
3483 static void show_help(void)
3485 av_log_set_callback(log_callback_help);
3486 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3487 "Hyper fast Audio and Video encoder\n");
3489 show_help_options(options, "Main options:\n",
3490 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3491 show_help_options(options, "\nVideo options:\n",
3492 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3494 show_help_options(options, "\nAdvanced Video options:\n",
3495 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3496 OPT_VIDEO | OPT_EXPERT);
3497 show_help_options(options, "\nAudio options:\n",
3498 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3500 show_help_options(options, "\nAdvanced Audio options:\n",
3501 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3502 OPT_AUDIO | OPT_EXPERT);
3503 show_help_options(options, "\nSubtitle options:\n",
3504 OPT_SUBTITLE | OPT_GRAB,
3506 show_help_options(options, "\nAudio/Video grab options:\n",
3509 show_help_options(options, "\nAdvanced options:\n",
3510 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3512 av_opt_show(avctx_opts[0], NULL);
3513 av_opt_show(avformat_opts, NULL);
3514 av_opt_show(sws_opts, NULL);
3517 static void opt_show_help(void)
3523 static void opt_target(const char *arg)
3526 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3528 if(!strncmp(arg, "pal-", 4)) {
3531 } else if(!strncmp(arg, "ntsc-", 5)) {
3534 } else if(!strncmp(arg, "film-", 5)) {
3539 /* Calculate FR via float to avoid int overflow */
3540 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3543 } else if((fr == 29970) || (fr == 23976)) {
3546 /* Try to determine PAL/NTSC by peeking in the input files */
3547 if(nb_input_files) {
3549 for(j = 0; j < nb_input_files; j++) {
3550 for(i = 0; i < input_files[j]->nb_streams; i++) {
3551 AVCodecContext *c = input_files[j]->streams[i]->codec;
3552 if(c->codec_type != CODEC_TYPE_VIDEO)
3554 fr = c->time_base.den * 1000 / c->time_base.num;
3558 } else if((fr == 29970) || (fr == 23976)) {
3568 if(verbose && norm >= 0)
3569 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3573 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3574 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3575 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3579 if(!strcmp(arg, "vcd")) {
3581 opt_video_codec("mpeg1video");
3582 opt_audio_codec("mp2");
3585 opt_frame_size(norm ? "352x240" : "352x288");
3586 opt_frame_rate(frame_rates[norm]);
3587 opt_default("gop", norm ? "18" : "15");
3589 opt_default("b", "1150000");
3590 opt_default("maxrate", "1150000");
3591 opt_default("minrate", "1150000");
3592 opt_default("bufsize", "327680"); // 40*1024*8;
3594 opt_default("ab", "224000");
3595 audio_sample_rate = 44100;
3598 opt_default("packetsize", "2324");
3599 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3601 /* We have to offset the PTS, so that it is consistent with the SCR.
3602 SCR starts at 36000, but the first two packs contain only padding
3603 and the first pack from the other stream, respectively, may also have
3604 been written before.
3605 So the real data starts at SCR 36000+3*1200. */
3606 mux_preload= (36000+3*1200) / 90000.0; //0.44
3607 } else if(!strcmp(arg, "svcd")) {
3609 opt_video_codec("mpeg2video");
3610 opt_audio_codec("mp2");
3613 opt_frame_size(norm ? "480x480" : "480x576");
3614 opt_frame_rate(frame_rates[norm]);
3615 opt_default("gop", norm ? "18" : "15");
3617 opt_default("b", "2040000");
3618 opt_default("maxrate", "2516000");
3619 opt_default("minrate", "0"); //1145000;
3620 opt_default("bufsize", "1835008"); //224*1024*8;
3621 opt_default("flags", "+SCAN_OFFSET");
3624 opt_default("ab", "224000");
3625 audio_sample_rate = 44100;
3627 opt_default("packetsize", "2324");
3629 } else if(!strcmp(arg, "dvd")) {
3631 opt_video_codec("mpeg2video");
3632 opt_audio_codec("ac3");
3635 opt_frame_size(norm ? "720x480" : "720x576");
3636 opt_frame_rate(frame_rates[norm]);
3637 opt_default("gop", norm ? "18" : "15");
3639 opt_default("b", "6000000");
3640 opt_default("maxrate", "9000000");
3641 opt_default("minrate", "0"); //1500000;
3642 opt_default("bufsize", "1835008"); //224*1024*8;
3644 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3645 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3647 opt_default("ab", "448000");
3648 audio_sample_rate = 48000;
3650 } else if(!strncmp(arg, "dv", 2)) {
3654 opt_frame_size(norm ? "720x480" : "720x576");
3655 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3656 (norm ? "yuv411p" : "yuv420p"));
3657 opt_frame_rate(frame_rates[norm]);
3659 audio_sample_rate = 48000;
3663 fprintf(stderr, "Unknown target: %s\n", arg);
3668 static void opt_vstats_file (const char *arg)
3670 av_free (vstats_filename);
3671 vstats_filename=av_strdup (arg);
3674 static void opt_vstats (void)
3677 time_t today2 = time(NULL);
3678 struct tm *today = localtime(&today2);
3680 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3682 opt_vstats_file(filename);
3685 static int opt_bsf(const char *opt, const char *arg)
3687 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3688 AVBitStreamFilterContext **bsfp;
3691 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3695 bsfp= *opt == 'v' ? &video_bitstream_filters :
3696 *opt == 'a' ? &audio_bitstream_filters :
3697 &subtitle_bitstream_filters;
3699 bsfp= &(*bsfp)->next;
3706 static void opt_show_license(void)
3712 static void opt_show_version(void)
3714 show_version(program_name);
3718 const OptionDef options[] = {
3720 { "L", 0, {(void*)opt_show_license}, "show license" },
3721 { "h", 0, {(void*)opt_show_help}, "show help" },
3722 { "version", 0, {(void*)opt_show_version}, "show version" },
3723 { "formats", 0, {(void*)opt_show_formats}, "show available formats, codecs, protocols, ..." },
3724 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3725 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3726 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3727 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3728 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3729 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3730 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3731 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3732 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3733 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3734 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3735 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3736 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3737 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3738 { "genre", HAS_ARG | OPT_STRING, {(void*)&str_genre}, "set the genre", "string" },
3739 { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3740 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3741 "add timings for benchmarking" },
3742 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3743 "dump each input packet" },
3744 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3745 "when dumping packets, also dump the payload" },
3746 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3747 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3748 { "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)", "" },
3749 { "v", HAS_ARG, {(void*)opt_verbose}, "set the logging verbosity level", "number" },
3750 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3751 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3752 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3753 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3754 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3755 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3756 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3757 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3758 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3759 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3762 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3763 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3764 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3765 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3766 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3767 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3768 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3769 { "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" },
3770 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3771 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3772 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3773 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3774 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3775 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3776 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3777 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3778 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3779 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3780 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3781 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3782 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3783 { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantizer scale (VBR)", "q" },
3784 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3785 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3786 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
3787 { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3788 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3789 "use same video quality as source (implies VBR)" },
3790 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3791 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3792 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3793 "deinterlace pictures" },
3794 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3795 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3796 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3798 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3800 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3801 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3802 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3803 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3804 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3805 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3806 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3809 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3810 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3811 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3812 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3813 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3814 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3815 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3816 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3817 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3818 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3819 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3821 /* subtitle options */
3822 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3823 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3824 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3825 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3828 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3829 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3830 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3833 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3834 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3836 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" },
3837 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" },
3838 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" },
3840 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3844 static int av_exit()
3849 for(i=0;i<nb_output_files;i++) {
3850 /* maybe av_close_output_file ??? */
3851 AVFormatContext *s = output_files[i];
3853 if (!(s->oformat->flags & AVFMT_NOFILE))
3855 for(j=0;j<s->nb_streams;j++) {
3856 av_free(s->streams[j]->codec);
3857 av_free(s->streams[j]);
3861 for(i=0;i<nb_input_files;i++)
3862 av_close_input_file(input_files[i]);
3866 av_free(intra_matrix);
3867 av_free(inter_matrix);
3870 fclose(vstats_file);
3871 av_free(vstats_filename);
3875 av_free(video_codec_name);
3876 av_free(audio_codec_name);
3877 av_free(subtitle_codec_name);
3879 av_free(video_standard);
3881 #ifdef CONFIG_POWERPC_PERF
3882 extern void powerpc_display_perf_report(void);
3883 powerpc_display_perf_report();
3884 #endif /* CONFIG_POWERPC_PERF */
3886 if (received_sigterm) {
3888 "Received signal %d: terminating.\n",
3889 (int) received_sigterm);
3893 exit(0); /* not all OS-es handle main() return value */
3897 int main(int argc, char **argv)
3902 avcodec_register_all();
3903 avdevice_register_all();
3906 for(i=0; i<CODEC_TYPE_NB; i++){
3907 avctx_opts[i]= avcodec_alloc_context2(i);
3909 avformat_opts = av_alloc_format_context();
3910 sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3912 show_banner(program_name, program_birth_year);
3919 parse_options(argc, argv, options, opt_output_file);
3921 /* file converter / grab */
3922 if (nb_output_files <= 0) {
3923 fprintf(stderr, "Must supply at least one output file\n");
3927 if (nb_input_files == 0) {
3928 fprintf(stderr, "Must supply at least one input file\n");
3933 av_encode(output_files, nb_output_files, input_files, nb_input_files,
3934 stream_maps, nb_stream_maps);
3935 ti = getutime() - ti;
3937 printf("bench: utime=%0.3fs\n", ti / 1000000.0);