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
21 #define HAVE_AV_CONFIG_H
26 #include "framehook.h"
36 #include <sys/ioctl.h>
39 #include <sys/resource.h>
42 #include <sys/types.h>
43 #include <sys/select.h>
46 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
55 #if !defined(INFINITY) && defined(HUGE_VAL)
56 #define INFINITY HUGE_VAL
59 /* select an input stream for an output stream */
60 typedef struct AVStreamMap {
64 int sync_stream_index;
67 /** select an input file for an output file */
68 typedef struct AVMetaDataMap {
73 extern const OptionDef options[];
75 static void show_help(void);
76 static void show_license(void);
77 static int opt_default(const char *opt, const char *arg);
81 static AVFormatContext *input_files[MAX_FILES];
82 static int64_t input_files_ts_offset[MAX_FILES];
83 static int nb_input_files = 0;
85 static AVFormatContext *output_files[MAX_FILES];
86 static int nb_output_files = 0;
88 static AVStreamMap stream_maps[MAX_FILES];
89 static int nb_stream_maps;
91 static AVMetaDataMap meta_data_maps[MAX_FILES];
92 static int nb_meta_data_maps;
94 static AVInputFormat *file_iformat;
95 static AVOutputFormat *file_oformat;
96 static int frame_width = 0;
97 static int frame_height = 0;
98 static float frame_aspect_ratio = 0;
99 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
100 static int frame_padtop = 0;
101 static int frame_padbottom = 0;
102 static int frame_padleft = 0;
103 static int frame_padright = 0;
104 static int padcolor[3] = {16,128,128}; /* default to black */
105 static int frame_topBand = 0;
106 static int frame_bottomBand = 0;
107 static int frame_leftBand = 0;
108 static int frame_rightBand = 0;
109 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
110 static int frame_rate = 25;
111 static int frame_rate_base = 1;
112 static float video_qscale = 0;
113 static int video_qdiff = 3;
114 static uint16_t *intra_matrix = NULL;
115 static uint16_t *inter_matrix = NULL;
116 #if 0 //experimental, (can be removed)
117 static float video_rc_qsquish=1.0;
118 static float video_rc_qmod_amp=0;
119 static int video_rc_qmod_freq=0;
121 static char *video_rc_override_string=NULL;
122 static char *video_rc_eq="tex^qComp";
123 static int me_method = ME_EPZS;
124 static int video_disable = 0;
125 static int video_discard = 0;
126 static int video_codec_id = CODEC_ID_NONE;
127 static int video_codec_tag = 0;
128 static int same_quality = 0;
129 static int do_deinterlace = 0;
130 static int packet_size = 0;
131 static int strict = 0;
132 static int top_field_first = -1;
133 static int me_threshold = 0;
134 static int intra_dc_precision = 8;
135 static int loop_input = 0;
136 static int loop_output = AVFMT_NOOUTPUTLOOP;
137 static int qp_hist = 0;
139 static int intra_only = 0;
140 static int audio_sample_rate = 44100;
141 static int audio_bit_rate = 64000;
142 #define QSCALE_NONE -99999
143 static float audio_qscale = QSCALE_NONE;
144 static int audio_disable = 0;
145 static int audio_channels = 1;
146 static int audio_codec_id = CODEC_ID_NONE;
147 static int audio_codec_tag = 0;
148 static char *audio_language = NULL;
150 static int subtitle_codec_id = CODEC_ID_NONE;
151 static char *subtitle_language = NULL;
153 static float mux_preload= 0.5;
154 static float mux_max_delay= 0.7;
156 static int64_t recording_time = 0;
157 static int64_t start_time = 0;
158 static int64_t rec_timestamp = 0;
159 static int64_t input_ts_offset = 0;
160 static int file_overwrite = 0;
161 static char *str_title = NULL;
162 static char *str_author = NULL;
163 static char *str_copyright = NULL;
164 static char *str_comment = NULL;
165 static char *str_album = NULL;
166 static int do_benchmark = 0;
167 static int do_hex_dump = 0;
168 static int do_pkt_dump = 0;
169 static int do_psnr = 0;
170 static int do_vstats = 0;
171 static int do_pass = 0;
172 static char *pass_logfilename = NULL;
173 static int audio_stream_copy = 0;
174 static int video_stream_copy = 0;
175 static int subtitle_stream_copy = 0;
176 static int video_sync_method= 1;
177 static int audio_sync_method= 0;
178 static int copy_ts= 0;
179 static int opt_shortest = 0; //
180 static int video_global_header = 0;
182 static int rate_emu = 0;
184 static int video_channel = 0;
185 static char *video_standard = "ntsc";
187 static int audio_volume = 256;
189 static int using_stdin = 0;
190 static int using_vhook = 0;
191 static int verbose = 1;
192 static int thread_count= 1;
193 static int q_pressed = 0;
194 static int64_t video_size = 0;
195 static int64_t audio_size = 0;
196 static int64_t extra_size = 0;
197 static int nb_frames_dup = 0;
198 static int nb_frames_drop = 0;
199 static int input_sync;
200 static int limit_filesize = 0; //
202 static int pgmyuv_compatibility_hack=0;
203 static int dts_delta_threshold = 10;
205 static int sws_flags = SWS_BICUBIC;
207 const char **opt_names=NULL;
208 int opt_name_count=0;
209 AVCodecContext *avctx_opts;
210 AVFormatContext *avformat_opts;
212 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
213 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
214 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
216 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
218 struct AVInputStream;
220 typedef struct AVOutputStream {
221 int file_index; /* file index */
222 int index; /* stream index in the output file */
223 int source_index; /* AVInputStream index */
224 AVStream *st; /* stream in the output file */
225 int encoding_needed; /* true if encoding needed for this stream */
227 /* input pts and corresponding output pts
229 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
230 struct AVInputStream *sync_ist; /* input stream to sync against */
231 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
234 AVFrame pict_tmp; /* temporary image for resampling */
235 struct SwsContext *img_resample_ctx; /* for image resampling */
239 int topBand; /* cropping area sizes */
243 int padtop; /* padding area sizes */
250 ReSampleContext *resample; /* for audio resampling */
251 AVFifoBuffer fifo; /* for compression: one audio fifo per codec */
255 typedef struct AVInputStream {
259 int discard; /* true if stream data should be discarded */
260 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
261 int64_t sample_index; /* current sample */
263 int64_t start; /* time when read started */
264 unsigned long frame; /* current frame */
265 int64_t next_pts; /* synthetic pts for cases where pkt.pts
267 int64_t pts; /* current pts */
268 int is_start; /* is 1 at the start and after a discontinuity */
271 typedef struct AVInputFile {
272 int eof_reached; /* true if eof reached */
273 int ist_index; /* index of first stream in ist_table */
274 int buffer_size; /* current total buffer size */
275 int buffer_size_max; /* buffer size at which we consider we can stop
277 int nb_streams; /* nb streams we are aware of */
282 /* init terminal so that we can grab keys */
283 static struct termios oldtty;
286 static void term_exit(void)
289 tcsetattr (0, TCSANOW, &oldtty);
293 static volatile sig_atomic_t received_sigterm = 0;
296 sigterm_handler(int sig)
298 received_sigterm = sig;
302 static void term_init(void)
310 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
311 |INLCR|IGNCR|ICRNL|IXON);
312 tty.c_oflag |= OPOST;
313 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
314 tty.c_cflag &= ~(CSIZE|PARENB);
319 tcsetattr (0, TCSANOW, &tty);
320 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
323 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
324 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
326 register a function to be called at normal program termination
329 #ifdef CONFIG_BEOS_NETSERVER
330 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
334 /* read a key without blocking */
335 static int read_key(void)
343 #ifndef CONFIG_BEOS_NETSERVER
351 n = select(1, &rfds, NULL, NULL, &tv);
364 static int decode_interrupt_cb(void)
366 return q_pressed || (q_pressed = read_key() == 'q');
369 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
374 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
377 /* copy stream format */
378 s->nb_streams = ic->nb_streams;
379 for(i=0;i<ic->nb_streams;i++) {
382 // FIXME: a more elegant solution is needed
383 st = av_mallocz(sizeof(AVStream));
384 memcpy(st, ic->streams[i], sizeof(AVStream));
385 st->codec = avcodec_alloc_context();
386 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
390 av_close_input_file(ic);
395 get_sync_ipts(const AVOutputStream *ost)
397 const AVInputStream *ist = ost->sync_ist;
398 return (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/AV_TIME_BASE;
401 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
403 AVPacket new_pkt= *pkt;
404 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
405 &new_pkt.data, &new_pkt.size,
406 pkt->data, pkt->size,
407 pkt->flags & PKT_FLAG_KEY);
410 new_pkt.destruct= av_destruct_packet;
417 av_interleaved_write_frame(s, pkt);
420 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
422 static void do_audio_out(AVFormatContext *s,
425 unsigned char *buf, int size)
428 static uint8_t *audio_buf = NULL;
429 static uint8_t *audio_out = NULL;
430 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
432 int size_out, frame_bytes, ret;
433 AVCodecContext *enc= ost->st->codec;
435 /* SC: dynamic allocation of buffers */
437 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
439 audio_out = av_malloc(audio_out_size);
440 if (!audio_buf || !audio_out)
441 return; /* Should signal an error ! */
443 if(audio_sync_method){
444 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
445 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
446 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
447 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
449 //FIXME resample delay
450 if(fabs(delta) > 50){
453 byte_delta= FFMAX(byte_delta, -size);
457 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
462 static uint8_t *input_tmp= NULL;
463 input_tmp= av_realloc(input_tmp, byte_delta + size);
465 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
468 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
470 memset(input_tmp, 0, byte_delta);
471 memcpy(input_tmp + byte_delta, buf, size);
475 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
477 }else if(audio_sync_method>1){
478 int comp= clip(delta, -audio_sync_method, audio_sync_method);
479 assert(ost->audio_resample);
481 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
482 // 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));
483 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
487 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
488 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
490 if (ost->audio_resample) {
492 size_out = audio_resample(ost->resample,
493 (short *)buftmp, (short *)buf,
494 size / (ist->st->codec->channels * 2));
495 size_out = size_out * enc->channels * 2;
501 /* now encode as many frames as possible */
502 if (enc->frame_size > 1) {
503 /* output resampled raw samples */
504 av_fifo_write(&ost->fifo, buftmp, size_out);
506 frame_bytes = enc->frame_size * 2 * enc->channels;
508 while (av_fifo_read(&ost->fifo, audio_buf, frame_bytes) == 0) {
510 av_init_packet(&pkt);
512 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
515 pkt.stream_index= ost->index;
518 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
519 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
520 pkt.flags |= PKT_FLAG_KEY;
521 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
523 ost->sync_opts += enc->frame_size;
527 av_init_packet(&pkt);
529 ost->sync_opts += size_out / (2 * enc->channels);
531 /* output a pcm frame */
532 /* XXX: change encoding codec API to avoid this ? */
533 switch(enc->codec->id) {
534 case CODEC_ID_PCM_S32LE:
535 case CODEC_ID_PCM_S32BE:
536 case CODEC_ID_PCM_U32LE:
537 case CODEC_ID_PCM_U32BE:
538 size_out = size_out << 1;
540 case CODEC_ID_PCM_S24LE:
541 case CODEC_ID_PCM_S24BE:
542 case CODEC_ID_PCM_U24LE:
543 case CODEC_ID_PCM_U24BE:
544 case CODEC_ID_PCM_S24DAUD:
545 size_out = size_out / 2 * 3;
547 case CODEC_ID_PCM_S16LE:
548 case CODEC_ID_PCM_S16BE:
549 case CODEC_ID_PCM_U16LE:
550 case CODEC_ID_PCM_U16BE:
553 size_out = size_out >> 1;
556 ret = avcodec_encode_audio(enc, audio_out, size_out,
559 pkt.stream_index= ost->index;
562 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
563 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
564 pkt.flags |= PKT_FLAG_KEY;
565 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
569 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
573 AVPicture picture_tmp;
576 dec = ist->st->codec;
578 /* deinterlace : must be done before any resize */
579 if (do_deinterlace || using_vhook) {
582 /* create temporary picture */
583 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
584 buf = av_malloc(size);
588 picture2 = &picture_tmp;
589 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
592 if(avpicture_deinterlace(picture2, picture,
593 dec->pix_fmt, dec->width, dec->height) < 0) {
594 /* if error, do not deinterlace */
600 img_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
606 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
608 if (picture != picture2)
609 *picture = *picture2;
613 /* we begin to correct av delay at this threshold */
614 #define AV_DELAY_MAX 0.100
616 static void do_subtitle_out(AVFormatContext *s,
622 static uint8_t *subtitle_out = NULL;
623 int subtitle_out_max_size = 65536;
624 int subtitle_out_size, nb, i;
628 if (pts == AV_NOPTS_VALUE) {
629 fprintf(stderr, "Subtitle packets must have a pts\n");
633 enc = ost->st->codec;
636 subtitle_out = av_malloc(subtitle_out_max_size);
639 /* Note: DVB subtitle need one packet to draw them and one other
640 packet to clear them */
641 /* XXX: signal it in the codec context ? */
642 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
647 for(i = 0; i < nb; i++) {
648 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
649 subtitle_out_max_size, sub);
651 av_init_packet(&pkt);
652 pkt.stream_index = ost->index;
653 pkt.data = subtitle_out;
654 pkt.size = subtitle_out_size;
655 pkt.pts = av_rescale_q(av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q) + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
656 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
657 /* XXX: the pts correction is handled here. Maybe handling
658 it in the codec would be better */
660 pkt.pts += 90 * sub->start_display_time;
662 pkt.pts += 90 * sub->end_display_time;
664 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
668 static int bit_buffer_size= 1024*256;
669 static uint8_t *bit_buffer= NULL;
671 static void do_video_out(AVFormatContext *s,
677 int nb_frames, i, ret;
678 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
679 AVFrame picture_crop_temp, picture_pad_temp;
680 uint8_t *buf = NULL, *buf1 = NULL;
681 AVCodecContext *enc, *dec;
683 avcodec_get_frame_defaults(&picture_crop_temp);
684 avcodec_get_frame_defaults(&picture_pad_temp);
686 enc = ost->st->codec;
687 dec = ist->st->codec;
689 /* by default, we output a single frame */
694 if(video_sync_method){
696 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
697 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
700 else if (vdelta > 1.1)
701 nb_frames = lrintf(vdelta);
702 //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);
706 fprintf(stderr, "*** drop!\n");
707 }else if (nb_frames > 1) {
708 nb_frames_dup += nb_frames;
710 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
713 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
715 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
719 if (ost->video_crop) {
720 if (img_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
721 av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
724 formatted_picture = &picture_crop_temp;
726 formatted_picture = in_picture;
729 final_picture = formatted_picture;
730 padding_src = formatted_picture;
731 resampling_dst = &ost->pict_tmp;
732 if (ost->video_pad) {
733 final_picture = &ost->pict_tmp;
734 if (ost->video_resample) {
735 if (img_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
736 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
739 resampling_dst = &picture_pad_temp;
743 if (ost->video_resample) {
745 final_picture = &ost->pict_tmp;
746 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
747 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
750 if (ost->video_pad) {
751 img_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
752 enc->height, enc->width, enc->pix_fmt,
753 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
756 /* duplicates frame if needed */
757 for(i=0;i<nb_frames;i++) {
759 av_init_packet(&pkt);
760 pkt.stream_index= ost->index;
762 if (s->oformat->flags & AVFMT_RAWPICTURE) {
763 /* raw pictures are written as AVPicture structure to
764 avoid any copies. We support temorarily the older
766 AVFrame* old_frame = enc->coded_frame;
767 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
768 pkt.data= (uint8_t *)final_picture;
769 pkt.size= sizeof(AVPicture);
770 if(dec->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
771 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
772 if(dec->coded_frame && dec->coded_frame->key_frame)
773 pkt.flags |= PKT_FLAG_KEY;
775 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
776 enc->coded_frame = old_frame;
780 big_picture= *final_picture;
781 /* better than nothing: use input picture interlaced
783 big_picture.interlaced_frame = in_picture->interlaced_frame;
784 if(avctx_opts->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
785 if(top_field_first == -1)
786 big_picture.top_field_first = in_picture->top_field_first;
788 big_picture.top_field_first = top_field_first;
791 /* handles sameq here. This is not correct because it may
792 not be a global option */
794 big_picture.quality = ist->st->quality;
796 big_picture.quality = ost->st->quality;
798 big_picture.pict_type = 0;
799 // big_picture.pts = AV_NOPTS_VALUE;
800 big_picture.pts= ost->sync_opts;
801 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
802 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
803 ret = avcodec_encode_video(enc,
804 bit_buffer, bit_buffer_size,
807 fprintf(stderr, "Video encoding failed\n");
810 //enc->frame_number = enc->real_pict_num;
812 pkt.data= bit_buffer;
814 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
815 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
816 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
817 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
818 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
820 if(enc->coded_frame && enc->coded_frame->key_frame)
821 pkt.flags |= PKT_FLAG_KEY;
822 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
824 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
825 // enc->frame_number-1, enc->real_pict_num, ret,
827 /* if two pass, output log */
828 if (ost->logfile && enc->stats_out) {
829 fprintf(ost->logfile, "%s", enc->stats_out);
841 static double psnr(double d){
842 if(d==0) return INFINITY;
843 return -10.0*log(d)/log(10.0);
846 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
849 static FILE *fvstats=NULL;
856 double ti1, bitrate, avg_bitrate;
860 today = localtime(&today2);
861 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
864 fvstats = fopen(filename,"w");
872 enc = ost->st->codec;
873 if (enc->codec_type == CODEC_TYPE_VIDEO) {
874 frame_number = ost->frame_number;
875 fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
876 if (enc->flags&CODEC_FLAG_PSNR)
877 fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
879 fprintf(fvstats,"f_size= %6d ", frame_size);
880 /* compute pts value */
881 ti1 = ost->sync_opts * av_q2d(enc->time_base);
885 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
886 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
887 fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
888 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
889 fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
893 static void print_report(AVFormatContext **output_files,
894 AVOutputStream **ost_table, int nb_ostreams,
899 AVFormatContext *oc, *os;
902 int frame_number, vid, i;
903 double bitrate, ti1, pts;
904 static int64_t last_time = -1;
905 static int qp_histogram[52];
907 if (!is_last_report) {
909 /* display the report every 0.5 seconds */
910 cur_time = av_gettime();
911 if (last_time == -1) {
912 last_time = cur_time;
915 if ((cur_time - last_time) < 500000)
917 last_time = cur_time;
921 oc = output_files[0];
923 total_size = url_ftell(&oc->pb);
928 for(i=0;i<nb_ostreams;i++) {
930 os = output_files[ost->file_index];
931 enc = ost->st->codec;
932 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
933 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
934 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
936 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
937 frame_number = ost->frame_number;
938 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d q=%3.1f ",
939 frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
941 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
942 if(qp_hist && enc->coded_frame){
944 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
945 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
948 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
950 if (enc->flags&CODEC_FLAG_PSNR){
952 double error, error_sum=0;
953 double scale, scale_sum=0;
954 char type[3]= {'Y','U','V'};
955 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
958 error= enc->error[j];
959 scale= enc->width*enc->height*255.0*255.0*frame_number;
961 error= enc->coded_frame->error[j];
962 scale= enc->width*enc->height*255.0*255.0;
967 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
969 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
973 /* compute min output value */
974 pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
975 if ((pts < ti1) && (pts > 0))
981 if (verbose || is_last_report) {
982 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
984 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
985 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
986 (double)total_size / 1024, ti1, bitrate);
989 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
990 nb_frames_dup, nb_frames_drop);
993 fprintf(stderr, "%s \r", buf);
998 if (is_last_report && verbose >= 0){
999 int64_t raw= audio_size + video_size + extra_size;
1000 fprintf(stderr, "\n");
1001 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1005 100.0*(total_size - raw)/raw
1010 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1011 static int output_packet(AVInputStream *ist, int ist_index,
1012 AVOutputStream **ost_table, int nb_ostreams,
1013 const AVPacket *pkt)
1015 AVFormatContext *os;
1016 AVOutputStream *ost;
1020 int data_size, got_picture;
1022 void *buffer_to_free;
1023 static unsigned int samples_size= 0;
1024 static short *samples= NULL;
1025 AVSubtitle subtitle, *subtitle_to_free;
1029 ist->pts= ist->next_pts; // needed for last packet if vsync=0
1030 } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1031 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1033 // assert(ist->pts == ist->next_pts);
1047 /* decode the packet if needed */
1048 data_buf = NULL; /* fail safe */
1050 subtitle_to_free = NULL;
1051 if (ist->decoding_needed) {
1052 switch(ist->st->codec->codec_type) {
1053 case CODEC_TYPE_AUDIO:{
1055 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
1056 data_size= samples_size;
1057 /* XXX: could avoid copy if PCM 16 bits with same
1058 endianness as CPU */
1059 ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1065 /* Some bug in mpeg audio decoder gives */
1066 /* data_size < 0, it seems they are overflows */
1067 if (data_size <= 0) {
1068 /* no audio frame */
1071 data_buf = (uint8_t *)samples;
1072 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1073 (ist->st->codec->sample_rate * ist->st->codec->channels);
1075 case CODEC_TYPE_VIDEO:
1076 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1077 /* XXX: allocate picture correctly */
1078 avcodec_get_frame_defaults(&picture);
1080 ret = avcodec_decode_video(ist->st->codec,
1081 &picture, &got_picture, ptr, len);
1082 ist->st->quality= picture.quality;
1086 /* no picture yet */
1087 goto discard_packet;
1089 if (ist->st->codec->time_base.num != 0) {
1090 ist->next_pts += ((int64_t)AV_TIME_BASE *
1091 ist->st->codec->time_base.num) /
1092 ist->st->codec->time_base.den;
1096 case CODEC_TYPE_SUBTITLE:
1097 ret = avcodec_decode_subtitle(ist->st->codec,
1098 &subtitle, &got_subtitle, ptr, len);
1101 if (!got_subtitle) {
1102 goto discard_packet;
1104 subtitle_to_free = &subtitle;
1111 switch(ist->st->codec->codec_type) {
1112 case CODEC_TYPE_AUDIO:
1113 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1114 (ist->st->codec->sample_rate * ist->st->codec->channels);
1116 case CODEC_TYPE_VIDEO:
1117 if (ist->st->codec->time_base.num != 0) {
1118 ist->next_pts += ((int64_t)AV_TIME_BASE *
1119 ist->st->codec->time_base.num) /
1120 ist->st->codec->time_base.den;
1130 buffer_to_free = NULL;
1131 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1132 pre_process_video_frame(ist, (AVPicture *)&picture,
1136 // preprocess audio (volume)
1137 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1138 if (audio_volume != 256) {
1141 for(i=0;i<(data_size / sizeof(short));i++) {
1142 int v = ((*volp) * audio_volume + 128) >> 8;
1143 if (v < -32768) v = -32768;
1144 if (v > 32767) v = 32767;
1150 /* frame rate emulation */
1151 if (ist->st->codec->rate_emu) {
1152 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1153 int64_t now = av_gettime() - ist->start;
1161 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1162 is the one of the next displayed one */
1163 /* XXX: add mpeg4 too ? */
1164 if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1165 if (ist->st->codec->pict_type != B_TYPE) {
1167 tmp = ist->last_ip_pts;
1168 ist->last_ip_pts = ist->frac_pts.val;
1169 ist->frac_pts.val = tmp;
1173 /* if output time reached then transcode raw format,
1174 encode packets and output them */
1175 if (start_time == 0 || ist->pts >= start_time)
1176 for(i=0;i<nb_ostreams;i++) {
1180 if (ost->source_index == ist_index) {
1181 os = output_files[ost->file_index];
1184 printf("%d: got pts=%0.3f %0.3f\n", i,
1185 (double)pkt->pts / AV_TIME_BASE,
1186 ((double)ist->pts / AV_TIME_BASE) -
1187 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1189 /* set the input output pts pairs */
1190 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1192 if (ost->encoding_needed) {
1193 switch(ost->st->codec->codec_type) {
1194 case CODEC_TYPE_AUDIO:
1195 do_audio_out(os, ost, ist, data_buf, data_size);
1197 case CODEC_TYPE_VIDEO:
1198 do_video_out(os, ost, ist, &picture, &frame_size);
1199 video_size += frame_size;
1200 if (do_vstats && frame_size)
1201 do_video_stats(os, ost, frame_size);
1203 case CODEC_TYPE_SUBTITLE:
1204 do_subtitle_out(os, ost, ist, &subtitle,
1211 AVFrame avframe; //FIXME/XXX remove this
1213 av_init_packet(&opkt);
1215 /* no reencoding needed : output the packet directly */
1216 /* force the input stream PTS */
1218 avcodec_get_frame_defaults(&avframe);
1219 ost->st->codec->coded_frame= &avframe;
1220 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1222 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1223 audio_size += data_size;
1224 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1225 video_size += data_size;
1229 opkt.stream_index= ost->index;
1230 if(pkt->pts != AV_NOPTS_VALUE)
1231 opkt.pts= av_rescale_q(av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q) + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
1233 opkt.pts= AV_NOPTS_VALUE;
1237 if (pkt->dts == AV_NOPTS_VALUE)
1238 dts = ist->next_pts;
1240 dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1241 opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
1243 opkt.flags= pkt->flags;
1245 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1246 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1247 opkt.destruct= av_destruct_packet;
1249 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
1250 ost->st->codec->frame_number++;
1251 ost->frame_number++;
1252 av_free_packet(&opkt);
1256 av_free(buffer_to_free);
1257 /* XXX: allocate the subtitles in the codec ? */
1258 if (subtitle_to_free) {
1259 if (subtitle_to_free->rects != NULL) {
1260 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1261 av_free(subtitle_to_free->rects[i].bitmap);
1262 av_free(subtitle_to_free->rects[i].rgba_palette);
1264 av_freep(&subtitle_to_free->rects);
1266 subtitle_to_free->num_rects = 0;
1267 subtitle_to_free = NULL;
1274 for(i=0;i<nb_ostreams;i++) {
1276 if (ost->source_index == ist_index) {
1277 AVCodecContext *enc= ost->st->codec;
1278 os = output_files[ost->file_index];
1280 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1282 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1285 if (ost->encoding_needed) {
1289 av_init_packet(&pkt);
1290 pkt.stream_index= ost->index;
1292 switch(ost->st->codec->codec_type) {
1293 case CODEC_TYPE_AUDIO:
1294 fifo_bytes = av_fifo_size(&ost->fifo);
1296 /* encode any samples remaining in fifo */
1297 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1298 int fs_tmp = enc->frame_size;
1299 enc->frame_size = fifo_bytes / (2 * enc->channels);
1300 if(av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes) == 0) {
1301 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1303 enc->frame_size = fs_tmp;
1306 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1309 pkt.flags |= PKT_FLAG_KEY;
1311 case CODEC_TYPE_VIDEO:
1312 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1314 if(enc->coded_frame && enc->coded_frame->key_frame)
1315 pkt.flags |= PKT_FLAG_KEY;
1316 if (ost->logfile && enc->stats_out) {
1317 fprintf(ost->logfile, "%s", enc->stats_out);
1326 pkt.data= bit_buffer;
1328 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1329 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1330 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1344 * The following code is the main loop of the file converter
1346 static int av_encode(AVFormatContext **output_files,
1347 int nb_output_files,
1348 AVFormatContext **input_files,
1350 AVStreamMap *stream_maps, int nb_stream_maps)
1352 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1353 AVFormatContext *is, *os;
1354 AVCodecContext *codec, *icodec;
1355 AVOutputStream *ost, **ost_table = NULL;
1356 AVInputStream *ist, **ist_table = NULL;
1357 AVInputFile *file_table;
1358 AVFormatContext *stream_no_data;
1361 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1365 /* input stream init */
1367 for(i=0;i<nb_input_files;i++) {
1368 is = input_files[i];
1369 file_table[i].ist_index = j;
1370 file_table[i].nb_streams = is->nb_streams;
1371 j += is->nb_streams;
1375 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1379 for(i=0;i<nb_istreams;i++) {
1380 ist = av_mallocz(sizeof(AVInputStream));
1386 for(i=0;i<nb_input_files;i++) {
1387 is = input_files[i];
1388 for(k=0;k<is->nb_streams;k++) {
1389 ist = ist_table[j++];
1390 ist->st = is->streams[k];
1391 ist->file_index = i;
1393 ist->discard = 1; /* the stream is discarded by default
1396 if (ist->st->codec->rate_emu) {
1397 ist->start = av_gettime();
1403 /* output stream init */
1405 for(i=0;i<nb_output_files;i++) {
1406 os = output_files[i];
1407 if (!os->nb_streams) {
1408 fprintf(stderr, "Output file does not contain any stream\n");
1411 nb_ostreams += os->nb_streams;
1413 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1414 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1418 /* Sanity check the mapping args -- do the input files & streams exist? */
1419 for(i=0;i<nb_stream_maps;i++) {
1420 int fi = stream_maps[i].file_index;
1421 int si = stream_maps[i].stream_index;
1423 if (fi < 0 || fi > nb_input_files - 1 ||
1424 si < 0 || si > file_table[fi].nb_streams - 1) {
1425 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1428 fi = stream_maps[i].sync_file_index;
1429 si = stream_maps[i].sync_stream_index;
1430 if (fi < 0 || fi > nb_input_files - 1 ||
1431 si < 0 || si > file_table[fi].nb_streams - 1) {
1432 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1437 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1440 for(i=0;i<nb_ostreams;i++) {
1441 ost = av_mallocz(sizeof(AVOutputStream));
1448 for(k=0;k<nb_output_files;k++) {
1449 os = output_files[k];
1450 for(i=0;i<os->nb_streams;i++) {
1452 ost = ost_table[n++];
1453 ost->file_index = k;
1455 ost->st = os->streams[i];
1456 if (nb_stream_maps > 0) {
1457 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1458 stream_maps[n-1].stream_index;
1460 /* Sanity check that the stream types match */
1461 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1462 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1463 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1464 ost->file_index, ost->index);
1469 /* get corresponding input stream index : we select the first one with the right type */
1471 for(j=0;j<nb_istreams;j++) {
1474 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1475 ost->source_index = j;
1482 /* try again and reuse existing stream */
1483 for(j=0;j<nb_istreams;j++) {
1485 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1486 ost->source_index = j;
1491 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1492 ost->file_index, ost->index);
1497 ist = ist_table[ost->source_index];
1499 ost->sync_ist = (nb_stream_maps > 0) ?
1500 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1501 stream_maps[n-1].sync_stream_index] : ist;
1505 /* for each output stream, we compute the right encoding parameters */
1506 for(i=0;i<nb_ostreams;i++) {
1508 ist = ist_table[ost->source_index];
1510 codec = ost->st->codec;
1511 icodec = ist->st->codec;
1513 if (ost->st->stream_copy) {
1514 /* if stream_copy is selected, no need to decode or encode */
1515 codec->codec_id = icodec->codec_id;
1516 codec->codec_type = icodec->codec_type;
1517 if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1518 codec->bit_rate = icodec->bit_rate;
1519 codec->extradata= icodec->extradata;
1520 codec->extradata_size= icodec->extradata_size;
1521 if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1522 codec->time_base = icodec->time_base;
1524 codec->time_base = ist->st->time_base;
1525 switch(codec->codec_type) {
1526 case CODEC_TYPE_AUDIO:
1527 codec->sample_rate = icodec->sample_rate;
1528 codec->channels = icodec->channels;
1529 codec->frame_size = icodec->frame_size;
1530 codec->block_align= icodec->block_align;
1532 case CODEC_TYPE_VIDEO:
1534 fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1537 codec->pix_fmt = icodec->pix_fmt;
1538 codec->width = icodec->width;
1539 codec->height = icodec->height;
1540 codec->has_b_frames = icodec->has_b_frames;
1542 case CODEC_TYPE_SUBTITLE:
1548 switch(codec->codec_type) {
1549 case CODEC_TYPE_AUDIO:
1550 if (av_fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1553 if (codec->channels == icodec->channels &&
1554 codec->sample_rate == icodec->sample_rate) {
1555 ost->audio_resample = 0;
1557 if (codec->channels != icodec->channels &&
1558 (icodec->codec_id == CODEC_ID_AC3 ||
1559 icodec->codec_id == CODEC_ID_DTS)) {
1560 /* Special case for 5:1 AC3 and DTS input */
1561 /* and mono or stereo output */
1562 /* Request specific number of channels */
1563 icodec->channels = codec->channels;
1564 if (codec->sample_rate == icodec->sample_rate)
1565 ost->audio_resample = 0;
1567 ost->audio_resample = 1;
1570 ost->audio_resample = 1;
1573 if(audio_sync_method>1)
1574 ost->audio_resample = 1;
1576 if(ost->audio_resample){
1577 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1578 codec->sample_rate, icodec->sample_rate);
1580 printf("Can't resample. Aborting.\n");
1584 ist->decoding_needed = 1;
1585 ost->encoding_needed = 1;
1587 case CODEC_TYPE_VIDEO:
1588 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1589 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1590 ost->video_resample = ((codec->width != icodec->width -
1591 (frame_leftBand + frame_rightBand) +
1592 (frame_padleft + frame_padright)) ||
1593 (codec->height != icodec->height -
1594 (frame_topBand + frame_bottomBand) +
1595 (frame_padtop + frame_padbottom)) ||
1596 (codec->pix_fmt != icodec->pix_fmt));
1597 if (ost->video_crop) {
1598 ost->topBand = frame_topBand;
1599 ost->leftBand = frame_leftBand;
1601 if (ost->video_pad) {
1602 ost->padtop = frame_padtop;
1603 ost->padleft = frame_padleft;
1604 ost->padbottom = frame_padbottom;
1605 ost->padright = frame_padright;
1606 if (!ost->video_resample) {
1607 avcodec_get_frame_defaults(&ost->pict_tmp);
1608 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1609 codec->width, codec->height ) )
1613 if (ost->video_resample) {
1614 avcodec_get_frame_defaults(&ost->pict_tmp);
1615 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1616 codec->width, codec->height ) )
1619 ost->img_resample_ctx = sws_getContext(
1620 icodec->width - (frame_leftBand + frame_rightBand),
1621 icodec->height - (frame_topBand + frame_bottomBand),
1623 codec->width - (frame_padleft + frame_padright),
1624 codec->height - (frame_padtop + frame_padbottom),
1626 sws_flags, NULL, NULL, NULL);
1627 if (ost->img_resample_ctx == NULL) {
1628 fprintf(stderr, "Cannot get resampling context\n");
1631 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1633 ost->encoding_needed = 1;
1634 ist->decoding_needed = 1;
1636 case CODEC_TYPE_SUBTITLE:
1637 ost->encoding_needed = 1;
1638 ist->decoding_needed = 1;
1645 if (ost->encoding_needed &&
1646 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1647 char logfilename[1024];
1652 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1654 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1655 if (codec->flags & CODEC_FLAG_PASS1) {
1656 f = fopen(logfilename, "w");
1658 perror(logfilename);
1663 /* read the log file */
1664 f = fopen(logfilename, "r");
1666 perror(logfilename);
1669 fseek(f, 0, SEEK_END);
1671 fseek(f, 0, SEEK_SET);
1672 logbuffer = av_malloc(size + 1);
1674 fprintf(stderr, "Could not allocate log buffer\n");
1677 size = fread(logbuffer, 1, size, f);
1679 logbuffer[size] = '\0';
1680 codec->stats_in = logbuffer;
1684 if(codec->codec_type == CODEC_TYPE_VIDEO){
1685 int size= codec->width * codec->height;
1686 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1691 bit_buffer = av_malloc(bit_buffer_size);
1695 /* dump the file output parameters - cannot be done before in case
1697 for(i=0;i<nb_output_files;i++) {
1698 dump_format(output_files[i], i, output_files[i]->filename, 1);
1701 /* dump the stream mapping */
1703 fprintf(stderr, "Stream mapping:\n");
1704 for(i=0;i<nb_ostreams;i++) {
1706 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1707 ist_table[ost->source_index]->file_index,
1708 ist_table[ost->source_index]->index,
1711 if (ost->sync_ist != ist_table[ost->source_index])
1712 fprintf(stderr, " [sync #%d.%d]",
1713 ost->sync_ist->file_index,
1714 ost->sync_ist->index);
1715 fprintf(stderr, "\n");
1719 /* open each encoder */
1720 for(i=0;i<nb_ostreams;i++) {
1722 if (ost->encoding_needed) {
1724 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1726 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1727 ost->file_index, ost->index);
1730 if (avcodec_open(ost->st->codec, codec) < 0) {
1731 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1732 ost->file_index, ost->index);
1735 extra_size += ost->st->codec->extradata_size;
1739 /* open each decoder */
1740 for(i=0;i<nb_istreams;i++) {
1742 if (ist->decoding_needed) {
1744 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1746 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1747 ist->st->codec->codec_id, ist->file_index, ist->index);
1750 if (avcodec_open(ist->st->codec, codec) < 0) {
1751 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1752 ist->file_index, ist->index);
1755 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1756 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1761 for(i=0;i<nb_istreams;i++) {
1763 is = input_files[ist->file_index];
1765 ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1766 if(ist->st->start_time == AV_NOPTS_VALUE)
1768 if(input_files_ts_offset[ist->file_index])
1769 ist->next_pts= AV_NOPTS_VALUE;
1773 /* compute buffer size max (should use a complete heuristic) */
1774 for(i=0;i<nb_input_files;i++) {
1775 file_table[i].buffer_size_max = 2048;
1778 /* set meta data information from input file if required */
1779 for (i=0;i<nb_meta_data_maps;i++) {
1780 AVFormatContext *out_file;
1781 AVFormatContext *in_file;
1783 int out_file_index = meta_data_maps[i].out_file;
1784 int in_file_index = meta_data_maps[i].in_file;
1785 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1786 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1787 ret = AVERROR(EINVAL);
1790 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1791 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1792 ret = AVERROR(EINVAL);
1796 out_file = output_files[out_file_index];
1797 in_file = input_files[in_file_index];
1799 strcpy(out_file->title, in_file->title);
1800 strcpy(out_file->author, in_file->author);
1801 strcpy(out_file->copyright, in_file->copyright);
1802 strcpy(out_file->comment, in_file->comment);
1803 strcpy(out_file->album, in_file->album);
1804 out_file->year = in_file->year;
1805 out_file->track = in_file->track;
1806 strcpy(out_file->genre, in_file->genre);
1809 /* open files and write file headers */
1810 for(i=0;i<nb_output_files;i++) {
1811 os = output_files[i];
1812 if (av_write_header(os) < 0) {
1813 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1814 ret = AVERROR(EINVAL);
1819 if ( !using_stdin && verbose >= 0) {
1820 fprintf(stderr, "Press [q] to stop encoding\n");
1821 url_set_interrupt_cb(decode_interrupt_cb);
1828 for(; received_sigterm == 0;) {
1829 int file_index, ist_index;
1837 /* if 'q' pressed, exits */
1841 /* read_key() returns 0 on EOF */
1847 /* select the stream that we must read now by looking at the
1848 smallest output pts */
1850 for(i=0;i<nb_ostreams;i++) {
1853 os = output_files[ost->file_index];
1854 ist = ist_table[ost->source_index];
1855 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1856 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1858 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1859 ipts = (double)ist->pts;
1860 if (!file_table[ist->file_index].eof_reached){
1861 if(ipts < ipts_min) {
1863 if(input_sync ) file_index = ist->file_index;
1865 if(opts < opts_min) {
1867 if(!input_sync) file_index = ist->file_index;
1870 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1875 /* if none, if is finished */
1876 if (file_index < 0) {
1880 /* finish if recording time exhausted */
1881 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1884 /* finish if limit size exhausted */
1885 if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
1888 /* read a frame from it and output it in the fifo */
1889 is = input_files[file_index];
1890 if (av_read_frame(is, &pkt) < 0) {
1891 file_table[file_index].eof_reached = 1;
1892 if (opt_shortest) break; else continue; //
1896 stream_no_data = is;
1901 av_pkt_dump(stdout, &pkt, do_hex_dump);
1903 /* the following test is needed in case new streams appear
1904 dynamically in stream : we ignore them */
1905 if (pkt.stream_index >= file_table[file_index].nb_streams)
1906 goto discard_packet;
1907 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1908 ist = ist_table[ist_index];
1910 goto discard_packet;
1912 // 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);
1913 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1914 int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
1915 if(FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
1916 input_files_ts_offset[ist->file_index]-= delta;
1918 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1919 for(i=0; i<file_table[file_index].nb_streams; i++){
1920 int index= file_table[file_index].ist_index + i;
1921 ist_table[index]->next_pts += delta;
1922 ist_table[index]->is_start=1;
1927 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1928 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1931 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1932 ist->file_index, ist->index);
1934 av_free_packet(&pkt);
1939 av_free_packet(&pkt);
1941 /* dump report by using the output first video and audio streams */
1942 print_report(output_files, ost_table, nb_ostreams, 0);
1945 /* at the end of stream, we must flush the decoder buffers */
1946 for(i=0;i<nb_istreams;i++) {
1948 if (ist->decoding_needed) {
1949 output_packet(ist, i, ost_table, nb_ostreams, NULL);
1955 /* write the trailer if needed and close file */
1956 for(i=0;i<nb_output_files;i++) {
1957 os = output_files[i];
1958 av_write_trailer(os);
1961 /* dump report by using the first video and audio streams */
1962 print_report(output_files, ost_table, nb_ostreams, 1);
1964 /* close each encoder */
1965 for(i=0;i<nb_ostreams;i++) {
1967 if (ost->encoding_needed) {
1968 av_freep(&ost->st->codec->stats_in);
1969 avcodec_close(ost->st->codec);
1973 /* close each decoder */
1974 for(i=0;i<nb_istreams;i++) {
1976 if (ist->decoding_needed) {
1977 avcodec_close(ist->st->codec);
1985 av_freep(&bit_buffer);
1986 av_free(file_table);
1989 for(i=0;i<nb_istreams;i++) {
1996 for(i=0;i<nb_ostreams;i++) {
2000 fclose(ost->logfile);
2001 ost->logfile = NULL;
2003 av_fifo_free(&ost->fifo); /* works even if fifo is not
2004 initialized but set to zero */
2005 av_free(ost->pict_tmp.data[0]);
2006 if (ost->video_resample)
2007 sws_freeContext(ost->img_resample_ctx);
2008 if (ost->audio_resample)
2009 audio_resample_close(ost->resample);
2017 ret = AVERROR(ENOMEM);
2022 int file_read(const char *filename)
2025 unsigned char buffer[1024];
2028 if (url_open(&h, filename, O_RDONLY) < 0) {
2029 printf("could not open '%s'\n", filename);
2033 len = url_read(h, buffer, sizeof(buffer));
2036 for(i=0;i<len;i++) putchar(buffer[i]);
2043 static void opt_format(const char *arg)
2045 /* compatibility stuff for pgmyuv */
2046 if (!strcmp(arg, "pgmyuv")) {
2047 pgmyuv_compatibility_hack=1;
2048 // opt_image_format(arg);
2052 file_iformat = av_find_input_format(arg);
2053 file_oformat = guess_format(arg, NULL, NULL);
2054 if (!file_iformat && !file_oformat) {
2055 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2060 static void opt_video_rc_eq(char *arg)
2065 static void opt_video_rc_override_string(char *arg)
2067 video_rc_override_string = arg;
2070 static void opt_me_threshold(const char *arg)
2072 me_threshold = atoi(arg);
2075 static void opt_verbose(const char *arg)
2077 verbose = atoi(arg);
2078 av_log_level = atoi(arg);
2081 static void opt_frame_rate(const char *arg)
2083 if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2084 fprintf(stderr, "Incorrect frame rate\n");
2089 static void opt_frame_crop_top(const char *arg)
2091 frame_topBand = atoi(arg);
2092 if (frame_topBand < 0) {
2093 fprintf(stderr, "Incorrect top crop size\n");
2096 if ((frame_topBand % 2) != 0) {
2097 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2100 if ((frame_topBand) >= frame_height){
2101 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2104 frame_height -= frame_topBand;
2107 static void opt_frame_crop_bottom(const char *arg)
2109 frame_bottomBand = atoi(arg);
2110 if (frame_bottomBand < 0) {
2111 fprintf(stderr, "Incorrect bottom crop size\n");
2114 if ((frame_bottomBand % 2) != 0) {
2115 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2118 if ((frame_bottomBand) >= frame_height){
2119 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2122 frame_height -= frame_bottomBand;
2125 static void opt_frame_crop_left(const char *arg)
2127 frame_leftBand = atoi(arg);
2128 if (frame_leftBand < 0) {
2129 fprintf(stderr, "Incorrect left crop size\n");
2132 if ((frame_leftBand % 2) != 0) {
2133 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2136 if ((frame_leftBand) >= frame_width){
2137 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2140 frame_width -= frame_leftBand;
2143 static void opt_frame_crop_right(const char *arg)
2145 frame_rightBand = atoi(arg);
2146 if (frame_rightBand < 0) {
2147 fprintf(stderr, "Incorrect right crop size\n");
2150 if ((frame_rightBand % 2) != 0) {
2151 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2154 if ((frame_rightBand) >= frame_width){
2155 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2158 frame_width -= frame_rightBand;
2161 static void opt_frame_size(const char *arg)
2163 if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2164 fprintf(stderr, "Incorrect frame size\n");
2167 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2168 fprintf(stderr, "Frame size must be a multiple of 2\n");
2174 #define SCALEBITS 10
2175 #define ONE_HALF (1 << (SCALEBITS - 1))
2176 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2178 #define RGB_TO_Y(r, g, b) \
2179 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2180 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2182 #define RGB_TO_U(r1, g1, b1, shift)\
2183 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2184 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2186 #define RGB_TO_V(r1, g1, b1, shift)\
2187 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2188 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2190 static void opt_pad_color(const char *arg) {
2191 /* Input is expected to be six hex digits similar to
2192 how colors are expressed in html tags (but without the #) */
2193 int rgb = strtol(arg, NULL, 16);
2197 g = ((rgb >> 8) & 255);
2200 padcolor[0] = RGB_TO_Y(r,g,b);
2201 padcolor[1] = RGB_TO_U(r,g,b,0);
2202 padcolor[2] = RGB_TO_V(r,g,b,0);
2205 static void opt_frame_pad_top(const char *arg)
2207 frame_padtop = atoi(arg);
2208 if (frame_padtop < 0) {
2209 fprintf(stderr, "Incorrect top pad size\n");
2212 if ((frame_padtop % 2) != 0) {
2213 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2218 static void opt_frame_pad_bottom(const char *arg)
2220 frame_padbottom = atoi(arg);
2221 if (frame_padbottom < 0) {
2222 fprintf(stderr, "Incorrect bottom pad size\n");
2225 if ((frame_padbottom % 2) != 0) {
2226 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2232 static void opt_frame_pad_left(const char *arg)
2234 frame_padleft = atoi(arg);
2235 if (frame_padleft < 0) {
2236 fprintf(stderr, "Incorrect left pad size\n");
2239 if ((frame_padleft % 2) != 0) {
2240 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2246 static void opt_frame_pad_right(const char *arg)
2248 frame_padright = atoi(arg);
2249 if (frame_padright < 0) {
2250 fprintf(stderr, "Incorrect right pad size\n");
2253 if ((frame_padright % 2) != 0) {
2254 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2260 static void opt_frame_pix_fmt(const char *arg)
2262 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2265 static void opt_frame_aspect_ratio(const char *arg)
2271 p = strchr(arg, ':');
2273 x = strtol(arg, (char **)&arg, 10);
2275 y = strtol(arg+1, (char **)&arg, 10);
2277 ar = (double)x / (double)y;
2279 ar = strtod(arg, (char **)&arg);
2282 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2285 frame_aspect_ratio = ar;
2288 static void opt_qscale(const char *arg)
2290 video_qscale = atof(arg);
2291 if (video_qscale <= 0 ||
2292 video_qscale > 255) {
2293 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2298 static void opt_qdiff(const char *arg)
2300 video_qdiff = atoi(arg);
2301 if (video_qdiff < 0 ||
2303 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2308 static void opt_packet_size(const char *arg)
2310 packet_size= atoi(arg);
2313 static void opt_strict(const char *arg)
2318 static void opt_top_field_first(const char *arg)
2320 top_field_first= atoi(arg);
2323 static void opt_thread_count(const char *arg)
2325 thread_count= atoi(arg);
2326 #if !defined(HAVE_THREADS)
2328 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2332 static void opt_audio_bitrate(const char *arg)
2334 audio_bit_rate = atoi(arg) * 1000;
2337 static void opt_audio_rate(const char *arg)
2339 audio_sample_rate = atoi(arg);
2342 static void opt_audio_channels(const char *arg)
2344 audio_channels = atoi(arg);
2347 static void opt_video_channel(const char *arg)
2349 video_channel = strtol(arg, NULL, 0);
2352 static void opt_video_standard(const char *arg)
2354 video_standard = av_strdup(arg);
2357 static void opt_codec(int *pstream_copy, int *pcodec_id,
2358 int codec_type, const char *arg)
2362 if (!strcmp(arg, "copy")) {
2367 if (!strcmp(p->name, arg) && p->type == codec_type)
2372 fprintf(stderr, "Unknown codec '%s'\n", arg);
2380 static void opt_audio_codec(const char *arg)
2382 opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2385 static void opt_audio_tag(const char *arg)
2388 audio_codec_tag= strtol(arg, &tail, 0);
2391 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2394 static void opt_video_tag(const char *arg)
2397 video_codec_tag= strtol(arg, &tail, 0);
2400 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2403 static void add_frame_hooker(const char *arg)
2408 char *args = av_strdup(arg);
2412 argv[0] = strtok(args, " ");
2413 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2416 i = frame_hook_add(argc, argv);
2419 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2424 const char *motion_str[] = {
2437 static void opt_motion_estimation(const char *arg)
2443 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2446 if (!strcmp(*p, arg))
2450 me_method = (p - motion_str) + 1;
2453 static void opt_video_codec(const char *arg)
2455 opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2458 static void opt_subtitle_codec(const char *arg)
2460 opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2463 static void opt_map(const char *arg)
2469 m = &stream_maps[nb_stream_maps++];
2471 m->file_index = strtol(arg, (char **)&p, 0);
2475 m->stream_index = strtol(p, (char **)&p, 0);
2478 m->sync_file_index = strtol(p, (char **)&p, 0);
2481 m->sync_stream_index = strtol(p, (char **)&p, 0);
2483 m->sync_file_index = m->file_index;
2484 m->sync_stream_index = m->stream_index;
2488 static void opt_map_meta_data(const char *arg)
2494 m = &meta_data_maps[nb_meta_data_maps++];
2496 m->out_file = strtol(arg, (char **)&p, 0);
2500 m->in_file = strtol(p, (char **)&p, 0);
2503 static void opt_recording_time(const char *arg)
2505 recording_time = parse_date(arg, 1);
2508 static void opt_start_time(const char *arg)
2510 start_time = parse_date(arg, 1);
2513 static void opt_rec_timestamp(const char *arg)
2515 rec_timestamp = parse_date(arg, 0) / 1000000;
2518 static void opt_input_ts_offset(const char *arg)
2520 input_ts_offset = parse_date(arg, 1);
2523 static void opt_input_file(const char *filename)
2525 AVFormatContext *ic;
2526 AVFormatParameters params, *ap = ¶ms;
2527 int err, i, ret, rfps, rfps_base;
2530 if (!strcmp(filename, "-"))
2533 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2534 !strcmp( filename, "/dev/stdin" );
2536 /* get default parameters from command line */
2537 ic = av_alloc_format_context();
2539 memset(ap, 0, sizeof(*ap));
2540 ap->prealloced_context = 1;
2541 ap->sample_rate = audio_sample_rate;
2542 ap->channels = audio_channels;
2543 ap->time_base.den = frame_rate;
2544 ap->time_base.num = frame_rate_base;
2545 ap->width = frame_width + frame_padleft + frame_padright;
2546 ap->height = frame_height + frame_padtop + frame_padbottom;
2547 ap->pix_fmt = frame_pix_fmt;
2548 ap->channel = video_channel;
2549 ap->standard = video_standard;
2550 ap->video_codec_id = video_codec_id;
2551 ap->audio_codec_id = audio_codec_id;
2552 if(pgmyuv_compatibility_hack)
2553 ap->video_codec_id= CODEC_ID_PGMYUV;
2555 for(i=0; i<opt_name_count; i++){
2556 const AVOption *opt;
2557 double d= av_get_double(avformat_opts, opt_names[i], &opt);
2558 if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2559 av_set_double(ic, opt_names[i], d);
2561 /* open the input file with generic libav function */
2562 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2564 print_error(filename, err);
2568 ic->loop_input = loop_input;
2570 /* If not enough info to get the stream parameters, we decode the
2571 first frames to get it. (used in mpeg case for example) */
2572 ret = av_find_stream_info(ic);
2573 if (ret < 0 && verbose >= 0) {
2574 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2578 timestamp = start_time;
2579 /* add the stream start time */
2580 if (ic->start_time != AV_NOPTS_VALUE)
2581 timestamp += ic->start_time;
2583 /* if seeking requested, we execute it */
2584 if (start_time != 0) {
2585 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2587 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2588 filename, (double)timestamp / AV_TIME_BASE);
2590 /* reset seek info */
2594 /* update the current parameters so that they match the one of the input stream */
2595 for(i=0;i<ic->nb_streams;i++) {
2597 AVCodecContext *enc = ic->streams[i]->codec;
2598 #if defined(HAVE_THREADS)
2600 avcodec_thread_init(enc, thread_count);
2602 enc->thread_count= thread_count;
2603 switch(enc->codec_type) {
2604 case CODEC_TYPE_AUDIO:
2605 for(j=0; j<opt_name_count; j++){
2606 const AVOption *opt;
2607 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2608 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2609 av_set_double(enc, opt_names[j], d);
2611 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2612 audio_channels = enc->channels;
2613 audio_sample_rate = enc->sample_rate;
2615 ic->streams[i]->discard= AVDISCARD_ALL;
2617 case CODEC_TYPE_VIDEO:
2618 for(j=0; j<opt_name_count; j++){
2619 const AVOption *opt;
2620 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2621 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2622 av_set_double(enc, opt_names[j], d);
2624 frame_height = enc->height;
2625 frame_width = enc->width;
2626 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2627 frame_pix_fmt = enc->pix_fmt;
2628 rfps = ic->streams[i]->r_frame_rate.num;
2629 rfps_base = ic->streams[i]->r_frame_rate.den;
2630 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2632 enc->debug |= FF_DEBUG_MV;
2634 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2637 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2638 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2640 (float)rfps / rfps_base, rfps, rfps_base);
2642 /* update the current frame rate to match the stream frame rate */
2644 frame_rate_base = rfps_base;
2646 enc->rate_emu = rate_emu;
2648 ic->streams[i]->discard= AVDISCARD_ALL;
2649 else if(video_discard)
2650 ic->streams[i]->discard= video_discard;
2652 case CODEC_TYPE_DATA:
2654 case CODEC_TYPE_SUBTITLE:
2656 case CODEC_TYPE_UNKNOWN:
2663 input_files[nb_input_files] = ic;
2664 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2665 /* dump the file content */
2667 dump_format(ic, nb_input_files, filename, 0);
2670 file_iformat = NULL;
2671 file_oformat = NULL;
2678 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2680 int has_video, has_audio, i, j;
2681 AVFormatContext *ic;
2685 for(j=0;j<nb_input_files;j++) {
2686 ic = input_files[j];
2687 for(i=0;i<ic->nb_streams;i++) {
2688 AVCodecContext *enc = ic->streams[i]->codec;
2689 switch(enc->codec_type) {
2690 case CODEC_TYPE_AUDIO:
2693 case CODEC_TYPE_VIDEO:
2696 case CODEC_TYPE_DATA:
2697 case CODEC_TYPE_UNKNOWN:
2698 case CODEC_TYPE_SUBTITLE:
2705 *has_video_ptr = has_video;
2706 *has_audio_ptr = has_audio;
2709 static void new_video_stream(AVFormatContext *oc)
2712 AVCodecContext *video_enc;
2715 st = av_new_stream(oc, oc->nb_streams);
2717 fprintf(stderr, "Could not alloc stream\n");
2720 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2721 video_bitstream_filters= NULL;
2723 #if defined(HAVE_THREADS)
2725 avcodec_thread_init(st->codec, thread_count);
2728 video_enc = st->codec;
2731 video_enc->codec_tag= video_codec_tag;
2733 if( (video_global_header&1)
2734 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2735 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2736 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2738 if(video_global_header&2){
2739 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2740 avctx_opts->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2743 if (video_stream_copy) {
2744 st->stream_copy = 1;
2745 video_enc->codec_type = CODEC_TYPE_VIDEO;
2751 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2752 if (video_codec_id != CODEC_ID_NONE)
2753 codec_id = video_codec_id;
2755 video_enc->codec_id = codec_id;
2756 codec = avcodec_find_encoder(codec_id);
2758 for(i=0; i<opt_name_count; i++){
2759 const AVOption *opt;
2760 double d= av_get_double(avctx_opts, opt_names[i], &opt);
2761 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2762 av_set_double(video_enc, opt_names[i], d);
2765 video_enc->time_base.den = frame_rate;
2766 video_enc->time_base.num = frame_rate_base;
2767 if(codec && codec->supported_framerates){
2768 const AVRational *p= codec->supported_framerates;
2769 AVRational req= (AVRational){frame_rate, frame_rate_base};
2770 const AVRational *best=NULL;
2771 AVRational best_error= (AVRational){INT_MAX, 1};
2772 for(; p->den!=0; p++){
2773 AVRational error= av_sub_q(req, *p);
2774 if(error.num <0) error.num *= -1;
2775 if(av_cmp_q(error, best_error) < 0){
2780 video_enc->time_base.den= best->num;
2781 video_enc->time_base.num= best->den;
2784 video_enc->width = frame_width + frame_padright + frame_padleft;
2785 video_enc->height = frame_height + frame_padtop + frame_padbottom;
2786 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2787 video_enc->pix_fmt = frame_pix_fmt;
2789 if(codec && codec->pix_fmts){
2790 const enum PixelFormat *p= codec->pix_fmts;
2792 if(*p == video_enc->pix_fmt)
2796 video_enc->pix_fmt = codec->pix_fmts[0];
2800 video_enc->gop_size = 0;
2801 if (video_qscale || same_quality) {
2802 video_enc->flags |= CODEC_FLAG_QSCALE;
2803 video_enc->global_quality=
2804 st->quality = FF_QP2LAMBDA * video_qscale;
2808 video_enc->intra_matrix = intra_matrix;
2810 video_enc->inter_matrix = inter_matrix;
2812 video_enc->max_qdiff = video_qdiff;
2813 video_enc->rc_eq = video_rc_eq;
2814 video_enc->thread_count = thread_count;
2815 p= video_rc_override_string;
2818 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2820 fprintf(stderr, "error parsing rc_override\n");
2823 video_enc->rc_override=
2824 av_realloc(video_enc->rc_override,
2825 sizeof(RcOverride)*(i+1));
2826 video_enc->rc_override[i].start_frame= start;
2827 video_enc->rc_override[i].end_frame = end;
2829 video_enc->rc_override[i].qscale= q;
2830 video_enc->rc_override[i].quality_factor= 1.0;
2833 video_enc->rc_override[i].qscale= 0;
2834 video_enc->rc_override[i].quality_factor= -q/100.0;
2839 video_enc->rc_override_count=i;
2840 if (!video_enc->rc_initial_buffer_occupancy)
2841 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2842 video_enc->me_threshold= me_threshold;
2843 video_enc->intra_dc_precision= intra_dc_precision - 8;
2844 video_enc->strict_std_compliance = strict;
2847 video_enc->rtp_mode= 1;
2848 video_enc->rtp_payload_size= packet_size;
2852 video_enc->flags|= CODEC_FLAG_PSNR;
2854 video_enc->me_method = me_method;
2859 video_enc->flags |= CODEC_FLAG_PASS1;
2861 video_enc->flags |= CODEC_FLAG_PASS2;
2866 /* reset some key parameters */
2868 video_codec_id = CODEC_ID_NONE;
2869 video_stream_copy = 0;
2872 static void new_audio_stream(AVFormatContext *oc)
2875 AVCodecContext *audio_enc;
2878 st = av_new_stream(oc, oc->nb_streams);
2880 fprintf(stderr, "Could not alloc stream\n");
2884 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2885 audio_bitstream_filters= NULL;
2887 #if defined(HAVE_THREADS)
2889 avcodec_thread_init(st->codec, thread_count);
2892 audio_enc = st->codec;
2893 audio_enc->codec_type = CODEC_TYPE_AUDIO;
2894 audio_enc->strict_std_compliance = strict;
2897 audio_enc->codec_tag= audio_codec_tag;
2899 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
2900 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2901 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2903 if (audio_stream_copy) {
2904 st->stream_copy = 1;
2905 audio_enc->channels = audio_channels;
2907 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
2909 for(i=0; i<opt_name_count; i++){
2910 const AVOption *opt;
2911 double d= av_get_double(avctx_opts, opt_names[i], &opt);
2912 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2913 av_set_double(audio_enc, opt_names[i], d);
2916 if (audio_codec_id != CODEC_ID_NONE)
2917 codec_id = audio_codec_id;
2918 audio_enc->codec_id = codec_id;
2920 audio_enc->bit_rate = audio_bit_rate;
2921 if (audio_qscale > QSCALE_NONE) {
2922 audio_enc->flags |= CODEC_FLAG_QSCALE;
2923 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
2925 audio_enc->thread_count = thread_count;
2926 audio_enc->channels = audio_channels;
2928 audio_enc->sample_rate = audio_sample_rate;
2929 audio_enc->time_base= (AVRational){1, audio_sample_rate};
2930 if (audio_language) {
2931 pstrcpy(st->language, sizeof(st->language), audio_language);
2932 av_free(audio_language);
2933 audio_language = NULL;
2936 /* reset some key parameters */
2938 audio_codec_id = CODEC_ID_NONE;
2939 audio_stream_copy = 0;
2942 static void opt_new_subtitle_stream(void)
2944 AVFormatContext *oc;
2946 AVCodecContext *subtitle_enc;
2949 if (nb_output_files <= 0) {
2950 fprintf(stderr, "At least one output file must be specified\n");
2953 oc = output_files[nb_output_files - 1];
2955 st = av_new_stream(oc, oc->nb_streams);
2957 fprintf(stderr, "Could not alloc stream\n");
2961 subtitle_enc = st->codec;
2962 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
2963 if (subtitle_stream_copy) {
2964 st->stream_copy = 1;
2966 for(i=0; i<opt_name_count; i++){
2967 const AVOption *opt;
2968 double d= av_get_double(avctx_opts, opt_names[i], &opt);
2969 if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2970 av_set_double(subtitle_enc, opt_names[i], d);
2972 subtitle_enc->codec_id = subtitle_codec_id;
2975 if (subtitle_language) {
2976 pstrcpy(st->language, sizeof(st->language), subtitle_language);
2977 av_free(subtitle_language);
2978 subtitle_language = NULL;
2981 subtitle_codec_id = CODEC_ID_NONE;
2982 subtitle_stream_copy = 0;
2985 static void opt_new_audio_stream(void)
2987 AVFormatContext *oc;
2988 if (nb_output_files <= 0) {
2989 fprintf(stderr, "At least one output file must be specified\n");
2992 oc = output_files[nb_output_files - 1];
2993 new_audio_stream(oc);
2996 static void opt_new_video_stream(void)
2998 AVFormatContext *oc;
2999 if (nb_output_files <= 0) {
3000 fprintf(stderr, "At least one output file must be specified\n");
3003 oc = output_files[nb_output_files - 1];
3004 new_video_stream(oc);
3007 static void opt_output_file(const char *filename)
3009 AVFormatContext *oc;
3010 int use_video, use_audio, input_has_video, input_has_audio, i;
3011 AVFormatParameters params, *ap = ¶ms;
3013 if (!strcmp(filename, "-"))
3016 oc = av_alloc_format_context();
3018 if (!file_oformat) {
3019 file_oformat = guess_format(NULL, filename, NULL);
3020 if (!file_oformat) {
3021 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3027 oc->oformat = file_oformat;
3028 pstrcpy(oc->filename, sizeof(oc->filename), filename);
3030 if (!strcmp(file_oformat->name, "ffm") &&
3031 strstart(filename, "http:", NULL)) {
3032 /* special case for files sent to ffserver: we get the stream
3033 parameters from ffserver */
3034 if (read_ffserver_streams(oc, filename) < 0) {
3035 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3039 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3040 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3042 /* disable if no corresponding type found and at least one
3044 if (nb_input_files > 0) {
3045 check_audio_video_inputs(&input_has_video, &input_has_audio);
3046 if (!input_has_video)
3048 if (!input_has_audio)
3052 /* manual disable */
3053 if (audio_disable) {
3056 if (video_disable) {
3061 new_video_stream(oc);
3065 new_audio_stream(oc);
3068 oc->timestamp = rec_timestamp;
3071 pstrcpy(oc->title, sizeof(oc->title), str_title);
3073 pstrcpy(oc->author, sizeof(oc->author), str_author);
3075 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3077 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3079 pstrcpy(oc->album, sizeof(oc->album), str_album);
3082 output_files[nb_output_files++] = oc;
3084 /* check filename in case of an image number is expected */
3085 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3086 if (!av_filename_number_test(oc->filename)) {
3087 print_error(oc->filename, AVERROR_NUMEXPECTED);
3092 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3093 /* test if it already exists to avoid loosing precious files */
3094 if (!file_overwrite &&
3095 (strchr(filename, ':') == NULL ||
3096 strstart(filename, "file:", NULL))) {
3097 if (url_exist(filename)) {
3100 if ( !using_stdin ) {
3101 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3104 if (toupper(c) != 'Y') {
3105 fprintf(stderr, "Not overwriting - exiting\n");
3110 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3117 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3118 fprintf(stderr, "Could not open '%s'\n", filename);
3123 memset(ap, 0, sizeof(*ap));
3124 if (av_set_parameters(oc, ap) < 0) {
3125 fprintf(stderr, "%s: Invalid encoding parameters\n",
3130 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3131 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3132 oc->loop_output = loop_output;
3134 for(i=0; i<opt_name_count; i++){
3135 const AVOption *opt;
3136 double d = av_get_double(avformat_opts, opt_names[i], &opt);
3137 if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3138 av_set_double(oc, opt_names[i], d);
3141 /* reset some options */
3142 file_oformat = NULL;
3143 file_iformat = NULL;
3146 /* same option as mencoder */
3147 static void opt_pass(const char *pass_str)
3150 pass = atoi(pass_str);
3151 if (pass != 1 && pass != 2) {
3152 fprintf(stderr, "pass number can be only 1 or 2\n");
3158 #if defined(__MINGW32__) || defined(CONFIG_OS2)
3159 static int64_t getutime(void)
3161 return av_gettime();
3164 static int64_t getutime(void)
3166 struct rusage rusage;
3168 getrusage(RUSAGE_SELF, &rusage);
3169 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3173 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3174 extern int ffm_nopts;
3177 static void show_formats(void)
3179 AVInputFormat *ifmt;
3180 AVOutputFormat *ofmt;
3183 const char **pp, *last_name;
3185 printf("File formats:\n");
3190 const char *name=NULL;
3191 const char *long_name=NULL;
3193 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3194 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3195 strcmp(ofmt->name, last_name)>0){
3197 long_name= ofmt->long_name;
3201 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3202 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3203 strcmp(ifmt->name, last_name)>0){
3205 long_name= ifmt->long_name;
3208 if(name && strcmp(ifmt->name, name)==0)
3220 long_name ? long_name:" ");
3224 printf("Codecs:\n");
3230 const char *type_str;
3233 for(p = first_avcodec; p != NULL; p = p->next) {
3234 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3235 strcmp(p->name, last_name)>0){
3237 decode= encode= cap=0;
3239 if(p2 && strcmp(p->name, p2->name)==0){
3240 if(p->decode) decode=1;
3241 if(p->encode) encode=1;
3242 cap |= p->capabilities;
3247 last_name= p2->name;
3250 case CODEC_TYPE_VIDEO:
3253 case CODEC_TYPE_AUDIO:
3256 case CODEC_TYPE_SUBTITLE:
3265 decode ? "D": (/*p2->decoder ? "d":*/" "),
3268 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3269 cap & CODEC_CAP_DR1 ? "D":" ",
3270 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3272 /* if(p2->decoder && decode==0)
3273 printf(" use %s for decoding", p2->decoder->name);*/
3278 printf("Supported file protocols:\n");
3279 for(up = first_protocol; up != NULL; up = up->next)
3280 printf(" %s:", up->name);
3283 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3284 printf("Motion estimation methods:\n");
3288 if ((pp - motion_str + 1) == ME_ZERO)
3289 printf("(fastest)");
3290 else if ((pp - motion_str + 1) == ME_FULL)
3291 printf("(slowest)");
3292 else if ((pp - motion_str + 1) == ME_EPZS)
3293 printf("(default)");
3298 "Note, the names of encoders and decoders dont always match, so there are\n"
3299 "several cases where the above table shows encoder only or decoder only entries\n"
3300 "even though both encoding and decoding are supported for example, the h263\n"
3301 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3306 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3309 const char *p = str;
3316 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3323 static void opt_inter_matrix(const char *arg)
3325 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3326 parse_matrix_coeffs(inter_matrix, arg);
3329 static void opt_intra_matrix(const char *arg)
3331 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3332 parse_matrix_coeffs(intra_matrix, arg);
3335 static void opt_target(const char *arg)
3338 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3340 if(!strncmp(arg, "pal-", 4)) {
3343 } else if(!strncmp(arg, "ntsc-", 5)) {
3346 } else if(!strncmp(arg, "film-", 5)) {
3351 /* Calculate FR via float to avoid int overflow */
3352 fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3355 } else if((fr == 29970) || (fr == 23976)) {
3358 /* Try to determine PAL/NTSC by peeking in the input files */
3359 if(nb_input_files) {
3361 for(j = 0; j < nb_input_files; j++) {
3362 for(i = 0; i < input_files[j]->nb_streams; i++) {
3363 AVCodecContext *c = input_files[j]->streams[i]->codec;
3364 if(c->codec_type != CODEC_TYPE_VIDEO)
3366 fr = c->time_base.den * 1000 / c->time_base.num;
3370 } else if((fr == 29970) || (fr == 23976)) {
3380 if(verbose && norm >= 0)
3381 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3385 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3386 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3387 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3391 if(!strcmp(arg, "vcd")) {
3393 opt_video_codec("mpeg1video");
3394 opt_audio_codec("mp2");
3397 opt_frame_size(norm ? "352x240" : "352x288");
3398 opt_frame_rate(frame_rates[norm]);
3399 opt_default("gop", norm ? "18" : "15");
3401 opt_default("b", "1150000");
3402 opt_default("maxrate", "1150000");
3403 opt_default("minrate", "1150000");
3404 opt_default("bufsize", "327680"); // 40*1024*8;
3406 audio_bit_rate = 224000;
3407 audio_sample_rate = 44100;
3410 opt_default("packetsize", "2324");
3411 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3413 /* We have to offset the PTS, so that it is consistent with the SCR.
3414 SCR starts at 36000, but the first two packs contain only padding
3415 and the first pack from the other stream, respectively, may also have
3416 been written before.
3417 So the real data starts at SCR 36000+3*1200. */
3418 mux_preload= (36000+3*1200) / 90000.0; //0.44
3419 } else if(!strcmp(arg, "svcd")) {
3421 opt_video_codec("mpeg2video");
3422 opt_audio_codec("mp2");
3425 opt_frame_size(norm ? "480x480" : "480x576");
3426 opt_frame_rate(frame_rates[norm]);
3427 opt_default("gop", norm ? "18" : "15");
3429 opt_default("b", "2040000");
3430 opt_default("maxrate", "2516000");
3431 opt_default("minrate", "0"); //1145000;
3432 opt_default("bufsize", "1835008"); //224*1024*8;
3433 opt_default("flags", "+SCAN_OFFSET");
3436 audio_bit_rate = 224000;
3437 audio_sample_rate = 44100;
3439 opt_default("packetsize", "2324");
3441 } else if(!strcmp(arg, "dvd")) {
3443 opt_video_codec("mpeg2video");
3444 opt_audio_codec("ac3");
3447 opt_frame_size(norm ? "720x480" : "720x576");
3448 opt_frame_rate(frame_rates[norm]);
3449 opt_default("gop", norm ? "18" : "15");
3451 opt_default("b", "6000000");
3452 opt_default("maxrate", "9000000");
3453 opt_default("minrate", "0"); //1500000;
3454 opt_default("bufsize", "1835008"); //224*1024*8;
3456 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3457 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3459 audio_bit_rate = 448000;
3460 audio_sample_rate = 48000;
3462 } else if(!strncmp(arg, "dv", 2)) {
3466 opt_frame_size(norm ? "720x480" : "720x576");
3467 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3468 (norm ? "yuv411p" : "yuv420p"));
3469 opt_frame_rate(frame_rates[norm]);
3471 audio_sample_rate = 48000;
3475 fprintf(stderr, "Unknown target: %s\n", arg);
3480 static void opt_video_bsf(const char *arg)
3482 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3483 AVBitStreamFilterContext **bsfp;
3486 fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3490 bsfp= &video_bitstream_filters;
3492 bsfp= &(*bsfp)->next;
3497 //FIXME avoid audio - video code duplication
3498 static void opt_audio_bsf(const char *arg)
3500 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3501 AVBitStreamFilterContext **bsfp;
3504 fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3508 bsfp= &audio_bitstream_filters;
3510 bsfp= &(*bsfp)->next;
3515 static void show_version(void)
3517 /* TODO: add function interface to avutil and avformat */
3518 fprintf(stderr, "ffmpeg " FFMPEG_VERSION "\n"
3522 LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3526 static int opt_default(const char *opt, const char *arg){
3527 const AVOption *o= av_set_string(avctx_opts, opt, arg);
3529 o = av_set_string(avformat_opts, opt, arg);
3533 // 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));
3535 //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
3536 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
3537 opt_names[opt_name_count++]= o->name;
3539 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3540 /* disable generate of real time pts in ffm (need to be supressed anyway) */
3541 if(avctx_opts->flags & CODEC_FLAG_BITEXACT)
3545 if(avctx_opts->debug)
3546 av_log_level = AV_LOG_DEBUG;
3550 const OptionDef options[] = {
3552 { "L", 0, {(void*)show_license}, "show license" },
3553 { "h", 0, {(void*)show_help}, "show help" },
3554 { "version", 0, {(void*)show_version}, "show version" },
3555 { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3556 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3557 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3558 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3559 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3560 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3561 { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3562 { "fs", HAS_ARG | OPT_INT, {(void*)&limit_filesize}, "set the limit file size", "limit_size" }, //
3563 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3564 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3565 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3566 { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3567 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3568 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3569 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3570 { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3571 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3572 "add timings for benchmarking" },
3573 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3574 "dump each input packet" },
3575 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3576 "when dumping packets, also dump the payload" },
3577 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3578 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3579 { "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)", "" },
3580 { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3581 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3582 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3583 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3584 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3585 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3586 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3587 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3588 { "dts_delta_threshold", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
3591 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3592 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3593 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3594 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3595 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3596 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3597 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3598 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3599 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3600 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3601 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3602 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3603 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3604 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3605 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3606 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3607 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3608 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3609 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3610 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3611 { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantizer scale (VBR)", "q" },
3612 { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3613 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3614 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3615 { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
3617 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "" },
3618 { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
3619 { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3620 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3621 "use same video quality as source (implies VBR)" },
3622 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3623 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3624 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3625 "deinterlace pictures" },
3626 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3627 { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
3628 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3629 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3630 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3631 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3632 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3633 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3634 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3635 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3638 { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
3639 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3640 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3641 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3642 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3643 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3644 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3645 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3646 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3647 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3649 /* subtitle options */
3650 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3651 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3652 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3655 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3656 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3657 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3660 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3661 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3663 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
3664 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
3666 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3670 static void show_banner(void)
3672 fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2007 Fabrice Bellard, et al.\n");
3673 fprintf(stderr, " configuration: " FFMPEG_CONFIGURATION "\n");
3674 fprintf(stderr, " libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
3675 fprintf(stderr, " libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
3676 fprintf(stderr, " libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
3677 fprintf(stderr, " built on " __DATE__ " " __TIME__);
3679 fprintf(stderr, ", gcc: " __VERSION__ "\n");
3681 fprintf(stderr, ", using a non-gcc compiler\n");
3685 static void show_license(void)
3690 "FFmpeg is free software; you can redistribute it and/or modify\n"
3691 "it under the terms of the GNU General Public License as published by\n"
3692 "the Free Software Foundation; either version 2 of the License, or\n"
3693 "(at your option) any later version.\n"
3695 "FFmpeg is distributed in the hope that it will be useful,\n"
3696 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3697 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
3698 "GNU General Public License for more details.\n"
3700 "You should have received a copy of the GNU General Public License\n"
3701 "along with FFmpeg; if not, write to the Free Software\n"
3702 "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n"
3706 "FFmpeg is free software; you can redistribute it and/or\n"
3707 "modify it under the terms of the GNU Lesser General Public\n"
3708 "License as published by the Free Software Foundation; either\n"
3709 "version 2.1 of the License, or (at your option) any later version.\n"
3711 "FFmpeg is distributed in the hope that it will be useful,\n"
3712 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3713 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
3714 "Lesser General Public License for more details.\n"
3716 "You should have received a copy of the GNU Lesser General Public\n"
3717 "License along with FFmpeg; if not, write to the Free Software\n"
3718 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
3724 static void show_help(void)
3727 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3728 "Hyper fast Audio and Video encoder\n");
3730 show_help_options(options, "Main options:\n",
3731 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3732 show_help_options(options, "\nVideo options:\n",
3733 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3735 show_help_options(options, "\nAdvanced Video options:\n",
3736 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3737 OPT_VIDEO | OPT_EXPERT);
3738 show_help_options(options, "\nAudio options:\n",
3739 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3741 show_help_options(options, "\nAdvanced Audio options:\n",
3742 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3743 OPT_AUDIO | OPT_EXPERT);
3744 show_help_options(options, "\nSubtitle options:\n",
3745 OPT_SUBTITLE | OPT_GRAB,
3747 show_help_options(options, "\nAudio/Video grab options:\n",
3750 show_help_options(options, "\nAdvanced options:\n",
3751 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3753 av_opt_show(avctx_opts, NULL);
3754 av_opt_show(avformat_opts, NULL);
3759 void parse_arg_file(const char *filename)
3761 opt_output_file(filename);
3764 int main(int argc, char **argv)
3771 avctx_opts= avcodec_alloc_context();
3772 avformat_opts = av_alloc_format_context();
3780 parse_options(argc, argv, options);
3782 /* file converter / grab */
3783 if (nb_output_files <= 0) {
3784 fprintf(stderr, "Must supply at least one output file\n");
3788 if (nb_input_files == 0) {
3789 fprintf(stderr, "Must supply at least one input file\n");
3794 av_encode(output_files, nb_output_files, input_files, nb_input_files,
3795 stream_maps, nb_stream_maps);
3796 ti = getutime() - ti;
3798 printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3802 for(i=0;i<nb_output_files;i++) {
3803 /* maybe av_close_output_file ??? */
3804 AVFormatContext *s = output_files[i];
3806 if (!(s->oformat->flags & AVFMT_NOFILE))
3808 for(j=0;j<s->nb_streams;j++) {
3809 av_free(s->streams[j]->codec);
3810 av_free(s->streams[j]);
3814 for(i=0;i<nb_input_files;i++)
3815 av_close_input_file(input_files[i]);
3820 av_free(intra_matrix);
3822 av_free(inter_matrix);
3824 #ifdef CONFIG_POWERPC_PERF
3825 extern void powerpc_display_perf_report(void);
3826 powerpc_display_perf_report();
3827 #endif /* CONFIG_POWERPC_PERF */
3829 if (received_sigterm) {
3831 "Received signal %d: terminating.\n",
3832 (int) received_sigterm);
3836 exit(0); /* not all OS-es handle main() return value */