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
32 #include "framehook.h"
37 #if !defined(HAVE_GETRUSAGE) && defined(HAVE_GETPROCESSTIMES)
41 #if defined(HAVE_TERMIOS_H)
44 #include <sys/ioctl.h>
47 #include <sys/resource.h>
48 #elif defined(HAVE_CONIO_H)
51 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
60 #if !defined(INFINITY) && defined(HUGE_VAL)
61 #define INFINITY HUGE_VAL
66 static const char program_name[] = "FFmpeg";
67 static const int program_birth_year = 2000;
69 /* select an input stream for an output stream */
70 typedef struct AVStreamMap {
74 int sync_stream_index;
77 /** select an input file for an output file */
78 typedef struct AVMetaDataMap {
83 extern const OptionDef options[];
85 static void show_help(void);
86 static void opt_show_license(void);
87 static int opt_default(const char *opt, const char *arg);
91 static AVFormatContext *input_files[MAX_FILES];
92 static int64_t input_files_ts_offset[MAX_FILES];
93 static int nb_input_files = 0;
95 static AVFormatContext *output_files[MAX_FILES];
96 static int nb_output_files = 0;
98 static AVStreamMap stream_maps[MAX_FILES];
99 static int nb_stream_maps;
101 static AVMetaDataMap meta_data_maps[MAX_FILES];
102 static int nb_meta_data_maps;
104 static AVInputFormat *file_iformat;
105 static AVOutputFormat *file_oformat;
106 static int frame_width = 0;
107 static int frame_height = 0;
108 static float frame_aspect_ratio = 0;
109 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
110 static int frame_padtop = 0;
111 static int frame_padbottom = 0;
112 static int frame_padleft = 0;
113 static int frame_padright = 0;
114 static int padcolor[3] = {16,128,128}; /* default to black */
115 static int frame_topBand = 0;
116 static int frame_bottomBand = 0;
117 static int frame_leftBand = 0;
118 static int frame_rightBand = 0;
119 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
120 static AVRational frame_rate = (AVRational) {25,1};
121 static float video_qscale = 0;
122 static int video_qdiff = 3;
123 static uint16_t *intra_matrix = NULL;
124 static uint16_t *inter_matrix = NULL;
125 #if 0 //experimental, (can be removed)
126 static float video_rc_qsquish=1.0;
127 static float video_rc_qmod_amp=0;
128 static int video_rc_qmod_freq=0;
130 static char *video_rc_override_string=NULL;
131 static char *video_rc_eq="tex^qComp";
132 static int video_disable = 0;
133 static int video_discard = 0;
134 static char *video_codec_name = NULL;
135 static int video_codec_tag = 0;
136 static int same_quality = 0;
137 static int do_deinterlace = 0;
138 static int strict = 0;
139 static int top_field_first = -1;
140 static int me_threshold = 0;
141 static int intra_dc_precision = 8;
142 static int loop_input = 0;
143 static int loop_output = AVFMT_NOOUTPUTLOOP;
144 static int qp_hist = 0;
146 static int intra_only = 0;
147 static int audio_sample_rate = 44100;
148 #define QSCALE_NONE -99999
149 static float audio_qscale = QSCALE_NONE;
150 static int audio_disable = 0;
151 static int audio_channels = 1;
152 static char *audio_codec_name = NULL;
153 static int audio_codec_tag = 0;
154 static char *audio_language = NULL;
156 static int subtitle_disable = 0;
157 static char *subtitle_codec_name = NULL;
158 static char *subtitle_language = NULL;
160 static float mux_preload= 0.5;
161 static float mux_max_delay= 0.7;
163 static int64_t recording_time = 0;
164 static int64_t start_time = 0;
165 static int64_t rec_timestamp = 0;
166 static int64_t input_ts_offset = 0;
167 static int file_overwrite = 0;
168 static char *str_title = NULL;
169 static char *str_author = NULL;
170 static char *str_copyright = NULL;
171 static char *str_comment = NULL;
172 static char *str_album = NULL;
173 static int do_benchmark = 0;
174 static int do_hex_dump = 0;
175 static int do_pkt_dump = 0;
176 static int do_psnr = 0;
177 static int do_pass = 0;
178 static char *pass_logfilename = NULL;
179 static int audio_stream_copy = 0;
180 static int video_stream_copy = 0;
181 static int subtitle_stream_copy = 0;
182 static int video_sync_method= 1;
183 static int audio_sync_method= 0;
184 static float audio_drift_threshold= 0.1;
185 static int copy_ts= 0;
186 static int opt_shortest = 0; //
187 static int video_global_header = 0;
188 static char *vstats_filename;
189 static FILE *vstats_file;
191 static int rate_emu = 0;
193 static int video_channel = 0;
194 static char *video_standard;
196 static int audio_volume = 256;
198 static int using_stdin = 0;
199 static int using_vhook = 0;
200 static int verbose = 1;
201 static int thread_count= 1;
202 static int q_pressed = 0;
203 static int64_t video_size = 0;
204 static int64_t audio_size = 0;
205 static int64_t extra_size = 0;
206 static int nb_frames_dup = 0;
207 static int nb_frames_drop = 0;
208 static int input_sync;
209 static uint64_t limit_filesize = 0; //
211 static int pgmyuv_compatibility_hack=0;
212 static float dts_delta_threshold = 10;
214 static int sws_flags = SWS_BICUBIC;
216 static const char **opt_names;
217 static int opt_name_count;
218 static AVCodecContext *avctx_opts[CODEC_TYPE_NB];
219 static AVFormatContext *avformat_opts;
220 static struct SwsContext *sws_opts;
221 static int64_t timer_start;
223 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
224 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
225 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
227 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
229 struct AVInputStream;
231 typedef struct AVOutputStream {
232 int file_index; /* file index */
233 int index; /* stream index in the output file */
234 int source_index; /* AVInputStream index */
235 AVStream *st; /* stream in the output file */
236 int encoding_needed; /* true if encoding needed for this stream */
238 /* input pts and corresponding output pts
240 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
241 struct AVInputStream *sync_ist; /* input stream to sync against */
242 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
245 AVFrame pict_tmp; /* temporary image for resampling */
246 struct SwsContext *img_resample_ctx; /* for image resampling */
250 int topBand; /* cropping area sizes */
254 int padtop; /* padding area sizes */
261 ReSampleContext *resample; /* for audio resampling */
262 AVFifoBuffer fifo; /* for compression: one audio fifo per codec */
266 typedef struct AVInputStream {
270 int discard; /* true if stream data should be discarded */
271 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
272 int64_t sample_index; /* current sample */
274 int64_t start; /* time when read started */
275 unsigned long frame; /* current frame */
276 int64_t next_pts; /* synthetic pts for cases where pkt.pts
278 int64_t pts; /* current pts */
279 int is_start; /* is 1 at the start and after a discontinuity */
282 typedef struct AVInputFile {
283 int eof_reached; /* true if eof reached */
284 int ist_index; /* index of first stream in ist_table */
285 int buffer_size; /* current total buffer size */
286 int nb_streams; /* nb streams we are aware of */
289 #ifdef HAVE_TERMIOS_H
291 /* init terminal so that we can grab keys */
292 static struct termios oldtty;
295 static void term_exit(void)
297 #ifdef HAVE_TERMIOS_H
298 tcsetattr (0, TCSANOW, &oldtty);
302 static volatile sig_atomic_t received_sigterm = 0;
305 sigterm_handler(int sig)
307 received_sigterm = sig;
311 static void term_init(void)
313 #ifdef HAVE_TERMIOS_H
319 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
320 |INLCR|IGNCR|ICRNL|IXON);
321 tty.c_oflag |= OPOST;
322 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
323 tty.c_cflag &= ~(CSIZE|PARENB);
328 tcsetattr (0, TCSANOW, &tty);
329 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
332 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
333 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
335 register a function to be called at normal program termination
338 #ifdef CONFIG_BEOS_NETSERVER
339 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
343 /* read a key without blocking */
344 static int read_key(void)
346 #if defined(HAVE_TERMIOS_H)
349 #ifndef CONFIG_BEOS_NETSERVER
357 n = select(1, &rfds, NULL, NULL, &tv);
366 #elif defined(HAVE_CONIO_H)
373 static int decode_interrupt_cb(void)
375 return q_pressed || (q_pressed = read_key() == 'q');
378 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
383 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
386 /* copy stream format */
387 s->nb_streams = ic->nb_streams;
388 for(i=0;i<ic->nb_streams;i++) {
391 // FIXME: a more elegant solution is needed
392 st = av_mallocz(sizeof(AVStream));
393 memcpy(st, ic->streams[i], sizeof(AVStream));
394 st->codec = avcodec_alloc_context();
395 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
399 av_close_input_file(ic);
404 get_sync_ipts(const AVOutputStream *ost)
406 const AVInputStream *ist = ost->sync_ist;
407 return (double)(ist->pts - start_time)/AV_TIME_BASE;
410 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
412 AVPacket new_pkt= *pkt;
413 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
414 &new_pkt.data, &new_pkt.size,
415 pkt->data, pkt->size,
416 pkt->flags & PKT_FLAG_KEY);
419 new_pkt.destruct= av_destruct_packet;
426 av_interleaved_write_frame(s, pkt);
429 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
431 static void do_audio_out(AVFormatContext *s,
434 unsigned char *buf, int size)
437 static uint8_t *audio_buf = NULL;
438 static uint8_t *audio_out = NULL;
439 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
441 int size_out, frame_bytes, ret;
442 AVCodecContext *enc= ost->st->codec;
444 /* SC: dynamic allocation of buffers */
446 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
448 audio_out = av_malloc(audio_out_size);
449 if (!audio_buf || !audio_out)
450 return; /* Should signal an error ! */
452 if(audio_sync_method){
453 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
454 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
455 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
456 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
458 //FIXME resample delay
459 if(fabs(delta) > 50){
460 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
462 byte_delta= FFMAX(byte_delta, -size);
466 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
471 static uint8_t *input_tmp= NULL;
472 input_tmp= av_realloc(input_tmp, byte_delta + size);
474 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
477 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
479 memset(input_tmp, 0, byte_delta);
480 memcpy(input_tmp + byte_delta, buf, size);
484 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
486 }else if(audio_sync_method>1){
487 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
488 assert(ost->audio_resample);
490 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
491 // 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));
492 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
496 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
497 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
499 if (ost->audio_resample) {
501 size_out = audio_resample(ost->resample,
502 (short *)buftmp, (short *)buf,
503 size / (ist->st->codec->channels * 2));
504 size_out = size_out * enc->channels * 2;
510 /* now encode as many frames as possible */
511 if (enc->frame_size > 1) {
512 /* output resampled raw samples */
513 av_fifo_write(&ost->fifo, buftmp, size_out);
515 frame_bytes = enc->frame_size * 2 * enc->channels;
517 while (av_fifo_read(&ost->fifo, audio_buf, frame_bytes) == 0) {
519 av_init_packet(&pkt);
521 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
524 pkt.stream_index= ost->index;
527 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
528 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
529 pkt.flags |= PKT_FLAG_KEY;
530 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
532 ost->sync_opts += enc->frame_size;
536 av_init_packet(&pkt);
538 ost->sync_opts += size_out / (2 * enc->channels);
540 /* output a pcm frame */
541 /* XXX: change encoding codec API to avoid this ? */
542 switch(enc->codec->id) {
543 case CODEC_ID_PCM_S32LE:
544 case CODEC_ID_PCM_S32BE:
545 case CODEC_ID_PCM_U32LE:
546 case CODEC_ID_PCM_U32BE:
547 size_out = size_out << 1;
549 case CODEC_ID_PCM_S24LE:
550 case CODEC_ID_PCM_S24BE:
551 case CODEC_ID_PCM_U24LE:
552 case CODEC_ID_PCM_U24BE:
553 case CODEC_ID_PCM_S24DAUD:
554 size_out = size_out / 2 * 3;
556 case CODEC_ID_PCM_S16LE:
557 case CODEC_ID_PCM_S16BE:
558 case CODEC_ID_PCM_U16LE:
559 case CODEC_ID_PCM_U16BE:
562 size_out = size_out >> 1;
565 ret = avcodec_encode_audio(enc, audio_out, size_out,
568 pkt.stream_index= ost->index;
571 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
572 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
573 pkt.flags |= PKT_FLAG_KEY;
574 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
578 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
582 AVPicture picture_tmp;
585 dec = ist->st->codec;
587 /* deinterlace : must be done before any resize */
588 if (do_deinterlace || using_vhook) {
591 /* create temporary picture */
592 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
593 buf = av_malloc(size);
597 picture2 = &picture_tmp;
598 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
601 if(avpicture_deinterlace(picture2, picture,
602 dec->pix_fmt, dec->width, dec->height) < 0) {
603 /* if error, do not deinterlace */
609 av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
616 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,
617 1000000 * ist->pts / AV_TIME_BASE);
619 if (picture != picture2)
620 *picture = *picture2;
624 /* we begin to correct av delay at this threshold */
625 #define AV_DELAY_MAX 0.100
627 static void do_subtitle_out(AVFormatContext *s,
633 static uint8_t *subtitle_out = NULL;
634 int subtitle_out_max_size = 65536;
635 int subtitle_out_size, nb, i;
639 if (pts == AV_NOPTS_VALUE) {
640 fprintf(stderr, "Subtitle packets must have a pts\n");
644 enc = ost->st->codec;
647 subtitle_out = av_malloc(subtitle_out_max_size);
650 /* Note: DVB subtitle need one packet to draw them and one other
651 packet to clear them */
652 /* XXX: signal it in the codec context ? */
653 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
658 for(i = 0; i < nb; i++) {
659 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
660 subtitle_out_max_size, sub);
662 av_init_packet(&pkt);
663 pkt.stream_index = ost->index;
664 pkt.data = subtitle_out;
665 pkt.size = subtitle_out_size;
666 pkt.pts = av_rescale_q(pts, ist->st->time_base, ost->st->time_base);
667 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
668 /* XXX: the pts correction is handled here. Maybe handling
669 it in the codec would be better */
671 pkt.pts += 90 * sub->start_display_time;
673 pkt.pts += 90 * sub->end_display_time;
675 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
679 static int bit_buffer_size= 1024*256;
680 static uint8_t *bit_buffer= NULL;
682 static void do_video_out(AVFormatContext *s,
688 int nb_frames, i, ret;
689 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
690 AVFrame picture_crop_temp, picture_pad_temp;
691 AVCodecContext *enc, *dec;
693 avcodec_get_frame_defaults(&picture_crop_temp);
694 avcodec_get_frame_defaults(&picture_pad_temp);
696 enc = ost->st->codec;
697 dec = ist->st->codec;
699 /* by default, we output a single frame */
704 if(video_sync_method){
706 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
707 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
710 else if (vdelta > 1.1)
711 nb_frames = lrintf(vdelta);
712 //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);
716 fprintf(stderr, "*** drop!\n");
717 }else if (nb_frames > 1) {
718 nb_frames_dup += nb_frames;
720 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
723 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
725 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
729 if (ost->video_crop) {
730 if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
731 av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
734 formatted_picture = &picture_crop_temp;
736 formatted_picture = in_picture;
739 final_picture = formatted_picture;
740 padding_src = formatted_picture;
741 resampling_dst = &ost->pict_tmp;
742 if (ost->video_pad) {
743 final_picture = &ost->pict_tmp;
744 if (ost->video_resample) {
745 if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
746 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
749 resampling_dst = &picture_pad_temp;
753 if (ost->video_resample) {
755 final_picture = &ost->pict_tmp;
756 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
757 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
760 if (ost->video_pad) {
761 av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
762 enc->height, enc->width, enc->pix_fmt,
763 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
766 /* duplicates frame if needed */
767 for(i=0;i<nb_frames;i++) {
769 av_init_packet(&pkt);
770 pkt.stream_index= ost->index;
772 if (s->oformat->flags & AVFMT_RAWPICTURE) {
773 /* raw pictures are written as AVPicture structure to
774 avoid any copies. We support temorarily the older
776 AVFrame* old_frame = enc->coded_frame;
777 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
778 pkt.data= (uint8_t *)final_picture;
779 pkt.size= sizeof(AVPicture);
780 if(dec->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
781 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
782 if(dec->coded_frame && dec->coded_frame->key_frame)
783 pkt.flags |= PKT_FLAG_KEY;
785 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
786 enc->coded_frame = old_frame;
790 big_picture= *final_picture;
791 /* better than nothing: use input picture interlaced
793 big_picture.interlaced_frame = in_picture->interlaced_frame;
794 if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
795 if(top_field_first == -1)
796 big_picture.top_field_first = in_picture->top_field_first;
798 big_picture.top_field_first = top_field_first;
801 /* handles sameq here. This is not correct because it may
802 not be a global option */
804 big_picture.quality = ist->st->quality;
806 big_picture.quality = ost->st->quality;
808 big_picture.pict_type = 0;
809 // big_picture.pts = AV_NOPTS_VALUE;
810 big_picture.pts= ost->sync_opts;
811 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
812 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
813 ret = avcodec_encode_video(enc,
814 bit_buffer, bit_buffer_size,
817 fprintf(stderr, "Video encoding failed\n");
820 //enc->frame_number = enc->real_pict_num;
822 pkt.data= bit_buffer;
824 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
825 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
826 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
827 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
828 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
830 if(enc->coded_frame && enc->coded_frame->key_frame)
831 pkt.flags |= PKT_FLAG_KEY;
832 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
834 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
835 // enc->frame_number-1, enc->real_pict_num, ret,
837 /* if two pass, output log */
838 if (ost->logfile && enc->stats_out) {
839 fprintf(ost->logfile, "%s", enc->stats_out);
848 static double psnr(double d){
849 if(d==0) return INFINITY;
850 return -10.0*log(d)/log(10.0);
853 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
858 double ti1, bitrate, avg_bitrate;
860 /* this is executed just the first time do_video_stats is called */
862 vstats_file = fopen(vstats_filename, "w");
869 enc = ost->st->codec;
870 if (enc->codec_type == CODEC_TYPE_VIDEO) {
871 frame_number = ost->frame_number;
872 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
873 if (enc->flags&CODEC_FLAG_PSNR)
874 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
876 fprintf(vstats_file,"f_size= %6d ", frame_size);
877 /* compute pts value */
878 ti1 = ost->sync_opts * av_q2d(enc->time_base);
882 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
883 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
884 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
885 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
886 fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
890 static void print_report(AVFormatContext **output_files,
891 AVOutputStream **ost_table, int nb_ostreams,
896 AVFormatContext *oc, *os;
899 int frame_number, vid, i;
900 double bitrate, ti1, pts;
901 static int64_t last_time = -1;
902 static int qp_histogram[52];
904 if (!is_last_report) {
906 /* display the report every 0.5 seconds */
907 cur_time = av_gettime();
908 if (last_time == -1) {
909 last_time = cur_time;
912 if ((cur_time - last_time) < 500000)
914 last_time = cur_time;
918 oc = output_files[0];
920 total_size = url_fsize(&oc->pb);
921 if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
922 total_size= url_ftell(&oc->pb);
927 for(i=0;i<nb_ostreams;i++) {
929 os = output_files[ost->file_index];
930 enc = ost->st->codec;
931 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
932 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
933 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
935 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
936 float t = (av_gettime()-timer_start) / 1000000.0;
938 frame_number = ost->frame_number;
939 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
940 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
941 enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
943 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
944 if(qp_hist && enc->coded_frame){
946 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
947 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
950 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
952 if (enc->flags&CODEC_FLAG_PSNR){
954 double error, error_sum=0;
955 double scale, scale_sum=0;
956 char type[3]= {'Y','U','V'};
957 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
960 error= enc->error[j];
961 scale= enc->width*enc->height*255.0*255.0*frame_number;
963 error= enc->coded_frame->error[j];
964 scale= enc->width*enc->height*255.0*255.0;
969 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
971 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
975 /* compute min output value */
976 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
977 if ((pts < ti1) && (pts > 0))
983 if (verbose || is_last_report) {
984 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
986 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
987 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
988 (double)total_size / 1024, ti1, bitrate);
991 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
992 nb_frames_dup, nb_frames_drop);
995 fprintf(stderr, "%s \r", buf);
1000 if (is_last_report && verbose >= 0){
1001 int64_t raw= audio_size + video_size + extra_size;
1002 fprintf(stderr, "\n");
1003 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1007 100.0*(total_size - raw)/raw
1012 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1013 static int output_packet(AVInputStream *ist, int ist_index,
1014 AVOutputStream **ost_table, int nb_ostreams,
1015 const AVPacket *pkt)
1017 AVFormatContext *os;
1018 AVOutputStream *ost;
1022 int data_size, got_picture;
1024 void *buffer_to_free;
1025 static unsigned int samples_size= 0;
1026 static short *samples= NULL;
1027 AVSubtitle subtitle, *subtitle_to_free;
1031 ist->pts= ist->next_pts; // needed for last packet if vsync=0
1032 } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1033 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1035 // assert(ist->pts == ist->next_pts);
1049 /* decode the packet if needed */
1050 data_buf = NULL; /* fail safe */
1052 subtitle_to_free = NULL;
1053 if (ist->decoding_needed) {
1054 switch(ist->st->codec->codec_type) {
1055 case CODEC_TYPE_AUDIO:{
1057 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE));
1058 data_size= samples_size;
1059 /* XXX: could avoid copy if PCM 16 bits with same
1060 endianness as CPU */
1061 ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1067 /* Some bug in mpeg audio decoder gives */
1068 /* data_size < 0, it seems they are overflows */
1069 if (data_size <= 0) {
1070 /* no audio frame */
1073 data_buf = (uint8_t *)samples;
1074 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1075 (ist->st->codec->sample_rate * ist->st->codec->channels);
1077 case CODEC_TYPE_VIDEO:
1078 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1079 /* XXX: allocate picture correctly */
1080 avcodec_get_frame_defaults(&picture);
1082 ret = avcodec_decode_video(ist->st->codec,
1083 &picture, &got_picture, ptr, len);
1084 ist->st->quality= picture.quality;
1088 /* no picture yet */
1089 goto discard_packet;
1091 if (ist->st->codec->time_base.num != 0) {
1092 ist->next_pts += ((int64_t)AV_TIME_BASE *
1093 ist->st->codec->time_base.num) /
1094 ist->st->codec->time_base.den;
1098 case CODEC_TYPE_SUBTITLE:
1099 ret = avcodec_decode_subtitle(ist->st->codec,
1100 &subtitle, &got_subtitle, ptr, len);
1103 if (!got_subtitle) {
1104 goto discard_packet;
1106 subtitle_to_free = &subtitle;
1113 switch(ist->st->codec->codec_type) {
1114 case CODEC_TYPE_AUDIO:
1115 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1116 (ist->st->codec->sample_rate * ist->st->codec->channels);
1118 case CODEC_TYPE_VIDEO:
1119 if (ist->st->codec->time_base.num != 0) {
1120 ist->next_pts += ((int64_t)AV_TIME_BASE *
1121 ist->st->codec->time_base.num) /
1122 ist->st->codec->time_base.den;
1132 buffer_to_free = NULL;
1133 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1134 pre_process_video_frame(ist, (AVPicture *)&picture,
1138 // preprocess audio (volume)
1139 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1140 if (audio_volume != 256) {
1143 for(i=0;i<(data_size / sizeof(short));i++) {
1144 int v = ((*volp) * audio_volume + 128) >> 8;
1145 if (v < -32768) v = -32768;
1146 if (v > 32767) v = 32767;
1152 /* frame rate emulation */
1153 if (ist->st->codec->rate_emu) {
1154 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1155 int64_t now = av_gettime() - ist->start;
1163 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1164 is the one of the next displayed one */
1165 /* XXX: add mpeg4 too ? */
1166 if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1167 if (ist->st->codec->pict_type != B_TYPE) {
1169 tmp = ist->last_ip_pts;
1170 ist->last_ip_pts = ist->frac_pts.val;
1171 ist->frac_pts.val = tmp;
1175 /* if output time reached then transcode raw format,
1176 encode packets and output them */
1177 if (start_time == 0 || ist->pts >= start_time)
1178 for(i=0;i<nb_ostreams;i++) {
1182 if (ost->source_index == ist_index) {
1183 os = output_files[ost->file_index];
1186 printf("%d: got pts=%0.3f %0.3f\n", i,
1187 (double)pkt->pts / AV_TIME_BASE,
1188 ((double)ist->pts / AV_TIME_BASE) -
1189 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1191 /* set the input output pts pairs */
1192 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1194 if (ost->encoding_needed) {
1195 switch(ost->st->codec->codec_type) {
1196 case CODEC_TYPE_AUDIO:
1197 do_audio_out(os, ost, ist, data_buf, data_size);
1199 case CODEC_TYPE_VIDEO:
1200 do_video_out(os, ost, ist, &picture, &frame_size);
1201 video_size += frame_size;
1202 if (vstats_filename && frame_size)
1203 do_video_stats(os, ost, frame_size);
1205 case CODEC_TYPE_SUBTITLE:
1206 do_subtitle_out(os, ost, ist, &subtitle,
1213 AVFrame avframe; //FIXME/XXX remove this
1215 av_init_packet(&opkt);
1217 if (!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY))
1220 /* no reencoding needed : output the packet directly */
1221 /* force the input stream PTS */
1223 avcodec_get_frame_defaults(&avframe);
1224 ost->st->codec->coded_frame= &avframe;
1225 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1227 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1228 audio_size += data_size;
1229 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1230 video_size += data_size;
1234 opkt.stream_index= ost->index;
1235 if(pkt->pts != AV_NOPTS_VALUE)
1236 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1238 opkt.pts= AV_NOPTS_VALUE;
1240 if (pkt->dts == AV_NOPTS_VALUE)
1241 opkt.dts = av_rescale_q(ist->next_pts, AV_TIME_BASE_Q, ost->st->time_base);
1243 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1245 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1246 opkt.flags= pkt->flags;
1248 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1249 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1250 opkt.destruct= av_destruct_packet;
1252 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
1253 ost->st->codec->frame_number++;
1254 ost->frame_number++;
1255 av_free_packet(&opkt);
1259 av_free(buffer_to_free);
1260 /* XXX: allocate the subtitles in the codec ? */
1261 if (subtitle_to_free) {
1262 if (subtitle_to_free->rects != NULL) {
1263 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1264 av_free(subtitle_to_free->rects[i].bitmap);
1265 av_free(subtitle_to_free->rects[i].rgba_palette);
1267 av_freep(&subtitle_to_free->rects);
1269 subtitle_to_free->num_rects = 0;
1270 subtitle_to_free = NULL;
1277 for(i=0;i<nb_ostreams;i++) {
1279 if (ost->source_index == ist_index) {
1280 AVCodecContext *enc= ost->st->codec;
1281 os = output_files[ost->file_index];
1283 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1285 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1288 if (ost->encoding_needed) {
1292 av_init_packet(&pkt);
1293 pkt.stream_index= ost->index;
1295 switch(ost->st->codec->codec_type) {
1296 case CODEC_TYPE_AUDIO:
1297 fifo_bytes = av_fifo_size(&ost->fifo);
1299 /* encode any samples remaining in fifo */
1300 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1301 int fs_tmp = enc->frame_size;
1302 enc->frame_size = fifo_bytes / (2 * enc->channels);
1303 if(av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes) == 0) {
1304 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1306 enc->frame_size = fs_tmp;
1309 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1312 pkt.flags |= PKT_FLAG_KEY;
1314 case CODEC_TYPE_VIDEO:
1315 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1317 if(enc->coded_frame && enc->coded_frame->key_frame)
1318 pkt.flags |= PKT_FLAG_KEY;
1319 if (ost->logfile && enc->stats_out) {
1320 fprintf(ost->logfile, "%s", enc->stats_out);
1329 pkt.data= bit_buffer;
1331 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1332 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1333 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1345 static void print_sdp(AVFormatContext **avc, int n)
1349 avf_sdp_create(avc, n, sdp, sizeof(sdp));
1350 printf("SDP:\n%s\n", sdp);
1354 * The following code is the main loop of the file converter
1356 static int av_encode(AVFormatContext **output_files,
1357 int nb_output_files,
1358 AVFormatContext **input_files,
1360 AVStreamMap *stream_maps, int nb_stream_maps)
1362 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1363 AVFormatContext *is, *os;
1364 AVCodecContext *codec, *icodec;
1365 AVOutputStream *ost, **ost_table = NULL;
1366 AVInputStream *ist, **ist_table = NULL;
1367 AVInputFile *file_table;
1371 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1375 /* input stream init */
1377 for(i=0;i<nb_input_files;i++) {
1378 is = input_files[i];
1379 file_table[i].ist_index = j;
1380 file_table[i].nb_streams = is->nb_streams;
1381 j += is->nb_streams;
1385 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1389 for(i=0;i<nb_istreams;i++) {
1390 ist = av_mallocz(sizeof(AVInputStream));
1396 for(i=0;i<nb_input_files;i++) {
1397 is = input_files[i];
1398 for(k=0;k<is->nb_streams;k++) {
1399 ist = ist_table[j++];
1400 ist->st = is->streams[k];
1401 ist->file_index = i;
1403 ist->discard = 1; /* the stream is discarded by default
1406 if (ist->st->codec->rate_emu) {
1407 ist->start = av_gettime();
1413 /* output stream init */
1415 for(i=0;i<nb_output_files;i++) {
1416 os = output_files[i];
1417 if (!os->nb_streams) {
1418 fprintf(stderr, "Output file does not contain any stream\n");
1421 nb_ostreams += os->nb_streams;
1423 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1424 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1428 /* Sanity check the mapping args -- do the input files & streams exist? */
1429 for(i=0;i<nb_stream_maps;i++) {
1430 int fi = stream_maps[i].file_index;
1431 int si = stream_maps[i].stream_index;
1433 if (fi < 0 || fi > nb_input_files - 1 ||
1434 si < 0 || si > file_table[fi].nb_streams - 1) {
1435 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1438 fi = stream_maps[i].sync_file_index;
1439 si = stream_maps[i].sync_stream_index;
1440 if (fi < 0 || fi > nb_input_files - 1 ||
1441 si < 0 || si > file_table[fi].nb_streams - 1) {
1442 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1447 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1450 for(i=0;i<nb_ostreams;i++) {
1451 ost = av_mallocz(sizeof(AVOutputStream));
1458 for(k=0;k<nb_output_files;k++) {
1459 os = output_files[k];
1460 for(i=0;i<os->nb_streams;i++) {
1462 ost = ost_table[n++];
1463 ost->file_index = k;
1465 ost->st = os->streams[i];
1466 if (nb_stream_maps > 0) {
1467 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1468 stream_maps[n-1].stream_index;
1470 /* Sanity check that the stream types match */
1471 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1472 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1473 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1474 ost->file_index, ost->index);
1479 /* get corresponding input stream index : we select the first one with the right type */
1481 for(j=0;j<nb_istreams;j++) {
1484 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1485 ost->source_index = j;
1492 /* try again and reuse existing stream */
1493 for(j=0;j<nb_istreams;j++) {
1495 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1496 ost->source_index = j;
1501 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1502 ost->file_index, ost->index);
1507 ist = ist_table[ost->source_index];
1509 ost->sync_ist = (nb_stream_maps > 0) ?
1510 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1511 stream_maps[n-1].sync_stream_index] : ist;
1515 /* for each output stream, we compute the right encoding parameters */
1516 for(i=0;i<nb_ostreams;i++) {
1518 os = output_files[ost->file_index];
1519 ist = ist_table[ost->source_index];
1521 codec = ost->st->codec;
1522 icodec = ist->st->codec;
1524 if (!ost->st->language[0])
1525 av_strlcpy(ost->st->language, ist->st->language,
1526 sizeof(ost->st->language));
1528 if (ost->st->stream_copy) {
1529 /* if stream_copy is selected, no need to decode or encode */
1530 codec->codec_id = icodec->codec_id;
1531 codec->codec_type = icodec->codec_type;
1533 if(!codec->codec_tag){
1534 if( !os->oformat->codec_tag
1535 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1536 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1537 codec->codec_tag = icodec->codec_tag;
1540 codec->bit_rate = icodec->bit_rate;
1541 codec->extradata= icodec->extradata;
1542 codec->extradata_size= icodec->extradata_size;
1543 if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1544 codec->time_base = icodec->time_base;
1546 codec->time_base = ist->st->time_base;
1547 switch(codec->codec_type) {
1548 case CODEC_TYPE_AUDIO:
1549 codec->sample_rate = icodec->sample_rate;
1550 codec->channels = icodec->channels;
1551 codec->frame_size = icodec->frame_size;
1552 codec->block_align= icodec->block_align;
1553 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1554 codec->block_align= 0;
1556 case CODEC_TYPE_VIDEO:
1558 fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1561 codec->pix_fmt = icodec->pix_fmt;
1562 codec->width = icodec->width;
1563 codec->height = icodec->height;
1564 codec->has_b_frames = icodec->has_b_frames;
1566 case CODEC_TYPE_SUBTITLE:
1572 switch(codec->codec_type) {
1573 case CODEC_TYPE_AUDIO:
1574 if (av_fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1577 if (codec->channels == icodec->channels &&
1578 codec->sample_rate == icodec->sample_rate) {
1579 ost->audio_resample = 0;
1581 if (codec->channels != icodec->channels &&
1582 (icodec->codec_id == CODEC_ID_AC3 ||
1583 icodec->codec_id == CODEC_ID_DTS)) {
1584 /* Special case for 5:1 AC3 and DTS input */
1585 /* and mono or stereo output */
1586 /* Request specific number of channels */
1587 icodec->channels = codec->channels;
1588 if (codec->sample_rate == icodec->sample_rate)
1589 ost->audio_resample = 0;
1591 ost->audio_resample = 1;
1594 ost->audio_resample = 1;
1597 if(audio_sync_method>1)
1598 ost->audio_resample = 1;
1600 if(ost->audio_resample){
1601 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1602 codec->sample_rate, icodec->sample_rate);
1604 printf("Can't resample. Aborting.\n");
1608 ist->decoding_needed = 1;
1609 ost->encoding_needed = 1;
1611 case CODEC_TYPE_VIDEO:
1612 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1613 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1614 ost->video_resample = ((codec->width != icodec->width -
1615 (frame_leftBand + frame_rightBand) +
1616 (frame_padleft + frame_padright)) ||
1617 (codec->height != icodec->height -
1618 (frame_topBand + frame_bottomBand) +
1619 (frame_padtop + frame_padbottom)) ||
1620 (codec->pix_fmt != icodec->pix_fmt));
1621 if (ost->video_crop) {
1622 ost->topBand = frame_topBand;
1623 ost->leftBand = frame_leftBand;
1625 if (ost->video_pad) {
1626 ost->padtop = frame_padtop;
1627 ost->padleft = frame_padleft;
1628 ost->padbottom = frame_padbottom;
1629 ost->padright = frame_padright;
1630 if (!ost->video_resample) {
1631 avcodec_get_frame_defaults(&ost->pict_tmp);
1632 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1633 codec->width, codec->height ) )
1637 if (ost->video_resample) {
1638 avcodec_get_frame_defaults(&ost->pict_tmp);
1639 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1640 codec->width, codec->height ) ) {
1641 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1644 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1645 ost->img_resample_ctx = sws_getContext(
1646 icodec->width - (frame_leftBand + frame_rightBand),
1647 icodec->height - (frame_topBand + frame_bottomBand),
1649 codec->width - (frame_padleft + frame_padright),
1650 codec->height - (frame_padtop + frame_padbottom),
1652 sws_flags, NULL, NULL, NULL);
1653 if (ost->img_resample_ctx == NULL) {
1654 fprintf(stderr, "Cannot get resampling context\n");
1657 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1659 ost->encoding_needed = 1;
1660 ist->decoding_needed = 1;
1662 case CODEC_TYPE_SUBTITLE:
1663 ost->encoding_needed = 1;
1664 ist->decoding_needed = 1;
1671 if (ost->encoding_needed &&
1672 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1673 char logfilename[1024];
1678 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1680 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1681 if (codec->flags & CODEC_FLAG_PASS1) {
1682 f = fopen(logfilename, "w");
1684 perror(logfilename);
1689 /* read the log file */
1690 f = fopen(logfilename, "r");
1692 perror(logfilename);
1695 fseek(f, 0, SEEK_END);
1697 fseek(f, 0, SEEK_SET);
1698 logbuffer = av_malloc(size + 1);
1700 fprintf(stderr, "Could not allocate log buffer\n");
1703 size = fread(logbuffer, 1, size, f);
1705 logbuffer[size] = '\0';
1706 codec->stats_in = logbuffer;
1710 if(codec->codec_type == CODEC_TYPE_VIDEO){
1711 int size= codec->width * codec->height;
1712 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1717 bit_buffer = av_malloc(bit_buffer_size);
1721 /* dump the file output parameters - cannot be done before in case
1723 for(i=0;i<nb_output_files;i++) {
1724 dump_format(output_files[i], i, output_files[i]->filename, 1);
1727 /* dump the stream mapping */
1729 fprintf(stderr, "Stream mapping:\n");
1730 for(i=0;i<nb_ostreams;i++) {
1732 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1733 ist_table[ost->source_index]->file_index,
1734 ist_table[ost->source_index]->index,
1737 if (ost->sync_ist != ist_table[ost->source_index])
1738 fprintf(stderr, " [sync #%d.%d]",
1739 ost->sync_ist->file_index,
1740 ost->sync_ist->index);
1741 fprintf(stderr, "\n");
1745 /* open each encoder */
1746 for(i=0;i<nb_ostreams;i++) {
1748 if (ost->encoding_needed) {
1750 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1752 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1753 ost->file_index, ost->index);
1756 if (avcodec_open(ost->st->codec, codec) < 0) {
1757 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1758 ost->file_index, ost->index);
1761 extra_size += ost->st->codec->extradata_size;
1765 /* open each decoder */
1766 for(i=0;i<nb_istreams;i++) {
1768 if (ist->decoding_needed) {
1770 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1772 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1773 ist->st->codec->codec_id, ist->file_index, ist->index);
1776 if (avcodec_open(ist->st->codec, codec) < 0) {
1777 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1778 ist->file_index, ist->index);
1781 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1782 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1787 for(i=0;i<nb_istreams;i++) {
1789 is = input_files[ist->file_index];
1792 if( input_files_ts_offset[ist->file_index] != -is->start_time
1793 && !(is->start_time == AV_NOPTS_VALUE && input_files_ts_offset[ist->file_index]==0))
1794 ist->next_pts= AV_NOPTS_VALUE;
1798 /* set meta data information from input file if required */
1799 for (i=0;i<nb_meta_data_maps;i++) {
1800 AVFormatContext *out_file;
1801 AVFormatContext *in_file;
1803 int out_file_index = meta_data_maps[i].out_file;
1804 int in_file_index = meta_data_maps[i].in_file;
1805 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1806 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1807 ret = AVERROR(EINVAL);
1810 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1811 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1812 ret = AVERROR(EINVAL);
1816 out_file = output_files[out_file_index];
1817 in_file = input_files[in_file_index];
1819 strcpy(out_file->title, in_file->title);
1820 strcpy(out_file->author, in_file->author);
1821 strcpy(out_file->copyright, in_file->copyright);
1822 strcpy(out_file->comment, in_file->comment);
1823 strcpy(out_file->album, in_file->album);
1824 out_file->year = in_file->year;
1825 out_file->track = in_file->track;
1826 strcpy(out_file->genre, in_file->genre);
1829 /* open files and write file headers */
1830 for(i=0;i<nb_output_files;i++) {
1831 os = output_files[i];
1832 if (av_write_header(os) < 0) {
1833 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1834 ret = AVERROR(EINVAL);
1837 if (strcmp(output_files[i]->oformat->name, "rtp")) {
1842 print_sdp(output_files, nb_output_files);
1845 if ( !using_stdin && verbose >= 0) {
1846 fprintf(stderr, "Press [q] to stop encoding\n");
1847 url_set_interrupt_cb(decode_interrupt_cb);
1852 timer_start = av_gettime();
1854 for(; received_sigterm == 0;) {
1855 int file_index, ist_index;
1863 /* if 'q' pressed, exits */
1867 /* read_key() returns 0 on EOF */
1873 /* select the stream that we must read now by looking at the
1874 smallest output pts */
1876 for(i=0;i<nb_ostreams;i++) {
1879 os = output_files[ost->file_index];
1880 ist = ist_table[ost->source_index];
1881 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1882 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1884 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1885 ipts = (double)ist->pts;
1886 if (!file_table[ist->file_index].eof_reached){
1887 if(ipts < ipts_min) {
1889 if(input_sync ) file_index = ist->file_index;
1891 if(opts < opts_min) {
1893 if(!input_sync) file_index = ist->file_index;
1896 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1901 /* if none, if is finished */
1902 if (file_index < 0) {
1906 /* finish if recording time exhausted */
1907 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1910 /* finish if limit size exhausted */
1911 if (limit_filesize != 0 && limit_filesize < url_ftell(&output_files[0]->pb))
1914 /* read a frame from it and output it in the fifo */
1915 is = input_files[file_index];
1916 if (av_read_frame(is, &pkt) < 0) {
1917 file_table[file_index].eof_reached = 1;
1925 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
1927 /* the following test is needed in case new streams appear
1928 dynamically in stream : we ignore them */
1929 if (pkt.stream_index >= file_table[file_index].nb_streams)
1930 goto discard_packet;
1931 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1932 ist = ist_table[ist_index];
1934 goto discard_packet;
1936 if (pkt.dts != AV_NOPTS_VALUE)
1937 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
1938 if (pkt.pts != AV_NOPTS_VALUE)
1939 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
1941 // 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);
1942 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1943 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
1944 int64_t delta= pkt_dts - ist->next_pts;
1945 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
1946 input_files_ts_offset[ist->file_index]-= delta;
1948 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1949 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
1950 if(pkt.pts != AV_NOPTS_VALUE)
1951 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
1955 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1956 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1959 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1960 ist->file_index, ist->index);
1962 av_free_packet(&pkt);
1967 av_free_packet(&pkt);
1969 /* dump report by using the output first video and audio streams */
1970 print_report(output_files, ost_table, nb_ostreams, 0);
1973 /* at the end of stream, we must flush the decoder buffers */
1974 for(i=0;i<nb_istreams;i++) {
1976 if (ist->decoding_needed) {
1977 output_packet(ist, i, ost_table, nb_ostreams, NULL);
1983 /* write the trailer if needed and close file */
1984 for(i=0;i<nb_output_files;i++) {
1985 os = output_files[i];
1986 av_write_trailer(os);
1989 /* dump report by using the first video and audio streams */
1990 print_report(output_files, ost_table, nb_ostreams, 1);
1992 /* close each encoder */
1993 for(i=0;i<nb_ostreams;i++) {
1995 if (ost->encoding_needed) {
1996 av_freep(&ost->st->codec->stats_in);
1997 avcodec_close(ost->st->codec);
2001 /* close each decoder */
2002 for(i=0;i<nb_istreams;i++) {
2004 if (ist->decoding_needed) {
2005 avcodec_close(ist->st->codec);
2013 av_freep(&bit_buffer);
2014 av_free(file_table);
2017 for(i=0;i<nb_istreams;i++) {
2024 for(i=0;i<nb_ostreams;i++) {
2028 fclose(ost->logfile);
2029 ost->logfile = NULL;
2031 av_fifo_free(&ost->fifo); /* works even if fifo is not
2032 initialized but set to zero */
2033 av_free(ost->pict_tmp.data[0]);
2034 if (ost->video_resample)
2035 sws_freeContext(ost->img_resample_ctx);
2036 if (ost->audio_resample)
2037 audio_resample_close(ost->resample);
2045 ret = AVERROR(ENOMEM);
2050 int file_read(const char *filename)
2053 unsigned char buffer[1024];
2056 if (url_open(&h, filename, O_RDONLY) < 0) {
2057 printf("could not open '%s'\n", filename);
2061 len = url_read(h, buffer, sizeof(buffer));
2064 for(i=0;i<len;i++) putchar(buffer[i]);
2071 static void opt_format(const char *arg)
2073 /* compatibility stuff for pgmyuv */
2074 if (!strcmp(arg, "pgmyuv")) {
2075 pgmyuv_compatibility_hack=1;
2076 // opt_image_format(arg);
2078 fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2081 file_iformat = av_find_input_format(arg);
2082 file_oformat = guess_format(arg, NULL, NULL);
2083 if (!file_iformat && !file_oformat) {
2084 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2089 static void opt_video_rc_eq(char *arg)
2094 static void opt_video_rc_override_string(char *arg)
2096 video_rc_override_string = arg;
2099 static void opt_me_threshold(const char *arg)
2101 me_threshold = atoi(arg);
2104 static void opt_verbose(const char *arg)
2106 verbose = atoi(arg);
2107 av_log_level = atoi(arg);
2110 static void opt_frame_rate(const char *arg)
2112 if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2113 fprintf(stderr, "Incorrect frame rate\n");
2118 static void opt_frame_crop_top(const char *arg)
2120 frame_topBand = atoi(arg);
2121 if (frame_topBand < 0) {
2122 fprintf(stderr, "Incorrect top crop size\n");
2125 if ((frame_topBand % 2) != 0) {
2126 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2129 if ((frame_topBand) >= frame_height){
2130 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2133 frame_height -= frame_topBand;
2136 static void opt_frame_crop_bottom(const char *arg)
2138 frame_bottomBand = atoi(arg);
2139 if (frame_bottomBand < 0) {
2140 fprintf(stderr, "Incorrect bottom crop size\n");
2143 if ((frame_bottomBand % 2) != 0) {
2144 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2147 if ((frame_bottomBand) >= frame_height){
2148 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2151 frame_height -= frame_bottomBand;
2154 static void opt_frame_crop_left(const char *arg)
2156 frame_leftBand = atoi(arg);
2157 if (frame_leftBand < 0) {
2158 fprintf(stderr, "Incorrect left crop size\n");
2161 if ((frame_leftBand % 2) != 0) {
2162 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2165 if ((frame_leftBand) >= frame_width){
2166 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2169 frame_width -= frame_leftBand;
2172 static void opt_frame_crop_right(const char *arg)
2174 frame_rightBand = atoi(arg);
2175 if (frame_rightBand < 0) {
2176 fprintf(stderr, "Incorrect right crop size\n");
2179 if ((frame_rightBand % 2) != 0) {
2180 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2183 if ((frame_rightBand) >= frame_width){
2184 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2187 frame_width -= frame_rightBand;
2190 static void opt_frame_size(const char *arg)
2192 if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2193 fprintf(stderr, "Incorrect frame size\n");
2196 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2197 fprintf(stderr, "Frame size must be a multiple of 2\n");
2203 #define SCALEBITS 10
2204 #define ONE_HALF (1 << (SCALEBITS - 1))
2205 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2207 #define RGB_TO_Y(r, g, b) \
2208 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2209 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2211 #define RGB_TO_U(r1, g1, b1, shift)\
2212 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2213 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2215 #define RGB_TO_V(r1, g1, b1, shift)\
2216 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2217 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2219 static void opt_pad_color(const char *arg) {
2220 /* Input is expected to be six hex digits similar to
2221 how colors are expressed in html tags (but without the #) */
2222 int rgb = strtol(arg, NULL, 16);
2226 g = ((rgb >> 8) & 255);
2229 padcolor[0] = RGB_TO_Y(r,g,b);
2230 padcolor[1] = RGB_TO_U(r,g,b,0);
2231 padcolor[2] = RGB_TO_V(r,g,b,0);
2234 static void opt_frame_pad_top(const char *arg)
2236 frame_padtop = atoi(arg);
2237 if (frame_padtop < 0) {
2238 fprintf(stderr, "Incorrect top pad size\n");
2241 if ((frame_padtop % 2) != 0) {
2242 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2247 static void opt_frame_pad_bottom(const char *arg)
2249 frame_padbottom = atoi(arg);
2250 if (frame_padbottom < 0) {
2251 fprintf(stderr, "Incorrect bottom pad size\n");
2254 if ((frame_padbottom % 2) != 0) {
2255 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2261 static void opt_frame_pad_left(const char *arg)
2263 frame_padleft = atoi(arg);
2264 if (frame_padleft < 0) {
2265 fprintf(stderr, "Incorrect left pad size\n");
2268 if ((frame_padleft % 2) != 0) {
2269 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2275 static void opt_frame_pad_right(const char *arg)
2277 frame_padright = atoi(arg);
2278 if (frame_padright < 0) {
2279 fprintf(stderr, "Incorrect right pad size\n");
2282 if ((frame_padright % 2) != 0) {
2283 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2288 void list_pix_fmts(void)
2291 char pix_fmt_str[128];
2292 for (i=-1; i < PIX_FMT_NB; i++) {
2293 avcodec_pix_fmt_string (pix_fmt_str, sizeof(pix_fmt_str), i);
2294 fprintf(stdout, "%s\n", pix_fmt_str);
2298 static void opt_frame_pix_fmt(const char *arg)
2300 if (strcmp(arg, "list"))
2301 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2308 static void opt_frame_aspect_ratio(const char *arg)
2314 p = strchr(arg, ':');
2316 x = strtol(arg, (char **)&arg, 10);
2318 y = strtol(arg+1, (char **)&arg, 10);
2320 ar = (double)x / (double)y;
2322 ar = strtod(arg, (char **)&arg);
2325 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2328 frame_aspect_ratio = ar;
2331 static void opt_qscale(const char *arg)
2333 video_qscale = atof(arg);
2334 if (video_qscale <= 0 ||
2335 video_qscale > 255) {
2336 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2341 static void opt_qdiff(const char *arg)
2343 video_qdiff = atoi(arg);
2344 if (video_qdiff < 0 ||
2346 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2351 static void opt_strict(const char *arg)
2356 static void opt_top_field_first(const char *arg)
2358 top_field_first= atoi(arg);
2361 static void opt_thread_count(const char *arg)
2363 thread_count= atoi(arg);
2364 #if !defined(HAVE_THREADS)
2366 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2370 static void opt_audio_rate(const char *arg)
2372 audio_sample_rate = atoi(arg);
2375 static void opt_audio_channels(const char *arg)
2377 audio_channels = atoi(arg);
2380 static void opt_video_channel(const char *arg)
2382 video_channel = strtol(arg, NULL, 0);
2385 static void opt_video_standard(const char *arg)
2387 video_standard = av_strdup(arg);
2390 static void opt_codec(int *pstream_copy, char **pcodec_name,
2391 int codec_type, const char *arg)
2393 av_freep(pcodec_name);
2394 if (!strcmp(arg, "copy")) {
2397 *pcodec_name = av_strdup(arg);
2401 static void opt_audio_codec(const char *arg)
2403 opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2406 static void opt_audio_tag(const char *arg)
2409 audio_codec_tag= strtol(arg, &tail, 0);
2412 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2415 static void opt_video_tag(const char *arg)
2418 video_codec_tag= strtol(arg, &tail, 0);
2421 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2425 static void add_frame_hooker(const char *arg)
2430 char *args = av_strdup(arg);
2434 argv[0] = strtok(args, " ");
2435 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2438 i = frame_hook_add(argc, argv);
2441 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2447 static void opt_video_codec(const char *arg)
2449 opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2452 static void opt_subtitle_codec(const char *arg)
2454 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2457 static void opt_map(const char *arg)
2463 m = &stream_maps[nb_stream_maps++];
2465 m->file_index = strtol(arg, (char **)&p, 0);
2469 m->stream_index = strtol(p, (char **)&p, 0);
2472 m->sync_file_index = strtol(p, (char **)&p, 0);
2475 m->sync_stream_index = strtol(p, (char **)&p, 0);
2477 m->sync_file_index = m->file_index;
2478 m->sync_stream_index = m->stream_index;
2482 static void opt_map_meta_data(const char *arg)
2488 m = &meta_data_maps[nb_meta_data_maps++];
2490 m->out_file = strtol(arg, (char **)&p, 0);
2494 m->in_file = strtol(p, (char **)&p, 0);
2497 static int64_t parse_time_or_die(const char *timestr, int is_duration)
2499 int64_t us = parse_date(timestr, is_duration);
2500 if (us == INT64_MIN) {
2501 fprintf(stderr, "Invalid %s specification: %s\n",
2502 is_duration ? "duration" : "date", timestr);
2508 static void opt_recording_time(const char *arg)
2510 recording_time = parse_time_or_die(arg, 1);
2513 static void opt_start_time(const char *arg)
2515 start_time = parse_time_or_die(arg, 1);
2518 static void opt_rec_timestamp(const char *arg)
2520 rec_timestamp = parse_time_or_die(arg, 0) / 1000000;
2523 static void opt_input_ts_offset(const char *arg)
2525 input_ts_offset = parse_time_or_die(arg, 1);
2528 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2530 char *codec_string = encoder ? "encoder" : "decoder";
2534 return CODEC_ID_NONE;
2536 avcodec_find_encoder_by_name(name) :
2537 avcodec_find_decoder_by_name(name);
2539 av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2542 if(codec->type != type) {
2543 av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2549 static void opt_input_file(const char *filename)
2551 AVFormatContext *ic;
2552 AVFormatParameters params, *ap = ¶ms;
2553 int err, i, ret, rfps, rfps_base;
2556 if (!strcmp(filename, "-"))
2559 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2560 !strcmp( filename, "/dev/stdin" );
2562 /* get default parameters from command line */
2563 ic = av_alloc_format_context();
2565 memset(ap, 0, sizeof(*ap));
2566 ap->prealloced_context = 1;
2567 ap->sample_rate = audio_sample_rate;
2568 ap->channels = audio_channels;
2569 ap->time_base.den = frame_rate.num;
2570 ap->time_base.num = frame_rate.den;
2571 ap->width = frame_width + frame_padleft + frame_padright;
2572 ap->height = frame_height + frame_padtop + frame_padbottom;
2573 ap->pix_fmt = frame_pix_fmt;
2574 ap->channel = video_channel;
2575 ap->standard = video_standard;
2576 ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2577 ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2578 if(pgmyuv_compatibility_hack)
2579 ap->video_codec_id= CODEC_ID_PGMYUV;
2581 for(i=0; i<opt_name_count; i++){
2582 const AVOption *opt;
2583 double d= av_get_double(avformat_opts, opt_names[i], &opt);
2584 if(!isnan(d) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2585 av_set_double(ic, opt_names[i], d);
2587 /* open the input file with generic libav function */
2588 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2590 print_error(filename, err);
2594 ic->loop_input = loop_input;
2596 /* If not enough info to get the stream parameters, we decode the
2597 first frames to get it. (used in mpeg case for example) */
2598 ret = av_find_stream_info(ic);
2599 if (ret < 0 && verbose >= 0) {
2600 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2604 timestamp = start_time;
2605 /* add the stream start time */
2606 if (ic->start_time != AV_NOPTS_VALUE)
2607 timestamp += ic->start_time;
2609 /* if seeking requested, we execute it */
2610 if (start_time != 0) {
2611 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2613 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2614 filename, (double)timestamp / AV_TIME_BASE);
2616 /* reset seek info */
2620 /* update the current parameters so that they match the one of the input stream */
2621 for(i=0;i<ic->nb_streams;i++) {
2623 AVCodecContext *enc = ic->streams[i]->codec;
2625 avcodec_thread_init(enc, thread_count);
2626 enc->thread_count= thread_count;
2627 switch(enc->codec_type) {
2628 case CODEC_TYPE_AUDIO:
2629 for(j=0; j<opt_name_count; j++){
2630 const AVOption *opt;
2631 double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[j], &opt);
2632 if(!isnan(d) && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2633 av_set_double(enc, opt_names[j], d);
2635 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2636 audio_channels = enc->channels;
2637 audio_sample_rate = enc->sample_rate;
2639 ic->streams[i]->discard= AVDISCARD_ALL;
2641 case CODEC_TYPE_VIDEO:
2642 for(j=0; j<opt_name_count; j++){
2643 const AVOption *opt;
2644 double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[j], &opt);
2645 if(!isnan(d) && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2646 av_set_double(enc, opt_names[j], d);
2648 frame_height = enc->height;
2649 frame_width = enc->width;
2650 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2651 frame_pix_fmt = enc->pix_fmt;
2652 rfps = ic->streams[i]->r_frame_rate.num;
2653 rfps_base = ic->streams[i]->r_frame_rate.den;
2654 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2656 enc->debug |= FF_DEBUG_MV;
2658 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2661 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2662 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2664 (float)rfps / rfps_base, rfps, rfps_base);
2666 /* update the current frame rate to match the stream frame rate */
2667 frame_rate.num = rfps;
2668 frame_rate.den = rfps_base;
2670 enc->rate_emu = rate_emu;
2672 ic->streams[i]->discard= AVDISCARD_ALL;
2673 else if(video_discard)
2674 ic->streams[i]->discard= video_discard;
2676 case CODEC_TYPE_DATA:
2678 case CODEC_TYPE_SUBTITLE:
2679 if(subtitle_disable)
2680 ic->streams[i]->discard = AVDISCARD_ALL;
2682 case CODEC_TYPE_UNKNOWN:
2689 input_files[nb_input_files] = ic;
2690 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2691 /* dump the file content */
2693 dump_format(ic, nb_input_files, filename, 0);
2696 file_iformat = NULL;
2697 file_oformat = NULL;
2704 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2705 int *has_subtitle_ptr)
2707 int has_video, has_audio, has_subtitle, i, j;
2708 AVFormatContext *ic;
2713 for(j=0;j<nb_input_files;j++) {
2714 ic = input_files[j];
2715 for(i=0;i<ic->nb_streams;i++) {
2716 AVCodecContext *enc = ic->streams[i]->codec;
2717 switch(enc->codec_type) {
2718 case CODEC_TYPE_AUDIO:
2721 case CODEC_TYPE_VIDEO:
2724 case CODEC_TYPE_SUBTITLE:
2727 case CODEC_TYPE_DATA:
2728 case CODEC_TYPE_UNKNOWN:
2735 *has_video_ptr = has_video;
2736 *has_audio_ptr = has_audio;
2737 *has_subtitle_ptr = has_subtitle;
2740 static void new_video_stream(AVFormatContext *oc)
2743 AVCodecContext *video_enc;
2746 st = av_new_stream(oc, oc->nb_streams);
2748 fprintf(stderr, "Could not alloc stream\n");
2751 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2752 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2753 video_bitstream_filters= NULL;
2756 avcodec_thread_init(st->codec, thread_count);
2758 video_enc = st->codec;
2761 video_enc->codec_tag= video_codec_tag;
2763 if( (video_global_header&1)
2764 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2765 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2766 avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2768 if(video_global_header&2){
2769 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2770 avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2773 if (video_stream_copy) {
2774 st->stream_copy = 1;
2775 video_enc->codec_type = CODEC_TYPE_VIDEO;
2781 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2782 if (video_codec_name)
2783 codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
2785 video_enc->codec_id = codec_id;
2786 codec = avcodec_find_encoder(codec_id);
2788 for(i=0; i<opt_name_count; i++){
2789 const AVOption *opt;
2790 double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt);
2791 if(!isnan(d) && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2792 av_set_double(video_enc, opt_names[i], d);
2795 video_enc->time_base.den = frame_rate.num;
2796 video_enc->time_base.num = frame_rate.den;
2797 if(codec && codec->supported_framerates){
2798 const AVRational *p= codec->supported_framerates;
2799 AVRational req= (AVRational){frame_rate.num, frame_rate.den};
2800 const AVRational *best=NULL;
2801 AVRational best_error= (AVRational){INT_MAX, 1};
2802 for(; p->den!=0; p++){
2803 AVRational error= av_sub_q(req, *p);
2804 if(error.num <0) error.num *= -1;
2805 if(av_cmp_q(error, best_error) < 0){
2810 video_enc->time_base.den= best->num;
2811 video_enc->time_base.num= best->den;
2814 video_enc->width = frame_width + frame_padright + frame_padleft;
2815 video_enc->height = frame_height + frame_padtop + frame_padbottom;
2816 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2817 video_enc->pix_fmt = frame_pix_fmt;
2819 if(codec && codec->pix_fmts){
2820 const enum PixelFormat *p= codec->pix_fmts;
2822 if(*p == video_enc->pix_fmt)
2826 video_enc->pix_fmt = codec->pix_fmts[0];
2830 video_enc->gop_size = 0;
2831 if (video_qscale || same_quality) {
2832 video_enc->flags |= CODEC_FLAG_QSCALE;
2833 video_enc->global_quality=
2834 st->quality = FF_QP2LAMBDA * video_qscale;
2838 video_enc->intra_matrix = intra_matrix;
2840 video_enc->inter_matrix = inter_matrix;
2842 video_enc->max_qdiff = video_qdiff;
2843 video_enc->rc_eq = video_rc_eq;
2844 video_enc->thread_count = thread_count;
2845 p= video_rc_override_string;
2848 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2850 fprintf(stderr, "error parsing rc_override\n");
2853 video_enc->rc_override=
2854 av_realloc(video_enc->rc_override,
2855 sizeof(RcOverride)*(i+1));
2856 video_enc->rc_override[i].start_frame= start;
2857 video_enc->rc_override[i].end_frame = end;
2859 video_enc->rc_override[i].qscale= q;
2860 video_enc->rc_override[i].quality_factor= 1.0;
2863 video_enc->rc_override[i].qscale= 0;
2864 video_enc->rc_override[i].quality_factor= -q/100.0;
2869 video_enc->rc_override_count=i;
2870 if (!video_enc->rc_initial_buffer_occupancy)
2871 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2872 video_enc->me_threshold= me_threshold;
2873 video_enc->intra_dc_precision= intra_dc_precision - 8;
2874 video_enc->strict_std_compliance = strict;
2877 video_enc->flags|= CODEC_FLAG_PSNR;
2882 video_enc->flags |= CODEC_FLAG_PASS1;
2884 video_enc->flags |= CODEC_FLAG_PASS2;
2889 /* reset some key parameters */
2891 av_freep(&video_codec_name);
2892 video_stream_copy = 0;
2895 static void new_audio_stream(AVFormatContext *oc)
2898 AVCodecContext *audio_enc;
2901 st = av_new_stream(oc, oc->nb_streams);
2903 fprintf(stderr, "Could not alloc stream\n");
2906 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
2908 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2909 audio_bitstream_filters= NULL;
2912 avcodec_thread_init(st->codec, thread_count);
2914 audio_enc = st->codec;
2915 audio_enc->codec_type = CODEC_TYPE_AUDIO;
2916 audio_enc->strict_std_compliance = strict;
2919 audio_enc->codec_tag= audio_codec_tag;
2921 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
2922 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2923 avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2925 if (audio_stream_copy) {
2926 st->stream_copy = 1;
2927 audio_enc->channels = audio_channels;
2929 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
2931 for(i=0; i<opt_name_count; i++){
2932 const AVOption *opt;
2933 double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt);
2934 if(!isnan(d) && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2935 av_set_double(audio_enc, opt_names[i], d);
2938 if (audio_codec_name)
2939 codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
2940 audio_enc->codec_id = codec_id;
2942 if (audio_qscale > QSCALE_NONE) {
2943 audio_enc->flags |= CODEC_FLAG_QSCALE;
2944 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
2946 audio_enc->thread_count = thread_count;
2947 audio_enc->channels = audio_channels;
2949 audio_enc->sample_rate = audio_sample_rate;
2950 audio_enc->time_base= (AVRational){1, audio_sample_rate};
2951 if (audio_language) {
2952 av_strlcpy(st->language, audio_language, sizeof(st->language));
2953 av_free(audio_language);
2954 audio_language = NULL;
2957 /* reset some key parameters */
2959 av_freep(&audio_codec_name);
2960 audio_stream_copy = 0;
2963 static void new_subtitle_stream(AVFormatContext *oc)
2966 AVCodecContext *subtitle_enc;
2969 st = av_new_stream(oc, oc->nb_streams);
2971 fprintf(stderr, "Could not alloc stream\n");
2974 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
2976 subtitle_enc = st->codec;
2977 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
2978 if (subtitle_stream_copy) {
2979 st->stream_copy = 1;
2981 for(i=0; i<opt_name_count; i++){
2982 const AVOption *opt;
2983 double d= av_get_double(avctx_opts[CODEC_TYPE_SUBTITLE], opt_names[i], &opt);
2984 if(!isnan(d) && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2985 av_set_double(subtitle_enc, opt_names[i], d);
2987 subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
2990 if (subtitle_language) {
2991 av_strlcpy(st->language, subtitle_language, sizeof(st->language));
2992 av_free(subtitle_language);
2993 subtitle_language = NULL;
2996 subtitle_disable = 0;
2997 av_freep(&subtitle_codec_name);
2998 subtitle_stream_copy = 0;
3001 static void opt_new_audio_stream(void)
3003 AVFormatContext *oc;
3004 if (nb_output_files <= 0) {
3005 fprintf(stderr, "At least one output file must be specified\n");
3008 oc = output_files[nb_output_files - 1];
3009 new_audio_stream(oc);
3012 static void opt_new_video_stream(void)
3014 AVFormatContext *oc;
3015 if (nb_output_files <= 0) {
3016 fprintf(stderr, "At least one output file must be specified\n");
3019 oc = output_files[nb_output_files - 1];
3020 new_video_stream(oc);
3023 static void opt_new_subtitle_stream(void)
3025 AVFormatContext *oc;
3026 if (nb_output_files <= 0) {
3027 fprintf(stderr, "At least one output file must be specified\n");
3030 oc = output_files[nb_output_files - 1];
3031 new_subtitle_stream(oc);
3034 static void opt_output_file(const char *filename)
3036 AVFormatContext *oc;
3037 int use_video, use_audio, use_subtitle;
3038 int input_has_video, input_has_audio, input_has_subtitle, i;
3039 AVFormatParameters params, *ap = ¶ms;
3041 if (!strcmp(filename, "-"))
3044 oc = av_alloc_format_context();
3046 if (!file_oformat) {
3047 file_oformat = guess_format(NULL, filename, NULL);
3048 if (!file_oformat) {
3049 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3055 oc->oformat = file_oformat;
3056 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3058 if (!strcmp(file_oformat->name, "ffm") &&
3059 av_strstart(filename, "http:", NULL)) {
3060 /* special case for files sent to ffserver: we get the stream
3061 parameters from ffserver */
3062 if (read_ffserver_streams(oc, filename) < 0) {
3063 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3067 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3068 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3069 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3071 /* disable if no corresponding type found and at least one
3073 if (nb_input_files > 0) {
3074 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3075 &input_has_subtitle);
3076 if (!input_has_video)
3078 if (!input_has_audio)
3080 if (!input_has_subtitle)
3084 /* manual disable */
3085 if (audio_disable) {
3088 if (video_disable) {
3091 if (subtitle_disable) {
3096 new_video_stream(oc);
3100 new_audio_stream(oc);
3104 new_subtitle_stream(oc);
3107 oc->timestamp = rec_timestamp;
3110 av_strlcpy(oc->title, str_title, sizeof(oc->title));
3112 av_strlcpy(oc->author, str_author, sizeof(oc->author));
3114 av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3116 av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3118 av_strlcpy(oc->album, str_album, sizeof(oc->album));
3121 output_files[nb_output_files++] = oc;
3123 /* check filename in case of an image number is expected */
3124 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3125 if (!av_filename_number_test(oc->filename)) {
3126 print_error(oc->filename, AVERROR_NUMEXPECTED);
3131 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3132 /* test if it already exists to avoid loosing precious files */
3133 if (!file_overwrite &&
3134 (strchr(filename, ':') == NULL ||
3135 av_strstart(filename, "file:", NULL))) {
3136 if (url_exist(filename)) {
3139 if ( !using_stdin ) {
3140 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3143 if (toupper(c) != 'Y') {
3144 fprintf(stderr, "Not overwriting - exiting\n");
3149 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3156 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3157 fprintf(stderr, "Could not open '%s'\n", filename);
3162 memset(ap, 0, sizeof(*ap));
3163 if (av_set_parameters(oc, ap) < 0) {
3164 fprintf(stderr, "%s: Invalid encoding parameters\n",
3169 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3170 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3171 oc->loop_output = loop_output;
3173 for(i=0; i<opt_name_count; i++){
3174 const AVOption *opt;
3175 double d = av_get_double(avformat_opts, opt_names[i], &opt);
3176 if(!isnan(d) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3177 av_set_double(oc, opt_names[i], d);
3180 /* reset some options */
3181 file_oformat = NULL;
3182 file_iformat = NULL;
3185 /* same option as mencoder */
3186 static void opt_pass(const char *pass_str)
3189 pass = atoi(pass_str);
3190 if (pass != 1 && pass != 2) {
3191 fprintf(stderr, "pass number can be only 1 or 2\n");
3197 static int64_t getutime(void)
3199 #ifdef HAVE_GETRUSAGE
3200 struct rusage rusage;
3202 getrusage(RUSAGE_SELF, &rusage);
3203 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3204 #elif defined(HAVE_GETPROCESSTIMES)
3206 FILETIME c, e, k, u;
3207 proc = GetCurrentProcess();
3208 GetProcessTimes(proc, &c, &e, &k, &u);
3209 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3211 return av_gettime();
3215 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3216 extern int ffm_nopts;
3219 static void opt_show_formats(void)
3221 AVInputFormat *ifmt;
3222 AVOutputFormat *ofmt;
3225 const char *last_name;
3227 printf("File formats:\n");
3232 const char *name=NULL;
3233 const char *long_name=NULL;
3235 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3236 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3237 strcmp(ofmt->name, last_name)>0){
3239 long_name= ofmt->long_name;
3243 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3244 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3245 strcmp(ifmt->name, last_name)>0){
3247 long_name= ifmt->long_name;
3250 if(name && strcmp(ifmt->name, name)==0)
3262 long_name ? long_name:" ");
3266 printf("Codecs:\n");
3272 const char *type_str;
3275 for(p = first_avcodec; p != NULL; p = p->next) {
3276 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3277 strcmp(p->name, last_name)>0){
3279 decode= encode= cap=0;
3281 if(p2 && strcmp(p->name, p2->name)==0){
3282 if(p->decode) decode=1;
3283 if(p->encode) encode=1;
3284 cap |= p->capabilities;
3289 last_name= p2->name;
3292 case CODEC_TYPE_VIDEO:
3295 case CODEC_TYPE_AUDIO:
3298 case CODEC_TYPE_SUBTITLE:
3307 decode ? "D": (/*p2->decoder ? "d":*/" "),
3310 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3311 cap & CODEC_CAP_DR1 ? "D":" ",
3312 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3314 /* if(p2->decoder && decode==0)
3315 printf(" use %s for decoding", p2->decoder->name);*/
3320 printf("Supported file protocols:\n");
3321 for(up = first_protocol; up != NULL; up = up->next)
3322 printf(" %s:", up->name);
3325 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3328 "Note, the names of encoders and decoders do not always match, so there are\n"
3329 "several cases where the above table shows encoder only or decoder only entries\n"
3330 "even though both encoding and decoding are supported. For example, the h263\n"
3331 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
3336 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3339 const char *p = str;
3346 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3353 static void opt_inter_matrix(const char *arg)
3355 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3356 parse_matrix_coeffs(inter_matrix, arg);
3359 static void opt_intra_matrix(const char *arg)
3361 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3362 parse_matrix_coeffs(intra_matrix, arg);
3365 static void opt_show_help(void)
3371 static void opt_target(const char *arg)
3374 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3376 if(!strncmp(arg, "pal-", 4)) {
3379 } else if(!strncmp(arg, "ntsc-", 5)) {
3382 } else if(!strncmp(arg, "film-", 5)) {
3387 /* Calculate FR via float to avoid int overflow */
3388 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3391 } else if((fr == 29970) || (fr == 23976)) {
3394 /* Try to determine PAL/NTSC by peeking in the input files */
3395 if(nb_input_files) {
3397 for(j = 0; j < nb_input_files; j++) {
3398 for(i = 0; i < input_files[j]->nb_streams; i++) {
3399 AVCodecContext *c = input_files[j]->streams[i]->codec;
3400 if(c->codec_type != CODEC_TYPE_VIDEO)
3402 fr = c->time_base.den * 1000 / c->time_base.num;
3406 } else if((fr == 29970) || (fr == 23976)) {
3416 if(verbose && norm >= 0)
3417 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3421 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3422 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3423 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3427 if(!strcmp(arg, "vcd")) {
3429 opt_video_codec("mpeg1video");
3430 opt_audio_codec("mp2");
3433 opt_frame_size(norm ? "352x240" : "352x288");
3434 opt_frame_rate(frame_rates[norm]);
3435 opt_default("gop", norm ? "18" : "15");
3437 opt_default("b", "1150000");
3438 opt_default("maxrate", "1150000");
3439 opt_default("minrate", "1150000");
3440 opt_default("bufsize", "327680"); // 40*1024*8;
3442 opt_default("ab", "224000");
3443 audio_sample_rate = 44100;
3446 opt_default("packetsize", "2324");
3447 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3449 /* We have to offset the PTS, so that it is consistent with the SCR.
3450 SCR starts at 36000, but the first two packs contain only padding
3451 and the first pack from the other stream, respectively, may also have
3452 been written before.
3453 So the real data starts at SCR 36000+3*1200. */
3454 mux_preload= (36000+3*1200) / 90000.0; //0.44
3455 } else if(!strcmp(arg, "svcd")) {
3457 opt_video_codec("mpeg2video");
3458 opt_audio_codec("mp2");
3461 opt_frame_size(norm ? "480x480" : "480x576");
3462 opt_frame_rate(frame_rates[norm]);
3463 opt_default("gop", norm ? "18" : "15");
3465 opt_default("b", "2040000");
3466 opt_default("maxrate", "2516000");
3467 opt_default("minrate", "0"); //1145000;
3468 opt_default("bufsize", "1835008"); //224*1024*8;
3469 opt_default("flags", "+SCAN_OFFSET");
3472 opt_default("ab", "224000");
3473 audio_sample_rate = 44100;
3475 opt_default("packetsize", "2324");
3477 } else if(!strcmp(arg, "dvd")) {
3479 opt_video_codec("mpeg2video");
3480 opt_audio_codec("ac3");
3483 opt_frame_size(norm ? "720x480" : "720x576");
3484 opt_frame_rate(frame_rates[norm]);
3485 opt_default("gop", norm ? "18" : "15");
3487 opt_default("b", "6000000");
3488 opt_default("maxrate", "9000000");
3489 opt_default("minrate", "0"); //1500000;
3490 opt_default("bufsize", "1835008"); //224*1024*8;
3492 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3493 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3495 opt_default("ab", "448000");
3496 audio_sample_rate = 48000;
3498 } else if(!strncmp(arg, "dv", 2)) {
3502 opt_frame_size(norm ? "720x480" : "720x576");
3503 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3504 (norm ? "yuv411p" : "yuv420p"));
3505 opt_frame_rate(frame_rates[norm]);
3507 audio_sample_rate = 48000;
3511 fprintf(stderr, "Unknown target: %s\n", arg);
3516 static void opt_vstats_file (const char *arg)
3518 av_free (vstats_filename);
3519 vstats_filename=av_strdup (arg);
3522 static void opt_vstats (void)
3525 time_t today2 = time(NULL);
3526 struct tm *today = localtime(&today2);
3528 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3530 opt_vstats_file(filename);
3533 static void opt_video_bsf(const char *arg)
3535 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3536 AVBitStreamFilterContext **bsfp;
3539 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3543 bsfp= &video_bitstream_filters;
3545 bsfp= &(*bsfp)->next;
3550 //FIXME avoid audio - video code duplication
3551 static void opt_audio_bsf(const char *arg)
3553 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3554 AVBitStreamFilterContext **bsfp;
3557 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3561 bsfp= &audio_bitstream_filters;
3563 bsfp= &(*bsfp)->next;
3568 static void opt_show_version(void)
3570 show_version(program_name);
3574 static int opt_default(const char *opt, const char *arg){
3576 const AVOption *o= NULL;
3577 int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
3579 for(type=0; type<CODEC_TYPE_NB; type++){
3580 const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
3582 o = av_set_string(avctx_opts[type], opt, arg);
3585 o = av_set_string(avformat_opts, opt, arg);
3587 o = av_set_string(sws_opts, opt, arg);
3590 o = av_set_string(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg);
3591 else if(opt[0] == 'v')
3592 o = av_set_string(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg);
3593 else if(opt[0] == 's')
3594 o = av_set_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg);
3599 // 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));
3601 //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
3602 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
3603 opt_names[opt_name_count++]= o->name;
3605 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3606 /* disable generate of real time pts in ffm (need to be supressed anyway) */
3607 if(avctx_opts[0]->flags & CODEC_FLAG_BITEXACT)
3611 if(avctx_opts[0]->debug)
3612 av_log_level = AV_LOG_DEBUG;
3616 const OptionDef options[] = {
3618 { "L", 0, {(void*)opt_show_license}, "show license" },
3619 { "h", 0, {(void*)opt_show_help}, "show help" },
3620 { "version", 0, {(void*)opt_show_version}, "show version" },
3621 { "formats", 0, {(void*)opt_show_formats}, "show available formats, codecs, protocols, ..." },
3622 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3623 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3624 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3625 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3626 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3627 { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3628 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3629 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3630 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3631 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3632 { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3633 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3634 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3635 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3636 { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3637 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3638 "add timings for benchmarking" },
3639 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3640 "dump each input packet" },
3641 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3642 "when dumping packets, also dump the payload" },
3643 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3644 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3645 { "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)", "" },
3646 { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3647 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3648 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3649 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3650 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3651 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "" },
3652 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3653 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3654 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3655 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
3658 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3659 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3660 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3661 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3662 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3663 { "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" },
3664 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3665 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3666 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3667 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3668 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3669 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3670 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3671 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3672 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3673 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3674 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3675 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3676 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3677 { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantizer scale (VBR)", "q" },
3678 { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3679 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3680 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3681 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "" },
3682 { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3683 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3684 "use same video quality as source (implies VBR)" },
3685 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3686 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3687 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3688 "deinterlace pictures" },
3689 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3690 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3691 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3693 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3695 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3696 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3697 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3698 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3699 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3700 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3701 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3704 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3705 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3706 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3707 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3708 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3709 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3710 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3711 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3712 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3713 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3715 /* subtitle options */
3716 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3717 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3718 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3719 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3722 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3723 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3724 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3727 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3728 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3730 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
3731 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
3733 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3737 static void opt_show_license(void)
3744 * Trivial log callback.
3745 * Only suitable for show_help and similar since it lacks prefix handling.
3747 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3749 vfprintf(stdout, fmt, vl);
3752 static void show_help(void)
3754 av_log_set_callback(log_callback_help);
3755 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3756 "Hyper fast Audio and Video encoder\n");
3758 show_help_options(options, "Main options:\n",
3759 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3760 show_help_options(options, "\nVideo options:\n",
3761 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3763 show_help_options(options, "\nAdvanced Video options:\n",
3764 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3765 OPT_VIDEO | OPT_EXPERT);
3766 show_help_options(options, "\nAudio options:\n",
3767 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3769 show_help_options(options, "\nAdvanced Audio options:\n",
3770 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3771 OPT_AUDIO | OPT_EXPERT);
3772 show_help_options(options, "\nSubtitle options:\n",
3773 OPT_SUBTITLE | OPT_GRAB,
3775 show_help_options(options, "\nAudio/Video grab options:\n",
3778 show_help_options(options, "\nAdvanced options:\n",
3779 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3781 av_opt_show(avctx_opts[0], NULL);
3782 av_opt_show(avformat_opts, NULL);
3783 av_opt_show(sws_opts, NULL);
3786 static int av_exit()
3791 for(i=0;i<nb_output_files;i++) {
3792 /* maybe av_close_output_file ??? */
3793 AVFormatContext *s = output_files[i];
3795 if (!(s->oformat->flags & AVFMT_NOFILE))
3797 for(j=0;j<s->nb_streams;j++) {
3798 av_free(s->streams[j]->codec);
3799 av_free(s->streams[j]);
3803 for(i=0;i<nb_input_files;i++)
3804 av_close_input_file(input_files[i]);
3808 av_free(intra_matrix);
3809 av_free(inter_matrix);
3812 fclose(vstats_file);
3813 av_free(vstats_filename);
3817 av_free(video_codec_name);
3818 av_free(audio_codec_name);
3819 av_free(subtitle_codec_name);
3821 av_free(video_standard);
3823 #ifdef CONFIG_POWERPC_PERF
3824 extern void powerpc_display_perf_report(void);
3825 powerpc_display_perf_report();
3826 #endif /* CONFIG_POWERPC_PERF */
3828 if (received_sigterm) {
3830 "Received signal %d: terminating.\n",
3831 (int) received_sigterm);
3835 exit(0); /* not all OS-es handle main() return value */
3839 int main(int argc, char **argv)
3846 for(i=0; i<CODEC_TYPE_NB; i++){
3847 avctx_opts[i]= avcodec_alloc_context2(i);
3849 avformat_opts = av_alloc_format_context();
3850 sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3852 show_banner(program_name, program_birth_year);
3859 parse_options(argc, argv, options, opt_output_file);
3861 /* file converter / grab */
3862 if (nb_output_files <= 0) {
3863 fprintf(stderr, "Must supply at least one output file\n");
3867 if (nb_input_files == 0) {
3868 fprintf(stderr, "Must supply at least one input file\n");
3873 av_encode(output_files, nb_output_files, input_files, nb_input_files,
3874 stream_maps, nb_stream_maps);
3875 ti = getutime() - ti;
3877 printf("bench: utime=%0.3fs\n", ti / 1000000.0);