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 if (ost->st->stream_copy) {
1596 /* if stream_copy is selected, no need to decode or encode */
1597 codec->codec_id = icodec->codec_id;
1598 codec->codec_type = icodec->codec_type;
1600 if(!codec->codec_tag){
1601 if( !os->oformat->codec_tag
1602 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1603 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1604 codec->codec_tag = icodec->codec_tag;
1607 codec->bit_rate = icodec->bit_rate;
1608 codec->extradata= icodec->extradata;
1609 codec->extradata_size= icodec->extradata_size;
1610 if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1611 codec->time_base = icodec->time_base;
1613 codec->time_base = ist->st->time_base;
1614 switch(codec->codec_type) {
1615 case CODEC_TYPE_AUDIO:
1616 codec->sample_rate = icodec->sample_rate;
1617 codec->channels = icodec->channels;
1618 codec->frame_size = icodec->frame_size;
1619 codec->block_align= icodec->block_align;
1620 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1621 codec->block_align= 0;
1623 case CODEC_TYPE_VIDEO:
1625 fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1628 codec->pix_fmt = icodec->pix_fmt;
1629 codec->width = icodec->width;
1630 codec->height = icodec->height;
1631 codec->has_b_frames = icodec->has_b_frames;
1633 case CODEC_TYPE_SUBTITLE:
1639 switch(codec->codec_type) {
1640 case CODEC_TYPE_AUDIO:
1641 if (av_fifo_init(&ost->fifo, 1024))
1643 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1644 icodec->request_channels = codec->channels;
1645 ist->decoding_needed = 1;
1646 ost->encoding_needed = 1;
1648 case CODEC_TYPE_VIDEO:
1649 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1650 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1651 ost->video_resample = ((codec->width != icodec->width -
1652 (frame_leftBand + frame_rightBand) +
1653 (frame_padleft + frame_padright)) ||
1654 (codec->height != icodec->height -
1655 (frame_topBand + frame_bottomBand) +
1656 (frame_padtop + frame_padbottom)) ||
1657 (codec->pix_fmt != icodec->pix_fmt));
1658 if (ost->video_crop) {
1659 ost->topBand = frame_topBand;
1660 ost->leftBand = frame_leftBand;
1662 if (ost->video_pad) {
1663 ost->padtop = frame_padtop;
1664 ost->padleft = frame_padleft;
1665 ost->padbottom = frame_padbottom;
1666 ost->padright = frame_padright;
1667 if (!ost->video_resample) {
1668 avcodec_get_frame_defaults(&ost->pict_tmp);
1669 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1670 codec->width, codec->height ) )
1674 if (ost->video_resample) {
1675 avcodec_get_frame_defaults(&ost->pict_tmp);
1676 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1677 codec->width, codec->height ) ) {
1678 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1681 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1682 ost->img_resample_ctx = sws_getContext(
1683 icodec->width - (frame_leftBand + frame_rightBand),
1684 icodec->height - (frame_topBand + frame_bottomBand),
1686 codec->width - (frame_padleft + frame_padright),
1687 codec->height - (frame_padtop + frame_padbottom),
1689 sws_flags, NULL, NULL, NULL);
1690 if (ost->img_resample_ctx == NULL) {
1691 fprintf(stderr, "Cannot get resampling context\n");
1694 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1696 ost->encoding_needed = 1;
1697 ist->decoding_needed = 1;
1699 case CODEC_TYPE_SUBTITLE:
1700 ost->encoding_needed = 1;
1701 ist->decoding_needed = 1;
1708 if (ost->encoding_needed &&
1709 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1710 char logfilename[1024];
1715 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1717 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1718 if (codec->flags & CODEC_FLAG_PASS1) {
1719 f = fopen(logfilename, "w");
1721 perror(logfilename);
1726 /* read the log file */
1727 f = fopen(logfilename, "r");
1729 perror(logfilename);
1732 fseek(f, 0, SEEK_END);
1734 fseek(f, 0, SEEK_SET);
1735 logbuffer = av_malloc(size + 1);
1737 fprintf(stderr, "Could not allocate log buffer\n");
1740 size = fread(logbuffer, 1, size, f);
1742 logbuffer[size] = '\0';
1743 codec->stats_in = logbuffer;
1747 if(codec->codec_type == CODEC_TYPE_VIDEO){
1748 int size= codec->width * codec->height;
1749 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1754 bit_buffer = av_malloc(bit_buffer_size);
1758 /* dump the file output parameters - cannot be done before in case
1760 for(i=0;i<nb_output_files;i++) {
1761 dump_format(output_files[i], i, output_files[i]->filename, 1);
1764 /* dump the stream mapping */
1766 fprintf(stderr, "Stream mapping:\n");
1767 for(i=0;i<nb_ostreams;i++) {
1769 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1770 ist_table[ost->source_index]->file_index,
1771 ist_table[ost->source_index]->index,
1774 if (ost->sync_ist != ist_table[ost->source_index])
1775 fprintf(stderr, " [sync #%d.%d]",
1776 ost->sync_ist->file_index,
1777 ost->sync_ist->index);
1778 fprintf(stderr, "\n");
1782 /* open each encoder */
1783 for(i=0;i<nb_ostreams;i++) {
1785 if (ost->encoding_needed) {
1787 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1789 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1790 ost->file_index, ost->index);
1793 if (avcodec_open(ost->st->codec, codec) < 0) {
1794 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1795 ost->file_index, ost->index);
1798 extra_size += ost->st->codec->extradata_size;
1802 /* open each decoder */
1803 for(i=0;i<nb_istreams;i++) {
1805 if (ist->decoding_needed) {
1807 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1809 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1810 ist->st->codec->codec_id, ist->file_index, ist->index);
1813 if (avcodec_open(ist->st->codec, codec) < 0) {
1814 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1815 ist->file_index, ist->index);
1818 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1819 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1824 for(i=0;i<nb_istreams;i++) {
1826 is = input_files[ist->file_index];
1828 ist->next_pts = AV_NOPTS_VALUE;
1832 /* set meta data information from input file if required */
1833 for (i=0;i<nb_meta_data_maps;i++) {
1834 AVFormatContext *out_file;
1835 AVFormatContext *in_file;
1837 int out_file_index = meta_data_maps[i].out_file;
1838 int in_file_index = meta_data_maps[i].in_file;
1839 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1840 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1841 ret = AVERROR(EINVAL);
1844 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1845 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1846 ret = AVERROR(EINVAL);
1850 out_file = output_files[out_file_index];
1851 in_file = input_files[in_file_index];
1853 strcpy(out_file->title, in_file->title);
1854 strcpy(out_file->author, in_file->author);
1855 strcpy(out_file->copyright, in_file->copyright);
1856 strcpy(out_file->comment, in_file->comment);
1857 strcpy(out_file->album, in_file->album);
1858 out_file->year = in_file->year;
1859 out_file->track = in_file->track;
1860 strcpy(out_file->genre, in_file->genre);
1863 /* open files and write file headers */
1864 for(i=0;i<nb_output_files;i++) {
1865 os = output_files[i];
1866 if (av_write_header(os) < 0) {
1867 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1868 ret = AVERROR(EINVAL);
1871 if (strcmp(output_files[i]->oformat->name, "rtp")) {
1876 print_sdp(output_files, nb_output_files);
1879 if ( !using_stdin && verbose >= 0) {
1880 fprintf(stderr, "Press [q] to stop encoding\n");
1881 url_set_interrupt_cb(decode_interrupt_cb);
1886 timer_start = av_gettime();
1888 for(; received_sigterm == 0;) {
1889 int file_index, ist_index;
1897 /* if 'q' pressed, exits */
1901 /* read_key() returns 0 on EOF */
1907 /* select the stream that we must read now by looking at the
1908 smallest output pts */
1910 for(i=0;i<nb_ostreams;i++) {
1913 os = output_files[ost->file_index];
1914 ist = ist_table[ost->source_index];
1915 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1916 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1918 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1919 ipts = (double)ist->pts;
1920 if (!file_table[ist->file_index].eof_reached){
1921 if(ipts < ipts_min) {
1923 if(input_sync ) file_index = ist->file_index;
1925 if(opts < opts_min) {
1927 if(!input_sync) file_index = ist->file_index;
1930 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1935 /* if none, if is finished */
1936 if (file_index < 0) {
1940 /* finish if recording time exhausted */
1941 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1944 /* finish if limit size exhausted */
1945 if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
1948 /* read a frame from it and output it in the fifo */
1949 is = input_files[file_index];
1950 if (av_read_frame(is, &pkt) < 0) {
1951 file_table[file_index].eof_reached = 1;
1959 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
1961 /* the following test is needed in case new streams appear
1962 dynamically in stream : we ignore them */
1963 if (pkt.stream_index >= file_table[file_index].nb_streams)
1964 goto discard_packet;
1965 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1966 ist = ist_table[ist_index];
1968 goto discard_packet;
1970 if (pkt.dts != AV_NOPTS_VALUE)
1971 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
1972 if (pkt.pts != AV_NOPTS_VALUE)
1973 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
1975 // 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);
1976 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1977 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
1978 int64_t delta= pkt_dts - ist->next_pts;
1979 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
1980 input_files_ts_offset[ist->file_index]-= delta;
1982 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1983 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
1984 if(pkt.pts != AV_NOPTS_VALUE)
1985 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
1989 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1990 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1993 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1994 ist->file_index, ist->index);
1996 av_free_packet(&pkt);
2001 av_free_packet(&pkt);
2003 /* dump report by using the output first video and audio streams */
2004 print_report(output_files, ost_table, nb_ostreams, 0);
2007 /* at the end of stream, we must flush the decoder buffers */
2008 for(i=0;i<nb_istreams;i++) {
2010 if (ist->decoding_needed) {
2011 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2017 /* write the trailer if needed and close file */
2018 for(i=0;i<nb_output_files;i++) {
2019 os = output_files[i];
2020 av_write_trailer(os);
2023 /* dump report by using the first video and audio streams */
2024 print_report(output_files, ost_table, nb_ostreams, 1);
2026 /* close each encoder */
2027 for(i=0;i<nb_ostreams;i++) {
2029 if (ost->encoding_needed) {
2030 av_freep(&ost->st->codec->stats_in);
2031 avcodec_close(ost->st->codec);
2035 /* close each decoder */
2036 for(i=0;i<nb_istreams;i++) {
2038 if (ist->decoding_needed) {
2039 avcodec_close(ist->st->codec);
2047 av_freep(&bit_buffer);
2048 av_free(file_table);
2051 for(i=0;i<nb_istreams;i++) {
2058 for(i=0;i<nb_ostreams;i++) {
2062 fclose(ost->logfile);
2063 ost->logfile = NULL;
2065 av_fifo_free(&ost->fifo); /* works even if fifo is not
2066 initialized but set to zero */
2067 av_free(ost->pict_tmp.data[0]);
2068 if (ost->video_resample)
2069 sws_freeContext(ost->img_resample_ctx);
2071 audio_resample_close(ost->resample);
2079 ret = AVERROR(ENOMEM);
2084 int file_read(const char *filename)
2087 unsigned char buffer[1024];
2090 if (url_open(&h, filename, O_RDONLY) < 0) {
2091 printf("could not open '%s'\n", filename);
2095 len = url_read(h, buffer, sizeof(buffer));
2098 for(i=0;i<len;i++) putchar(buffer[i]);
2105 static void opt_format(const char *arg)
2107 /* compatibility stuff for pgmyuv */
2108 if (!strcmp(arg, "pgmyuv")) {
2109 pgmyuv_compatibility_hack=1;
2110 // opt_image_format(arg);
2112 fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2115 file_iformat = av_find_input_format(arg);
2116 file_oformat = guess_format(arg, NULL, NULL);
2117 if (!file_iformat && !file_oformat) {
2118 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2123 extern int ffm_nopts;
2125 static int opt_default(const char *opt, const char *arg){
2127 const AVOption *o= NULL;
2128 int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
2130 for(type=0; type<CODEC_TYPE_NB; type++){
2131 const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
2133 o = av_set_string(avctx_opts[type], opt, arg);
2136 o = av_set_string(avformat_opts, opt, arg);
2138 o = av_set_string(sws_opts, opt, arg);
2141 o = av_set_string(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg);
2142 else if(opt[0] == 'v')
2143 o = av_set_string(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg);
2144 else if(opt[0] == 's')
2145 o = av_set_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg);
2150 // 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));
2152 //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
2153 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
2154 opt_names[opt_name_count++]= o->name;
2156 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
2157 /* disable generate of real time pts in ffm (need to be supressed anyway) */
2158 if(avctx_opts[0]->flags & CODEC_FLAG_BITEXACT)
2162 if(avctx_opts[0]->debug)
2163 av_log_set_level(AV_LOG_DEBUG);
2167 static void opt_video_rc_override_string(const char *arg)
2169 video_rc_override_string = arg;
2172 static void opt_me_threshold(const char *arg)
2174 me_threshold = atoi(arg);
2177 static void opt_verbose(const char *arg)
2179 verbose = atoi(arg);
2180 av_log_set_level(verbose);
2183 static void opt_frame_rate(const char *arg)
2185 if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2186 fprintf(stderr, "Incorrect frame rate\n");
2191 static int opt_bitrate(const char *opt, const char *arg)
2193 int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2195 opt_default(opt, arg);
2197 if (av_get_int(avctx_opts[codec_type], "b", NULL) < 1000)
2198 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2203 static void opt_frame_crop_top(const char *arg)
2205 frame_topBand = atoi(arg);
2206 if (frame_topBand < 0) {
2207 fprintf(stderr, "Incorrect top crop size\n");
2210 if ((frame_topBand % 2) != 0) {
2211 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2214 if ((frame_topBand) >= frame_height){
2215 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2218 frame_height -= frame_topBand;
2221 static void opt_frame_crop_bottom(const char *arg)
2223 frame_bottomBand = atoi(arg);
2224 if (frame_bottomBand < 0) {
2225 fprintf(stderr, "Incorrect bottom crop size\n");
2228 if ((frame_bottomBand % 2) != 0) {
2229 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2232 if ((frame_bottomBand) >= frame_height){
2233 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2236 frame_height -= frame_bottomBand;
2239 static void opt_frame_crop_left(const char *arg)
2241 frame_leftBand = atoi(arg);
2242 if (frame_leftBand < 0) {
2243 fprintf(stderr, "Incorrect left crop size\n");
2246 if ((frame_leftBand % 2) != 0) {
2247 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2250 if ((frame_leftBand) >= frame_width){
2251 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2254 frame_width -= frame_leftBand;
2257 static void opt_frame_crop_right(const char *arg)
2259 frame_rightBand = atoi(arg);
2260 if (frame_rightBand < 0) {
2261 fprintf(stderr, "Incorrect right crop size\n");
2264 if ((frame_rightBand % 2) != 0) {
2265 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2268 if ((frame_rightBand) >= frame_width){
2269 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2272 frame_width -= frame_rightBand;
2275 static void opt_frame_size(const char *arg)
2277 if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2278 fprintf(stderr, "Incorrect frame size\n");
2281 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2282 fprintf(stderr, "Frame size must be a multiple of 2\n");
2288 #define SCALEBITS 10
2289 #define ONE_HALF (1 << (SCALEBITS - 1))
2290 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2292 #define RGB_TO_Y(r, g, b) \
2293 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2294 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2296 #define RGB_TO_U(r1, g1, b1, shift)\
2297 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2298 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2300 #define RGB_TO_V(r1, g1, b1, shift)\
2301 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2302 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2304 static void opt_pad_color(const char *arg) {
2305 /* Input is expected to be six hex digits similar to
2306 how colors are expressed in html tags (but without the #) */
2307 int rgb = strtol(arg, NULL, 16);
2311 g = ((rgb >> 8) & 255);
2314 padcolor[0] = RGB_TO_Y(r,g,b);
2315 padcolor[1] = RGB_TO_U(r,g,b,0);
2316 padcolor[2] = RGB_TO_V(r,g,b,0);
2319 static void opt_frame_pad_top(const char *arg)
2321 frame_padtop = atoi(arg);
2322 if (frame_padtop < 0) {
2323 fprintf(stderr, "Incorrect top pad size\n");
2326 if ((frame_padtop % 2) != 0) {
2327 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2332 static void opt_frame_pad_bottom(const char *arg)
2334 frame_padbottom = atoi(arg);
2335 if (frame_padbottom < 0) {
2336 fprintf(stderr, "Incorrect bottom pad size\n");
2339 if ((frame_padbottom % 2) != 0) {
2340 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2346 static void opt_frame_pad_left(const char *arg)
2348 frame_padleft = atoi(arg);
2349 if (frame_padleft < 0) {
2350 fprintf(stderr, "Incorrect left pad size\n");
2353 if ((frame_padleft % 2) != 0) {
2354 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2360 static void opt_frame_pad_right(const char *arg)
2362 frame_padright = atoi(arg);
2363 if (frame_padright < 0) {
2364 fprintf(stderr, "Incorrect right pad size\n");
2367 if ((frame_padright % 2) != 0) {
2368 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2373 void list_pix_fmts(void)
2376 char pix_fmt_str[128];
2377 for (i=-1; i < PIX_FMT_NB; i++) {
2378 avcodec_pix_fmt_string (pix_fmt_str, sizeof(pix_fmt_str), i);
2379 fprintf(stdout, "%s\n", pix_fmt_str);
2383 static void opt_frame_pix_fmt(const char *arg)
2385 if (strcmp(arg, "list"))
2386 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2393 static void opt_frame_aspect_ratio(const char *arg)
2400 p = strchr(arg, ':');
2402 x = strtol(arg, &end, 10);
2404 y = strtol(end+1, &end, 10);
2406 ar = (double)x / (double)y;
2408 ar = strtod(arg, NULL);
2411 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2414 frame_aspect_ratio = ar;
2417 static void opt_qscale(const char *arg)
2419 video_qscale = atof(arg);
2420 if (video_qscale <= 0 ||
2421 video_qscale > 255) {
2422 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2427 static void opt_qdiff(const char *arg)
2429 video_qdiff = atoi(arg);
2430 if (video_qdiff < 0 ||
2432 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2437 static void opt_strict(const char *arg)
2442 static void opt_top_field_first(const char *arg)
2444 top_field_first= atoi(arg);
2447 static void opt_thread_count(const char *arg)
2449 thread_count= atoi(arg);
2450 #if !defined(HAVE_THREADS)
2452 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2456 static void opt_audio_rate(const char *arg)
2458 audio_sample_rate = atoi(arg);
2461 static void opt_audio_channels(const char *arg)
2463 audio_channels = atoi(arg);
2466 static void opt_video_channel(const char *arg)
2468 video_channel = strtol(arg, NULL, 0);
2471 static void opt_video_standard(const char *arg)
2473 video_standard = av_strdup(arg);
2476 static void opt_codec(int *pstream_copy, char **pcodec_name,
2477 int codec_type, const char *arg)
2479 av_freep(pcodec_name);
2480 if (!strcmp(arg, "copy")) {
2483 *pcodec_name = av_strdup(arg);
2487 static void opt_audio_codec(const char *arg)
2489 opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2492 static void opt_audio_tag(const char *arg)
2495 audio_codec_tag= strtol(arg, &tail, 0);
2498 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2501 static void opt_video_tag(const char *arg)
2504 video_codec_tag= strtol(arg, &tail, 0);
2507 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2511 static void add_frame_hooker(const char *arg)
2516 char *args = av_strdup(arg);
2520 argv[0] = strtok(args, " ");
2521 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2524 i = frame_hook_add(argc, argv);
2527 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2533 static void opt_video_codec(const char *arg)
2535 opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2538 static void opt_subtitle_codec(const char *arg)
2540 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2543 static void opt_map(const char *arg)
2548 m = &stream_maps[nb_stream_maps++];
2550 m->file_index = strtol(arg, &p, 0);
2554 m->stream_index = strtol(p, &p, 0);
2557 m->sync_file_index = strtol(p, &p, 0);
2560 m->sync_stream_index = strtol(p, &p, 0);
2562 m->sync_file_index = m->file_index;
2563 m->sync_stream_index = m->stream_index;
2567 static void opt_map_meta_data(const char *arg)
2572 m = &meta_data_maps[nb_meta_data_maps++];
2574 m->out_file = strtol(arg, &p, 0);
2578 m->in_file = strtol(p, &p, 0);
2581 static int64_t parse_time_or_die(const char *timestr, int is_duration)
2583 int64_t us = parse_date(timestr, is_duration);
2584 if (us == INT64_MIN) {
2585 fprintf(stderr, "Invalid %s specification: %s\n",
2586 is_duration ? "duration" : "date", timestr);
2592 static void opt_recording_time(const char *arg)
2594 recording_time = parse_time_or_die(arg, 1);
2597 static void opt_start_time(const char *arg)
2599 start_time = parse_time_or_die(arg, 1);
2602 static void opt_rec_timestamp(const char *arg)
2604 rec_timestamp = parse_time_or_die(arg, 0) / 1000000;
2607 static void opt_input_ts_offset(const char *arg)
2609 input_ts_offset = parse_time_or_die(arg, 1);
2612 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2614 const char *codec_string = encoder ? "encoder" : "decoder";
2618 return CODEC_ID_NONE;
2620 avcodec_find_encoder_by_name(name) :
2621 avcodec_find_decoder_by_name(name);
2623 av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2626 if(codec->type != type) {
2627 av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2633 static void opt_input_file(const char *filename)
2635 AVFormatContext *ic;
2636 AVFormatParameters params, *ap = ¶ms;
2637 int err, i, ret, rfps, rfps_base;
2640 if (!strcmp(filename, "-"))
2643 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2644 !strcmp( filename, "/dev/stdin" );
2646 /* get default parameters from command line */
2647 ic = av_alloc_format_context();
2649 memset(ap, 0, sizeof(*ap));
2650 ap->prealloced_context = 1;
2651 ap->sample_rate = audio_sample_rate;
2652 ap->channels = audio_channels;
2653 ap->time_base.den = frame_rate.num;
2654 ap->time_base.num = frame_rate.den;
2655 ap->width = frame_width + frame_padleft + frame_padright;
2656 ap->height = frame_height + frame_padtop + frame_padbottom;
2657 ap->pix_fmt = frame_pix_fmt;
2658 ap->channel = video_channel;
2659 ap->standard = video_standard;
2660 ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2661 ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2662 if(pgmyuv_compatibility_hack)
2663 ap->video_codec_id= CODEC_ID_PGMYUV;
2665 for(i=0; i<opt_name_count; i++){
2667 const AVOption *opt;
2668 const char *str= av_get_string(avformat_opts, opt_names[i], &opt, buf, sizeof(buf));
2669 if(str && (opt->flags & AV_OPT_FLAG_DECODING_PARAM))
2670 av_set_string(ic, opt_names[i], str);
2673 ic->video_codec_id = find_codec_or_die(video_codec_name , CODEC_TYPE_VIDEO , 0);
2674 ic->audio_codec_id = find_codec_or_die(audio_codec_name , CODEC_TYPE_AUDIO , 0);
2675 ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2677 /* open the input file with generic libav function */
2678 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2680 print_error(filename, err);
2685 for(i=0; i<ic->nb_programs; i++)
2686 if(ic->programs[i]->id != opt_programid)
2687 ic->programs[i]->discard = AVDISCARD_ALL;
2690 ic->loop_input = loop_input;
2692 /* If not enough info to get the stream parameters, we decode the
2693 first frames to get it. (used in mpeg case for example) */
2694 ret = av_find_stream_info(ic);
2695 if (ret < 0 && verbose >= 0) {
2696 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2700 timestamp = start_time;
2701 /* add the stream start time */
2702 if (ic->start_time != AV_NOPTS_VALUE)
2703 timestamp += ic->start_time;
2705 /* if seeking requested, we execute it */
2706 if (start_time != 0) {
2707 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2709 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2710 filename, (double)timestamp / AV_TIME_BASE);
2712 /* reset seek info */
2716 /* update the current parameters so that they match the one of the input stream */
2717 for(i=0;i<ic->nb_streams;i++) {
2719 AVCodecContext *enc = ic->streams[i]->codec;
2721 avcodec_thread_init(enc, thread_count);
2722 enc->thread_count= thread_count;
2723 switch(enc->codec_type) {
2724 case CODEC_TYPE_AUDIO:
2725 for(j=0; j<opt_name_count; j++){
2727 const AVOption *opt;
2728 const char *str= av_get_string(avctx_opts[CODEC_TYPE_AUDIO], opt_names[j], &opt, buf, sizeof(buf));
2729 if(str && (opt->flags & AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags & AV_OPT_FLAG_DECODING_PARAM))
2730 av_set_string(enc, opt_names[j], str);
2732 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2733 audio_channels = enc->channels;
2734 audio_sample_rate = enc->sample_rate;
2736 ic->streams[i]->discard= AVDISCARD_ALL;
2738 case CODEC_TYPE_VIDEO:
2739 for(j=0; j<opt_name_count; j++){
2741 const AVOption *opt;
2742 const char *str= av_get_string(avctx_opts[CODEC_TYPE_VIDEO], opt_names[j], &opt, buf, sizeof(buf));
2743 if(str && (opt->flags & AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags & AV_OPT_FLAG_DECODING_PARAM))
2744 av_set_string(enc, opt_names[j], str);
2746 frame_height = enc->height;
2747 frame_width = enc->width;
2748 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2749 frame_pix_fmt = enc->pix_fmt;
2750 rfps = ic->streams[i]->r_frame_rate.num;
2751 rfps_base = ic->streams[i]->r_frame_rate.den;
2752 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2754 enc->debug |= FF_DEBUG_MV;
2756 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2759 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2760 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2762 (float)rfps / rfps_base, rfps, rfps_base);
2764 /* update the current frame rate to match the stream frame rate */
2765 frame_rate.num = rfps;
2766 frame_rate.den = rfps_base;
2768 enc->rate_emu = rate_emu;
2770 ic->streams[i]->discard= AVDISCARD_ALL;
2771 else if(video_discard)
2772 ic->streams[i]->discard= video_discard;
2774 case CODEC_TYPE_DATA:
2776 case CODEC_TYPE_SUBTITLE:
2777 if(subtitle_disable)
2778 ic->streams[i]->discard = AVDISCARD_ALL;
2780 case CODEC_TYPE_ATTACHMENT:
2781 case CODEC_TYPE_UNKNOWN:
2788 input_files[nb_input_files] = ic;
2789 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2790 /* dump the file content */
2792 dump_format(ic, nb_input_files, filename, 0);
2795 file_iformat = NULL;
2796 file_oformat = NULL;
2801 av_freep(&video_codec_name);
2802 av_freep(&audio_codec_name);
2803 av_freep(&subtitle_codec_name);
2806 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2807 int *has_subtitle_ptr)
2809 int has_video, has_audio, has_subtitle, i, j;
2810 AVFormatContext *ic;
2815 for(j=0;j<nb_input_files;j++) {
2816 ic = input_files[j];
2817 for(i=0;i<ic->nb_streams;i++) {
2818 AVCodecContext *enc = ic->streams[i]->codec;
2819 switch(enc->codec_type) {
2820 case CODEC_TYPE_AUDIO:
2823 case CODEC_TYPE_VIDEO:
2826 case CODEC_TYPE_SUBTITLE:
2829 case CODEC_TYPE_DATA:
2830 case CODEC_TYPE_ATTACHMENT:
2831 case CODEC_TYPE_UNKNOWN:
2838 *has_video_ptr = has_video;
2839 *has_audio_ptr = has_audio;
2840 *has_subtitle_ptr = has_subtitle;
2843 static void new_video_stream(AVFormatContext *oc)
2846 AVCodecContext *video_enc;
2849 st = av_new_stream(oc, oc->nb_streams);
2851 fprintf(stderr, "Could not alloc stream\n");
2854 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2855 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2856 video_bitstream_filters= NULL;
2859 avcodec_thread_init(st->codec, thread_count);
2861 video_enc = st->codec;
2864 video_enc->codec_tag= video_codec_tag;
2866 if( (video_global_header&1)
2867 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2868 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2869 avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2871 if(video_global_header&2){
2872 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2873 avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2876 if (video_stream_copy) {
2877 st->stream_copy = 1;
2878 video_enc->codec_type = CODEC_TYPE_VIDEO;
2883 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
2885 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2886 if (video_codec_name)
2887 codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
2889 video_enc->codec_id = codec_id;
2890 codec = avcodec_find_encoder(codec_id);
2892 for(i=0; i<opt_name_count; i++){
2894 const AVOption *opt;
2895 const char *str= av_get_string(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt, buf, sizeof(buf));
2896 if(str && (opt->flags & AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
2897 av_set_string(video_enc, opt_names[i], str);
2900 video_enc->time_base.den = fps.num;
2901 video_enc->time_base.num = fps.den;
2902 if(codec && codec->supported_framerates){
2903 const AVRational *p= codec->supported_framerates;
2904 const AVRational *best=NULL;
2905 AVRational best_error= (AVRational){INT_MAX, 1};
2906 for(; p->den!=0; p++){
2907 AVRational error= av_sub_q(fps, *p);
2908 if(error.num <0) error.num *= -1;
2909 if(av_cmp_q(error, best_error) < 0){
2914 video_enc->time_base.den= best->num;
2915 video_enc->time_base.num= best->den;
2918 video_enc->width = frame_width + frame_padright + frame_padleft;
2919 video_enc->height = frame_height + frame_padtop + frame_padbottom;
2920 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2921 video_enc->pix_fmt = frame_pix_fmt;
2923 if(codec && codec->pix_fmts){
2924 const enum PixelFormat *p= codec->pix_fmts;
2926 if(*p == video_enc->pix_fmt)
2930 video_enc->pix_fmt = codec->pix_fmts[0];
2934 video_enc->gop_size = 0;
2935 if (video_qscale || same_quality) {
2936 video_enc->flags |= CODEC_FLAG_QSCALE;
2937 video_enc->global_quality=
2938 st->quality = FF_QP2LAMBDA * video_qscale;
2942 video_enc->intra_matrix = intra_matrix;
2944 video_enc->inter_matrix = inter_matrix;
2946 video_enc->max_qdiff = video_qdiff;
2947 video_enc->thread_count = thread_count;
2948 p= video_rc_override_string;
2951 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2953 fprintf(stderr, "error parsing rc_override\n");
2956 video_enc->rc_override=
2957 av_realloc(video_enc->rc_override,
2958 sizeof(RcOverride)*(i+1));
2959 video_enc->rc_override[i].start_frame= start;
2960 video_enc->rc_override[i].end_frame = end;
2962 video_enc->rc_override[i].qscale= q;
2963 video_enc->rc_override[i].quality_factor= 1.0;
2966 video_enc->rc_override[i].qscale= 0;
2967 video_enc->rc_override[i].quality_factor= -q/100.0;
2972 video_enc->rc_override_count=i;
2973 if (!video_enc->rc_initial_buffer_occupancy)
2974 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2975 video_enc->me_threshold= me_threshold;
2976 video_enc->intra_dc_precision= intra_dc_precision - 8;
2977 video_enc->strict_std_compliance = strict;
2980 video_enc->flags|= CODEC_FLAG_PSNR;
2985 video_enc->flags |= CODEC_FLAG_PASS1;
2987 video_enc->flags |= CODEC_FLAG_PASS2;
2992 /* reset some key parameters */
2994 av_freep(&video_codec_name);
2995 video_stream_copy = 0;
2998 static void new_audio_stream(AVFormatContext *oc)
3001 AVCodecContext *audio_enc;
3004 st = av_new_stream(oc, oc->nb_streams);
3006 fprintf(stderr, "Could not alloc stream\n");
3009 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3011 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3012 audio_bitstream_filters= NULL;
3015 avcodec_thread_init(st->codec, thread_count);
3017 audio_enc = st->codec;
3018 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3019 audio_enc->strict_std_compliance = strict;
3022 audio_enc->codec_tag= audio_codec_tag;
3024 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3025 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3026 avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3028 if (audio_stream_copy) {
3029 st->stream_copy = 1;
3030 audio_enc->channels = audio_channels;
3032 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3034 for(i=0; i<opt_name_count; i++){
3036 const AVOption *opt;
3037 const char *str= av_get_string(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt, buf, sizeof(buf));
3038 if(str && (opt->flags & AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3039 av_set_string(audio_enc, opt_names[i], str);
3042 if (audio_codec_name)
3043 codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3044 audio_enc->codec_id = codec_id;
3046 if (audio_qscale > QSCALE_NONE) {
3047 audio_enc->flags |= CODEC_FLAG_QSCALE;
3048 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3050 audio_enc->thread_count = thread_count;
3051 audio_enc->channels = audio_channels;
3053 audio_enc->sample_rate = audio_sample_rate;
3054 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3055 if (audio_language) {
3056 av_strlcpy(st->language, audio_language, sizeof(st->language));
3057 av_free(audio_language);
3058 audio_language = NULL;
3061 /* reset some key parameters */
3063 av_freep(&audio_codec_name);
3064 audio_stream_copy = 0;
3067 static void new_subtitle_stream(AVFormatContext *oc)
3070 AVCodecContext *subtitle_enc;
3073 st = av_new_stream(oc, oc->nb_streams);
3075 fprintf(stderr, "Could not alloc stream\n");
3078 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3080 bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3081 subtitle_bitstream_filters= NULL;
3083 subtitle_enc = st->codec;
3084 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3085 if (subtitle_stream_copy) {
3086 st->stream_copy = 1;
3088 for(i=0; i<opt_name_count; i++){
3090 const AVOption *opt;
3091 const char *str= av_get_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt_names[i], &opt, buf, sizeof(buf));
3092 if(str && (opt->flags & AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3093 av_set_string(subtitle_enc, opt_names[i], str);
3095 subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3098 if (subtitle_language) {
3099 av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3100 av_free(subtitle_language);
3101 subtitle_language = NULL;
3104 subtitle_disable = 0;
3105 av_freep(&subtitle_codec_name);
3106 subtitle_stream_copy = 0;
3109 static void opt_new_audio_stream(void)
3111 AVFormatContext *oc;
3112 if (nb_output_files <= 0) {
3113 fprintf(stderr, "At least one output file must be specified\n");
3116 oc = output_files[nb_output_files - 1];
3117 new_audio_stream(oc);
3120 static void opt_new_video_stream(void)
3122 AVFormatContext *oc;
3123 if (nb_output_files <= 0) {
3124 fprintf(stderr, "At least one output file must be specified\n");
3127 oc = output_files[nb_output_files - 1];
3128 new_video_stream(oc);
3131 static void opt_new_subtitle_stream(void)
3133 AVFormatContext *oc;
3134 if (nb_output_files <= 0) {
3135 fprintf(stderr, "At least one output file must be specified\n");
3138 oc = output_files[nb_output_files - 1];
3139 new_subtitle_stream(oc);
3142 static void opt_output_file(const char *filename)
3144 AVFormatContext *oc;
3145 int use_video, use_audio, use_subtitle;
3146 int input_has_video, input_has_audio, input_has_subtitle, i;
3147 AVFormatParameters params, *ap = ¶ms;
3149 if (!strcmp(filename, "-"))
3152 oc = av_alloc_format_context();
3154 if (!file_oformat) {
3155 file_oformat = guess_format(NULL, filename, NULL);
3156 if (!file_oformat) {
3157 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3163 oc->oformat = file_oformat;
3164 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3166 if (!strcmp(file_oformat->name, "ffm") &&
3167 av_strstart(filename, "http:", NULL)) {
3168 /* special case for files sent to ffserver: we get the stream
3169 parameters from ffserver */
3170 if (read_ffserver_streams(oc, filename) < 0) {
3171 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3175 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3176 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3177 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3179 /* disable if no corresponding type found and at least one
3181 if (nb_input_files > 0) {
3182 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3183 &input_has_subtitle);
3184 if (!input_has_video)
3186 if (!input_has_audio)
3188 if (!input_has_subtitle)
3192 /* manual disable */
3193 if (audio_disable) {
3196 if (video_disable) {
3199 if (subtitle_disable) {
3204 new_video_stream(oc);
3208 new_audio_stream(oc);
3212 new_subtitle_stream(oc);
3215 oc->timestamp = rec_timestamp;
3218 av_strlcpy(oc->title, str_title, sizeof(oc->title));
3220 av_strlcpy(oc->author, str_author, sizeof(oc->author));
3222 av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3224 av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3226 av_strlcpy(oc->album, str_album, sizeof(oc->album));
3228 av_strlcpy(oc->genre, str_genre, sizeof(oc->genre));
3231 output_files[nb_output_files++] = oc;
3233 /* check filename in case of an image number is expected */
3234 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3235 if (!av_filename_number_test(oc->filename)) {
3236 print_error(oc->filename, AVERROR_NUMEXPECTED);
3241 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3242 /* test if it already exists to avoid loosing precious files */
3243 if (!file_overwrite &&
3244 (strchr(filename, ':') == NULL ||
3245 filename[1] == ':' ||
3246 av_strstart(filename, "file:", NULL))) {
3247 if (url_exist(filename)) {
3250 if ( !using_stdin ) {
3251 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3254 if (toupper(c) != 'Y') {
3255 fprintf(stderr, "Not overwriting - exiting\n");
3260 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3267 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3268 fprintf(stderr, "Could not open '%s'\n", filename);
3273 memset(ap, 0, sizeof(*ap));
3274 if (av_set_parameters(oc, ap) < 0) {
3275 fprintf(stderr, "%s: Invalid encoding parameters\n",
3280 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3281 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3282 oc->loop_output = loop_output;
3284 for(i=0; i<opt_name_count; i++){
3286 const AVOption *opt;
3287 const char *str= av_get_string(avformat_opts, opt_names[i], &opt, buf, sizeof(buf));
3288 if(str && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3289 av_set_string(oc, opt_names[i], str);
3292 /* reset some options */
3293 file_oformat = NULL;
3294 file_iformat = NULL;
3297 /* same option as mencoder */
3298 static void opt_pass(const char *pass_str)
3301 pass = atoi(pass_str);
3302 if (pass != 1 && pass != 2) {
3303 fprintf(stderr, "pass number can be only 1 or 2\n");
3309 static int64_t getutime(void)
3311 #ifdef HAVE_GETRUSAGE
3312 struct rusage rusage;
3314 getrusage(RUSAGE_SELF, &rusage);
3315 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3316 #elif defined(HAVE_GETPROCESSTIMES)
3318 FILETIME c, e, k, u;
3319 proc = GetCurrentProcess();
3320 GetProcessTimes(proc, &c, &e, &k, &u);
3321 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3323 return av_gettime();
3327 static void opt_show_formats(void)
3329 AVInputFormat *ifmt=NULL;
3330 AVOutputFormat *ofmt=NULL;
3331 URLProtocol *up=NULL;
3332 AVCodec *p=NULL, *p2;
3333 AVBitStreamFilter *bsf=NULL;
3334 const char *last_name;
3336 printf("File formats:\n");
3341 const char *name=NULL;
3342 const char *long_name=NULL;
3344 while((ofmt= av_oformat_next(ofmt))) {
3345 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3346 strcmp(ofmt->name, last_name)>0){
3348 long_name= ofmt->long_name;
3352 while((ifmt= av_iformat_next(ifmt))) {
3353 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3354 strcmp(ifmt->name, last_name)>0){
3356 long_name= ifmt->long_name;
3359 if(name && strcmp(ifmt->name, name)==0)
3371 long_name ? long_name:" ");
3375 printf("Codecs:\n");
3381 const char *type_str;
3384 while((p= av_codec_next(p))) {
3385 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3386 strcmp(p->name, last_name)>0){
3388 decode= encode= cap=0;
3390 if(p2 && strcmp(p->name, p2->name)==0){
3391 if(p->decode) decode=1;
3392 if(p->encode) encode=1;
3393 cap |= p->capabilities;
3398 last_name= p2->name;
3401 case CODEC_TYPE_VIDEO:
3404 case CODEC_TYPE_AUDIO:
3407 case CODEC_TYPE_SUBTITLE:
3416 decode ? "D": (/*p2->decoder ? "d":*/" "),
3419 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3420 cap & CODEC_CAP_DR1 ? "D":" ",
3421 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3423 /* if(p2->decoder && decode==0)
3424 printf(" use %s for decoding", p2->decoder->name);*/
3429 printf("Bitstream filters:\n");
3430 while((bsf = av_bitstream_filter_next(bsf)))
3431 printf(" %s", bsf->name);
3434 printf("Supported file protocols:\n");
3435 while((up = av_protocol_next(up)))
3436 printf(" %s:", up->name);
3439 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3442 "Note, the names of encoders and decoders do not always match, so there are\n"
3443 "several cases where the above table shows encoder only or decoder only entries\n"
3444 "even though both encoding and decoding are supported. For example, the h263\n"
3445 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
3450 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3453 const char *p = str;
3460 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3467 static void opt_inter_matrix(const char *arg)
3469 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3470 parse_matrix_coeffs(inter_matrix, arg);
3473 static void opt_intra_matrix(const char *arg)
3475 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3476 parse_matrix_coeffs(intra_matrix, arg);
3480 * Trivial log callback.
3481 * Only suitable for show_help and similar since it lacks prefix handling.
3483 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3485 vfprintf(stdout, fmt, vl);
3488 static void show_help(void)
3490 av_log_set_callback(log_callback_help);
3491 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3492 "Hyper fast Audio and Video encoder\n");
3494 show_help_options(options, "Main options:\n",
3495 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3496 show_help_options(options, "\nVideo options:\n",
3497 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3499 show_help_options(options, "\nAdvanced Video options:\n",
3500 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3501 OPT_VIDEO | OPT_EXPERT);
3502 show_help_options(options, "\nAudio options:\n",
3503 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3505 show_help_options(options, "\nAdvanced Audio options:\n",
3506 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3507 OPT_AUDIO | OPT_EXPERT);
3508 show_help_options(options, "\nSubtitle options:\n",
3509 OPT_SUBTITLE | OPT_GRAB,
3511 show_help_options(options, "\nAudio/Video grab options:\n",
3514 show_help_options(options, "\nAdvanced options:\n",
3515 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3517 av_opt_show(avctx_opts[0], NULL);
3518 av_opt_show(avformat_opts, NULL);
3519 av_opt_show(sws_opts, NULL);
3522 static void opt_show_help(void)
3528 static void opt_target(const char *arg)
3531 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3533 if(!strncmp(arg, "pal-", 4)) {
3536 } else if(!strncmp(arg, "ntsc-", 5)) {
3539 } else if(!strncmp(arg, "film-", 5)) {
3544 /* Calculate FR via float to avoid int overflow */
3545 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3548 } else if((fr == 29970) || (fr == 23976)) {
3551 /* Try to determine PAL/NTSC by peeking in the input files */
3552 if(nb_input_files) {
3554 for(j = 0; j < nb_input_files; j++) {
3555 for(i = 0; i < input_files[j]->nb_streams; i++) {
3556 AVCodecContext *c = input_files[j]->streams[i]->codec;
3557 if(c->codec_type != CODEC_TYPE_VIDEO)
3559 fr = c->time_base.den * 1000 / c->time_base.num;
3563 } else if((fr == 29970) || (fr == 23976)) {
3573 if(verbose && norm >= 0)
3574 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3578 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3579 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3580 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3584 if(!strcmp(arg, "vcd")) {
3586 opt_video_codec("mpeg1video");
3587 opt_audio_codec("mp2");
3590 opt_frame_size(norm ? "352x240" : "352x288");
3591 opt_frame_rate(frame_rates[norm]);
3592 opt_default("gop", norm ? "18" : "15");
3594 opt_default("b", "1150000");
3595 opt_default("maxrate", "1150000");
3596 opt_default("minrate", "1150000");
3597 opt_default("bufsize", "327680"); // 40*1024*8;
3599 opt_default("ab", "224000");
3600 audio_sample_rate = 44100;
3603 opt_default("packetsize", "2324");
3604 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3606 /* We have to offset the PTS, so that it is consistent with the SCR.
3607 SCR starts at 36000, but the first two packs contain only padding
3608 and the first pack from the other stream, respectively, may also have
3609 been written before.
3610 So the real data starts at SCR 36000+3*1200. */
3611 mux_preload= (36000+3*1200) / 90000.0; //0.44
3612 } else if(!strcmp(arg, "svcd")) {
3614 opt_video_codec("mpeg2video");
3615 opt_audio_codec("mp2");
3618 opt_frame_size(norm ? "480x480" : "480x576");
3619 opt_frame_rate(frame_rates[norm]);
3620 opt_default("gop", norm ? "18" : "15");
3622 opt_default("b", "2040000");
3623 opt_default("maxrate", "2516000");
3624 opt_default("minrate", "0"); //1145000;
3625 opt_default("bufsize", "1835008"); //224*1024*8;
3626 opt_default("flags", "+SCAN_OFFSET");
3629 opt_default("ab", "224000");
3630 audio_sample_rate = 44100;
3632 opt_default("packetsize", "2324");
3634 } else if(!strcmp(arg, "dvd")) {
3636 opt_video_codec("mpeg2video");
3637 opt_audio_codec("ac3");
3640 opt_frame_size(norm ? "720x480" : "720x576");
3641 opt_frame_rate(frame_rates[norm]);
3642 opt_default("gop", norm ? "18" : "15");
3644 opt_default("b", "6000000");
3645 opt_default("maxrate", "9000000");
3646 opt_default("minrate", "0"); //1500000;
3647 opt_default("bufsize", "1835008"); //224*1024*8;
3649 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3650 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3652 opt_default("ab", "448000");
3653 audio_sample_rate = 48000;
3655 } else if(!strncmp(arg, "dv", 2)) {
3659 opt_frame_size(norm ? "720x480" : "720x576");
3660 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3661 (norm ? "yuv411p" : "yuv420p"));
3662 opt_frame_rate(frame_rates[norm]);
3664 audio_sample_rate = 48000;
3668 fprintf(stderr, "Unknown target: %s\n", arg);
3673 static void opt_vstats_file (const char *arg)
3675 av_free (vstats_filename);
3676 vstats_filename=av_strdup (arg);
3679 static void opt_vstats (void)
3682 time_t today2 = time(NULL);
3683 struct tm *today = localtime(&today2);
3685 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3687 opt_vstats_file(filename);
3690 static int opt_bsf(const char *opt, const char *arg)
3692 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3693 AVBitStreamFilterContext **bsfp;
3696 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3700 bsfp= *opt == 'v' ? &video_bitstream_filters :
3701 *opt == 'a' ? &audio_bitstream_filters :
3702 &subtitle_bitstream_filters;
3704 bsfp= &(*bsfp)->next;
3711 static void opt_show_license(void)
3717 static void opt_show_version(void)
3719 show_version(program_name);
3723 const OptionDef options[] = {
3725 { "L", 0, {(void*)opt_show_license}, "show license" },
3726 { "h", 0, {(void*)opt_show_help}, "show help" },
3727 { "version", 0, {(void*)opt_show_version}, "show version" },
3728 { "formats", 0, {(void*)opt_show_formats}, "show available formats, codecs, protocols, ..." },
3729 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3730 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3731 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3732 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3733 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3734 { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3735 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3736 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3737 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3738 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3739 { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3740 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3741 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3742 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3743 { "genre", HAS_ARG | OPT_STRING, {(void*)&str_genre}, "set the genre", "string" },
3744 { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3745 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3746 "add timings for benchmarking" },
3747 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3748 "dump each input packet" },
3749 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3750 "when dumping packets, also dump the payload" },
3751 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3752 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3753 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "number of times to loop output in formats that support looping (0 loops forever)", "" },
3754 { "v", HAS_ARG, {(void*)opt_verbose}, "set the logging verbosity level", "number" },
3755 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3756 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3757 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3758 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3759 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "" },
3760 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3761 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3762 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3763 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
3764 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3767 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "" },
3768 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "" },
3769 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3770 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3771 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3772 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3773 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3774 { "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" },
3775 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3776 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3777 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3778 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3779 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3780 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3781 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3782 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3783 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3784 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3785 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3786 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3787 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3788 { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantizer scale (VBR)", "q" },
3789 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3790 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3791 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "" },
3792 { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3793 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3794 "use same video quality as source (implies VBR)" },
3795 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3796 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3797 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3798 "deinterlace pictures" },
3799 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3800 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3801 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3803 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3805 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3806 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3807 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3808 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3809 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3810 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3811 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3814 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "" },
3815 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3816 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3817 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3818 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3819 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3820 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3821 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3822 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3823 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3824 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3826 /* subtitle options */
3827 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3828 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3829 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3830 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3833 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3834 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3835 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3838 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3839 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3841 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" },
3842 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" },
3843 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" },
3845 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3849 static int av_exit()
3854 for(i=0;i<nb_output_files;i++) {
3855 /* maybe av_close_output_file ??? */
3856 AVFormatContext *s = output_files[i];
3858 if (!(s->oformat->flags & AVFMT_NOFILE))
3860 for(j=0;j<s->nb_streams;j++) {
3861 av_free(s->streams[j]->codec);
3862 av_free(s->streams[j]);
3866 for(i=0;i<nb_input_files;i++)
3867 av_close_input_file(input_files[i]);
3871 av_free(intra_matrix);
3872 av_free(inter_matrix);
3875 fclose(vstats_file);
3876 av_free(vstats_filename);
3880 av_free(video_codec_name);
3881 av_free(audio_codec_name);
3882 av_free(subtitle_codec_name);
3884 av_free(video_standard);
3886 #ifdef CONFIG_POWERPC_PERF
3887 extern void powerpc_display_perf_report(void);
3888 powerpc_display_perf_report();
3889 #endif /* CONFIG_POWERPC_PERF */
3891 if (received_sigterm) {
3893 "Received signal %d: terminating.\n",
3894 (int) received_sigterm);
3898 exit(0); /* not all OS-es handle main() return value */
3902 int main(int argc, char **argv)
3907 avcodec_register_all();
3908 avdevice_register_all();
3911 for(i=0; i<CODEC_TYPE_NB; i++){
3912 avctx_opts[i]= avcodec_alloc_context2(i);
3914 avformat_opts = av_alloc_format_context();
3915 sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3917 show_banner(program_name, program_birth_year);
3924 parse_options(argc, argv, options, opt_output_file);
3926 /* file converter / grab */
3927 if (nb_output_files <= 0) {
3928 fprintf(stderr, "Must supply at least one output file\n");
3932 if (nb_input_files == 0) {
3933 fprintf(stderr, "Must supply at least one input file\n");
3938 av_encode(output_files, nb_output_files, input_files, nb_input_files,
3939 stream_maps, nb_stream_maps);
3940 ti = getutime() - ti;
3942 printf("bench: utime=%0.3fs\n", ti / 1000000.0);