3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
32 #include "framehook.h"
37 #if defined(HAVE_TERMIOS_H)
40 #include <sys/ioctl.h>
43 #include <sys/resource.h>
44 #elif defined(HAVE_CONIO_H)
47 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
56 #if !defined(INFINITY) && defined(HUGE_VAL)
57 #define INFINITY HUGE_VAL
62 /* select an input stream for an output stream */
63 typedef struct AVStreamMap {
67 int sync_stream_index;
70 /** select an input file for an output file */
71 typedef struct AVMetaDataMap {
76 extern const OptionDef options[];
78 static void show_help(void);
79 static void show_license(void);
80 static int opt_default(const char *opt, const char *arg);
84 static AVFormatContext *input_files[MAX_FILES];
85 static int64_t input_files_ts_offset[MAX_FILES];
86 static int nb_input_files = 0;
88 static AVFormatContext *output_files[MAX_FILES];
89 static int nb_output_files = 0;
91 static AVStreamMap stream_maps[MAX_FILES];
92 static int nb_stream_maps;
94 static AVMetaDataMap meta_data_maps[MAX_FILES];
95 static int nb_meta_data_maps;
97 static AVInputFormat *file_iformat;
98 static AVOutputFormat *file_oformat;
99 static int frame_width = 0;
100 static int frame_height = 0;
101 static float frame_aspect_ratio = 0;
102 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
103 static int frame_padtop = 0;
104 static int frame_padbottom = 0;
105 static int frame_padleft = 0;
106 static int frame_padright = 0;
107 static int padcolor[3] = {16,128,128}; /* default to black */
108 static int frame_topBand = 0;
109 static int frame_bottomBand = 0;
110 static int frame_leftBand = 0;
111 static int frame_rightBand = 0;
112 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
113 static AVRational frame_rate = (AVRational) {25,1};
114 static float video_qscale = 0;
115 static int video_qdiff = 3;
116 static uint16_t *intra_matrix = NULL;
117 static uint16_t *inter_matrix = NULL;
118 #if 0 //experimental, (can be removed)
119 static float video_rc_qsquish=1.0;
120 static float video_rc_qmod_amp=0;
121 static int video_rc_qmod_freq=0;
123 static char *video_rc_override_string=NULL;
124 static char *video_rc_eq="tex^qComp";
125 static int video_disable = 0;
126 static int video_discard = 0;
127 static int video_codec_id = CODEC_ID_NONE;
128 static int video_codec_tag = 0;
129 static int same_quality = 0;
130 static int do_deinterlace = 0;
131 static int strict = 0;
132 static int top_field_first = -1;
133 static int me_threshold = 0;
134 static int intra_dc_precision = 8;
135 static int loop_input = 0;
136 static int loop_output = AVFMT_NOOUTPUTLOOP;
137 static int qp_hist = 0;
139 static int intra_only = 0;
140 static int audio_sample_rate = 44100;
141 #define QSCALE_NONE -99999
142 static float audio_qscale = QSCALE_NONE;
143 static int audio_disable = 0;
144 static int audio_channels = 1;
145 static int audio_codec_id = CODEC_ID_NONE;
146 static int audio_codec_tag = 0;
147 static char *audio_language = NULL;
149 static int subtitle_codec_id = CODEC_ID_NONE;
150 static char *subtitle_language = NULL;
152 static float mux_preload= 0.5;
153 static float mux_max_delay= 0.7;
155 static int64_t recording_time = 0;
156 static int64_t start_time = 0;
157 static int64_t rec_timestamp = 0;
158 static int64_t input_ts_offset = 0;
159 static int file_overwrite = 0;
160 static char *str_title = NULL;
161 static char *str_author = NULL;
162 static char *str_copyright = NULL;
163 static char *str_comment = NULL;
164 static char *str_album = NULL;
165 static int do_benchmark = 0;
166 static int do_hex_dump = 0;
167 static int do_pkt_dump = 0;
168 static int do_psnr = 0;
169 static int do_pass = 0;
170 static char *pass_logfilename = NULL;
171 static int audio_stream_copy = 0;
172 static int video_stream_copy = 0;
173 static int subtitle_stream_copy = 0;
174 static int video_sync_method= 1;
175 static int audio_sync_method= 0;
176 static int copy_ts= 0;
177 static int opt_shortest = 0; //
178 static int video_global_header = 0;
179 static char *vstats_filename;
180 static FILE *fvstats;
182 static int rate_emu = 0;
184 static int video_channel = 0;
185 static char *video_standard;
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 uint64_t 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 static const char **opt_names;
208 static int opt_name_count;
209 static AVCodecContext *avctx_opts[CODEC_TYPE_NB];
210 static AVFormatContext *avformat_opts;
211 static struct SwsContext *sws_opts;
212 static int64_t timer_start;
214 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
215 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
216 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
218 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
220 struct AVInputStream;
222 typedef struct AVOutputStream {
223 int file_index; /* file index */
224 int index; /* stream index in the output file */
225 int source_index; /* AVInputStream index */
226 AVStream *st; /* stream in the output file */
227 int encoding_needed; /* true if encoding needed for this stream */
229 /* input pts and corresponding output pts
231 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
232 struct AVInputStream *sync_ist; /* input stream to sync against */
233 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
236 AVFrame pict_tmp; /* temporary image for resampling */
237 struct SwsContext *img_resample_ctx; /* for image resampling */
241 int topBand; /* cropping area sizes */
245 int padtop; /* padding area sizes */
252 ReSampleContext *resample; /* for audio resampling */
253 AVFifoBuffer fifo; /* for compression: one audio fifo per codec */
257 typedef struct AVInputStream {
261 int discard; /* true if stream data should be discarded */
262 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
263 int64_t sample_index; /* current sample */
265 int64_t start; /* time when read started */
266 unsigned long frame; /* current frame */
267 int64_t next_pts; /* synthetic pts for cases where pkt.pts
269 int64_t pts; /* current pts */
270 int is_start; /* is 1 at the start and after a discontinuity */
273 typedef struct AVInputFile {
274 int eof_reached; /* true if eof reached */
275 int ist_index; /* index of first stream in ist_table */
276 int buffer_size; /* current total buffer size */
277 int nb_streams; /* nb streams we are aware of */
280 #ifdef HAVE_TERMIOS_H
282 /* init terminal so that we can grab keys */
283 static struct termios oldtty;
286 static void term_exit(void)
288 #ifdef HAVE_TERMIOS_H
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)
304 #ifdef HAVE_TERMIOS_H
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)
337 #if defined(HAVE_TERMIOS_H)
340 #ifndef CONFIG_BEOS_NETSERVER
348 n = select(1, &rfds, NULL, NULL, &tv);
357 #elif defined(HAVE_CONIO_H)
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= av_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 av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
606 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,
607 1000000 * ist->pts / AV_TIME_BASE);
609 if (picture != picture2)
610 *picture = *picture2;
614 /* we begin to correct av delay at this threshold */
615 #define AV_DELAY_MAX 0.100
617 static void do_subtitle_out(AVFormatContext *s,
623 static uint8_t *subtitle_out = NULL;
624 int subtitle_out_max_size = 65536;
625 int subtitle_out_size, nb, i;
629 if (pts == AV_NOPTS_VALUE) {
630 fprintf(stderr, "Subtitle packets must have a pts\n");
634 enc = ost->st->codec;
637 subtitle_out = av_malloc(subtitle_out_max_size);
640 /* Note: DVB subtitle need one packet to draw them and one other
641 packet to clear them */
642 /* XXX: signal it in the codec context ? */
643 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
648 for(i = 0; i < nb; i++) {
649 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
650 subtitle_out_max_size, sub);
652 av_init_packet(&pkt);
653 pkt.stream_index = ost->index;
654 pkt.data = subtitle_out;
655 pkt.size = subtitle_out_size;
656 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);
657 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
658 /* XXX: the pts correction is handled here. Maybe handling
659 it in the codec would be better */
661 pkt.pts += 90 * sub->start_display_time;
663 pkt.pts += 90 * sub->end_display_time;
665 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
669 static int bit_buffer_size= 1024*256;
670 static uint8_t *bit_buffer= NULL;
672 static void do_video_out(AVFormatContext *s,
678 int nb_frames, i, ret;
679 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
680 AVFrame picture_crop_temp, picture_pad_temp;
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 (av_picture_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 (av_picture_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 av_picture_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[CODEC_TYPE_VIDEO]->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);
838 static double psnr(double d){
839 if(d==0) return INFINITY;
840 return -10.0*log(d)/log(10.0);
843 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
849 double ti1, bitrate, avg_bitrate;
851 /* this is executed just the first time do_video_stats is called */
853 fvstats = fopen(vstats_filename, "w");
861 enc = ost->st->codec;
862 if (enc->codec_type == CODEC_TYPE_VIDEO) {
863 frame_number = ost->frame_number;
864 fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
865 if (enc->flags&CODEC_FLAG_PSNR)
866 fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
868 fprintf(fvstats,"f_size= %6d ", frame_size);
869 /* compute pts value */
870 ti1 = ost->sync_opts * av_q2d(enc->time_base);
874 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
875 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
876 fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
877 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
878 fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
882 static void print_report(AVFormatContext **output_files,
883 AVOutputStream **ost_table, int nb_ostreams,
888 AVFormatContext *oc, *os;
891 int frame_number, vid, i;
892 double bitrate, ti1, pts;
893 static int64_t last_time = -1;
894 static int qp_histogram[52];
896 if (!is_last_report) {
898 /* display the report every 0.5 seconds */
899 cur_time = av_gettime();
900 if (last_time == -1) {
901 last_time = cur_time;
904 if ((cur_time - last_time) < 500000)
906 last_time = cur_time;
910 oc = output_files[0];
912 total_size = url_fsize(&oc->pb);
913 if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
914 total_size= url_ftell(&oc->pb);
919 for(i=0;i<nb_ostreams;i++) {
921 os = output_files[ost->file_index];
922 enc = ost->st->codec;
923 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
924 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
925 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
927 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
928 float t = (av_gettime()-timer_start) / 1000000.0;
930 frame_number = ost->frame_number;
931 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
932 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
933 enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
935 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
936 if(qp_hist && enc->coded_frame){
938 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
939 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
942 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
944 if (enc->flags&CODEC_FLAG_PSNR){
946 double error, error_sum=0;
947 double scale, scale_sum=0;
948 char type[3]= {'Y','U','V'};
949 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
952 error= enc->error[j];
953 scale= enc->width*enc->height*255.0*255.0*frame_number;
955 error= enc->coded_frame->error[j];
956 scale= enc->width*enc->height*255.0*255.0;
961 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
963 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
967 /* compute min output value */
968 pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
969 if ((pts < ti1) && (pts > 0))
975 if (verbose || is_last_report) {
976 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
978 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
979 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
980 (double)total_size / 1024, ti1, bitrate);
983 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
984 nb_frames_dup, nb_frames_drop);
987 fprintf(stderr, "%s \r", buf);
992 if (is_last_report && verbose >= 0){
993 int64_t raw= audio_size + video_size + extra_size;
994 fprintf(stderr, "\n");
995 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
999 100.0*(total_size - raw)/raw
1004 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1005 static int output_packet(AVInputStream *ist, int ist_index,
1006 AVOutputStream **ost_table, int nb_ostreams,
1007 const AVPacket *pkt)
1009 AVFormatContext *os;
1010 AVOutputStream *ost;
1014 int data_size, got_picture;
1016 void *buffer_to_free;
1017 static unsigned int samples_size= 0;
1018 static short *samples= NULL;
1019 AVSubtitle subtitle, *subtitle_to_free;
1023 ist->pts= ist->next_pts; // needed for last packet if vsync=0
1024 } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1025 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1027 // assert(ist->pts == ist->next_pts);
1041 /* decode the packet if needed */
1042 data_buf = NULL; /* fail safe */
1044 subtitle_to_free = NULL;
1045 if (ist->decoding_needed) {
1046 switch(ist->st->codec->codec_type) {
1047 case CODEC_TYPE_AUDIO:{
1049 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE));
1050 data_size= samples_size;
1051 /* XXX: could avoid copy if PCM 16 bits with same
1052 endianness as CPU */
1053 ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1059 /* Some bug in mpeg audio decoder gives */
1060 /* data_size < 0, it seems they are overflows */
1061 if (data_size <= 0) {
1062 /* no audio frame */
1065 data_buf = (uint8_t *)samples;
1066 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1067 (ist->st->codec->sample_rate * ist->st->codec->channels);
1069 case CODEC_TYPE_VIDEO:
1070 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1071 /* XXX: allocate picture correctly */
1072 avcodec_get_frame_defaults(&picture);
1074 ret = avcodec_decode_video(ist->st->codec,
1075 &picture, &got_picture, ptr, len);
1076 ist->st->quality= picture.quality;
1080 /* no picture yet */
1081 goto discard_packet;
1083 if (ist->st->codec->time_base.num != 0) {
1084 ist->next_pts += ((int64_t)AV_TIME_BASE *
1085 ist->st->codec->time_base.num) /
1086 ist->st->codec->time_base.den;
1090 case CODEC_TYPE_SUBTITLE:
1091 ret = avcodec_decode_subtitle(ist->st->codec,
1092 &subtitle, &got_subtitle, ptr, len);
1095 if (!got_subtitle) {
1096 goto discard_packet;
1098 subtitle_to_free = &subtitle;
1105 switch(ist->st->codec->codec_type) {
1106 case CODEC_TYPE_AUDIO:
1107 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1108 (ist->st->codec->sample_rate * ist->st->codec->channels);
1110 case CODEC_TYPE_VIDEO:
1111 if (ist->st->codec->time_base.num != 0) {
1112 ist->next_pts += ((int64_t)AV_TIME_BASE *
1113 ist->st->codec->time_base.num) /
1114 ist->st->codec->time_base.den;
1124 buffer_to_free = NULL;
1125 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1126 pre_process_video_frame(ist, (AVPicture *)&picture,
1130 // preprocess audio (volume)
1131 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1132 if (audio_volume != 256) {
1135 for(i=0;i<(data_size / sizeof(short));i++) {
1136 int v = ((*volp) * audio_volume + 128) >> 8;
1137 if (v < -32768) v = -32768;
1138 if (v > 32767) v = 32767;
1144 /* frame rate emulation */
1145 if (ist->st->codec->rate_emu) {
1146 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1147 int64_t now = av_gettime() - ist->start;
1155 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1156 is the one of the next displayed one */
1157 /* XXX: add mpeg4 too ? */
1158 if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1159 if (ist->st->codec->pict_type != B_TYPE) {
1161 tmp = ist->last_ip_pts;
1162 ist->last_ip_pts = ist->frac_pts.val;
1163 ist->frac_pts.val = tmp;
1167 /* if output time reached then transcode raw format,
1168 encode packets and output them */
1169 if (start_time == 0 || ist->pts >= start_time)
1170 for(i=0;i<nb_ostreams;i++) {
1174 if (ost->source_index == ist_index) {
1175 os = output_files[ost->file_index];
1178 printf("%d: got pts=%0.3f %0.3f\n", i,
1179 (double)pkt->pts / AV_TIME_BASE,
1180 ((double)ist->pts / AV_TIME_BASE) -
1181 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1183 /* set the input output pts pairs */
1184 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1186 if (ost->encoding_needed) {
1187 switch(ost->st->codec->codec_type) {
1188 case CODEC_TYPE_AUDIO:
1189 do_audio_out(os, ost, ist, data_buf, data_size);
1191 case CODEC_TYPE_VIDEO:
1192 do_video_out(os, ost, ist, &picture, &frame_size);
1193 video_size += frame_size;
1194 if (vstats_filename && frame_size)
1195 do_video_stats(os, ost, frame_size);
1197 case CODEC_TYPE_SUBTITLE:
1198 do_subtitle_out(os, ost, ist, &subtitle,
1205 AVFrame avframe; //FIXME/XXX remove this
1207 av_init_packet(&opkt);
1209 /* no reencoding needed : output the packet directly */
1210 /* force the input stream PTS */
1212 avcodec_get_frame_defaults(&avframe);
1213 ost->st->codec->coded_frame= &avframe;
1214 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1216 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1217 audio_size += data_size;
1218 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1219 video_size += data_size;
1223 opkt.stream_index= ost->index;
1224 if(pkt->pts != AV_NOPTS_VALUE)
1225 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);
1227 opkt.pts= AV_NOPTS_VALUE;
1231 if (pkt->dts == AV_NOPTS_VALUE)
1232 dts = ist->next_pts;
1234 dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1235 opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
1237 opkt.flags= pkt->flags;
1239 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1240 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1241 opkt.destruct= av_destruct_packet;
1243 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
1244 ost->st->codec->frame_number++;
1245 ost->frame_number++;
1246 av_free_packet(&opkt);
1250 av_free(buffer_to_free);
1251 /* XXX: allocate the subtitles in the codec ? */
1252 if (subtitle_to_free) {
1253 if (subtitle_to_free->rects != NULL) {
1254 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1255 av_free(subtitle_to_free->rects[i].bitmap);
1256 av_free(subtitle_to_free->rects[i].rgba_palette);
1258 av_freep(&subtitle_to_free->rects);
1260 subtitle_to_free->num_rects = 0;
1261 subtitle_to_free = NULL;
1268 for(i=0;i<nb_ostreams;i++) {
1270 if (ost->source_index == ist_index) {
1271 AVCodecContext *enc= ost->st->codec;
1272 os = output_files[ost->file_index];
1274 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1276 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1279 if (ost->encoding_needed) {
1283 av_init_packet(&pkt);
1284 pkt.stream_index= ost->index;
1286 switch(ost->st->codec->codec_type) {
1287 case CODEC_TYPE_AUDIO:
1288 fifo_bytes = av_fifo_size(&ost->fifo);
1290 /* encode any samples remaining in fifo */
1291 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1292 int fs_tmp = enc->frame_size;
1293 enc->frame_size = fifo_bytes / (2 * enc->channels);
1294 if(av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes) == 0) {
1295 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1297 enc->frame_size = fs_tmp;
1300 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1303 pkt.flags |= PKT_FLAG_KEY;
1305 case CODEC_TYPE_VIDEO:
1306 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1308 if(enc->coded_frame && enc->coded_frame->key_frame)
1309 pkt.flags |= PKT_FLAG_KEY;
1310 if (ost->logfile && enc->stats_out) {
1311 fprintf(ost->logfile, "%s", enc->stats_out);
1320 pkt.data= bit_buffer;
1322 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1323 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1324 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1338 * The following code is the main loop of the file converter
1340 static int av_encode(AVFormatContext **output_files,
1341 int nb_output_files,
1342 AVFormatContext **input_files,
1344 AVStreamMap *stream_maps, int nb_stream_maps)
1346 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1347 AVFormatContext *is, *os;
1348 AVCodecContext *codec, *icodec;
1349 AVOutputStream *ost, **ost_table = NULL;
1350 AVInputStream *ist, **ist_table = NULL;
1351 AVInputFile *file_table;
1354 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1358 /* input stream init */
1360 for(i=0;i<nb_input_files;i++) {
1361 is = input_files[i];
1362 file_table[i].ist_index = j;
1363 file_table[i].nb_streams = is->nb_streams;
1364 j += is->nb_streams;
1368 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1372 for(i=0;i<nb_istreams;i++) {
1373 ist = av_mallocz(sizeof(AVInputStream));
1379 for(i=0;i<nb_input_files;i++) {
1380 is = input_files[i];
1381 for(k=0;k<is->nb_streams;k++) {
1382 ist = ist_table[j++];
1383 ist->st = is->streams[k];
1384 ist->file_index = i;
1386 ist->discard = 1; /* the stream is discarded by default
1389 if (ist->st->codec->rate_emu) {
1390 ist->start = av_gettime();
1396 /* output stream init */
1398 for(i=0;i<nb_output_files;i++) {
1399 os = output_files[i];
1400 if (!os->nb_streams) {
1401 fprintf(stderr, "Output file does not contain any stream\n");
1404 nb_ostreams += os->nb_streams;
1406 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1407 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1411 /* Sanity check the mapping args -- do the input files & streams exist? */
1412 for(i=0;i<nb_stream_maps;i++) {
1413 int fi = stream_maps[i].file_index;
1414 int si = stream_maps[i].stream_index;
1416 if (fi < 0 || fi > nb_input_files - 1 ||
1417 si < 0 || si > file_table[fi].nb_streams - 1) {
1418 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1421 fi = stream_maps[i].sync_file_index;
1422 si = stream_maps[i].sync_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 sync stream #%d.%d\n", fi, si);
1430 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1433 for(i=0;i<nb_ostreams;i++) {
1434 ost = av_mallocz(sizeof(AVOutputStream));
1441 for(k=0;k<nb_output_files;k++) {
1442 os = output_files[k];
1443 for(i=0;i<os->nb_streams;i++) {
1445 ost = ost_table[n++];
1446 ost->file_index = k;
1448 ost->st = os->streams[i];
1449 if (nb_stream_maps > 0) {
1450 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1451 stream_maps[n-1].stream_index;
1453 /* Sanity check that the stream types match */
1454 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1455 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1456 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1457 ost->file_index, ost->index);
1462 /* get corresponding input stream index : we select the first one with the right type */
1464 for(j=0;j<nb_istreams;j++) {
1467 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1468 ost->source_index = j;
1475 /* try again and reuse existing stream */
1476 for(j=0;j<nb_istreams;j++) {
1478 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1479 ost->source_index = j;
1484 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1485 ost->file_index, ost->index);
1490 ist = ist_table[ost->source_index];
1492 ost->sync_ist = (nb_stream_maps > 0) ?
1493 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1494 stream_maps[n-1].sync_stream_index] : ist;
1498 /* for each output stream, we compute the right encoding parameters */
1499 for(i=0;i<nb_ostreams;i++) {
1501 ist = ist_table[ost->source_index];
1503 codec = ost->st->codec;
1504 icodec = ist->st->codec;
1506 if (ost->st->stream_copy) {
1507 /* if stream_copy is selected, no need to decode or encode */
1508 codec->codec_id = icodec->codec_id;
1509 codec->codec_type = icodec->codec_type;
1510 if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1511 codec->bit_rate = icodec->bit_rate;
1512 codec->extradata= icodec->extradata;
1513 codec->extradata_size= icodec->extradata_size;
1514 if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1515 codec->time_base = icodec->time_base;
1517 codec->time_base = ist->st->time_base;
1518 switch(codec->codec_type) {
1519 case CODEC_TYPE_AUDIO:
1520 codec->sample_rate = icodec->sample_rate;
1521 codec->channels = icodec->channels;
1522 codec->frame_size = icodec->frame_size;
1523 codec->block_align= icodec->block_align;
1525 case CODEC_TYPE_VIDEO:
1527 fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1530 codec->pix_fmt = icodec->pix_fmt;
1531 codec->width = icodec->width;
1532 codec->height = icodec->height;
1533 codec->has_b_frames = icodec->has_b_frames;
1535 case CODEC_TYPE_SUBTITLE:
1541 switch(codec->codec_type) {
1542 case CODEC_TYPE_AUDIO:
1543 if (av_fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1546 if (codec->channels == icodec->channels &&
1547 codec->sample_rate == icodec->sample_rate) {
1548 ost->audio_resample = 0;
1550 if (codec->channels != icodec->channels &&
1551 (icodec->codec_id == CODEC_ID_AC3 ||
1552 icodec->codec_id == CODEC_ID_DTS)) {
1553 /* Special case for 5:1 AC3 and DTS input */
1554 /* and mono or stereo output */
1555 /* Request specific number of channels */
1556 icodec->channels = codec->channels;
1557 if (codec->sample_rate == icodec->sample_rate)
1558 ost->audio_resample = 0;
1560 ost->audio_resample = 1;
1563 ost->audio_resample = 1;
1566 if(audio_sync_method>1)
1567 ost->audio_resample = 1;
1569 if(ost->audio_resample){
1570 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1571 codec->sample_rate, icodec->sample_rate);
1573 printf("Can't resample. Aborting.\n");
1577 ist->decoding_needed = 1;
1578 ost->encoding_needed = 1;
1580 case CODEC_TYPE_VIDEO:
1581 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1582 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1583 ost->video_resample = ((codec->width != icodec->width -
1584 (frame_leftBand + frame_rightBand) +
1585 (frame_padleft + frame_padright)) ||
1586 (codec->height != icodec->height -
1587 (frame_topBand + frame_bottomBand) +
1588 (frame_padtop + frame_padbottom)) ||
1589 (codec->pix_fmt != icodec->pix_fmt));
1590 if (ost->video_crop) {
1591 ost->topBand = frame_topBand;
1592 ost->leftBand = frame_leftBand;
1594 if (ost->video_pad) {
1595 ost->padtop = frame_padtop;
1596 ost->padleft = frame_padleft;
1597 ost->padbottom = frame_padbottom;
1598 ost->padright = frame_padright;
1599 if (!ost->video_resample) {
1600 avcodec_get_frame_defaults(&ost->pict_tmp);
1601 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1602 codec->width, codec->height ) )
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 ) ) {
1610 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1613 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1614 ost->img_resample_ctx = sws_getContext(
1615 icodec->width - (frame_leftBand + frame_rightBand),
1616 icodec->height - (frame_topBand + frame_bottomBand),
1618 codec->width - (frame_padleft + frame_padright),
1619 codec->height - (frame_padtop + frame_padbottom),
1621 sws_flags, NULL, NULL, NULL);
1622 if (ost->img_resample_ctx == NULL) {
1623 fprintf(stderr, "Cannot get resampling context\n");
1626 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1628 ost->encoding_needed = 1;
1629 ist->decoding_needed = 1;
1631 case CODEC_TYPE_SUBTITLE:
1632 ost->encoding_needed = 1;
1633 ist->decoding_needed = 1;
1640 if (ost->encoding_needed &&
1641 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1642 char logfilename[1024];
1647 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1649 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1650 if (codec->flags & CODEC_FLAG_PASS1) {
1651 f = fopen(logfilename, "w");
1653 perror(logfilename);
1658 /* read the log file */
1659 f = fopen(logfilename, "r");
1661 perror(logfilename);
1664 fseek(f, 0, SEEK_END);
1666 fseek(f, 0, SEEK_SET);
1667 logbuffer = av_malloc(size + 1);
1669 fprintf(stderr, "Could not allocate log buffer\n");
1672 size = fread(logbuffer, 1, size, f);
1674 logbuffer[size] = '\0';
1675 codec->stats_in = logbuffer;
1679 if(codec->codec_type == CODEC_TYPE_VIDEO){
1680 int size= codec->width * codec->height;
1681 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1686 bit_buffer = av_malloc(bit_buffer_size);
1690 /* dump the file output parameters - cannot be done before in case
1692 for(i=0;i<nb_output_files;i++) {
1693 dump_format(output_files[i], i, output_files[i]->filename, 1);
1696 /* dump the stream mapping */
1698 fprintf(stderr, "Stream mapping:\n");
1699 for(i=0;i<nb_ostreams;i++) {
1701 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1702 ist_table[ost->source_index]->file_index,
1703 ist_table[ost->source_index]->index,
1706 if (ost->sync_ist != ist_table[ost->source_index])
1707 fprintf(stderr, " [sync #%d.%d]",
1708 ost->sync_ist->file_index,
1709 ost->sync_ist->index);
1710 fprintf(stderr, "\n");
1714 /* open each encoder */
1715 for(i=0;i<nb_ostreams;i++) {
1717 if (ost->encoding_needed) {
1719 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1721 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1722 ost->file_index, ost->index);
1725 if (avcodec_open(ost->st->codec, codec) < 0) {
1726 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1727 ost->file_index, ost->index);
1730 extra_size += ost->st->codec->extradata_size;
1734 /* open each decoder */
1735 for(i=0;i<nb_istreams;i++) {
1737 if (ist->decoding_needed) {
1739 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1741 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1742 ist->st->codec->codec_id, ist->file_index, ist->index);
1745 if (avcodec_open(ist->st->codec, codec) < 0) {
1746 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1747 ist->file_index, ist->index);
1750 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1751 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1756 for(i=0;i<nb_istreams;i++) {
1758 is = input_files[ist->file_index];
1760 ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1761 if(ist->st->start_time == AV_NOPTS_VALUE)
1763 if(input_files_ts_offset[ist->file_index])
1764 ist->next_pts= AV_NOPTS_VALUE;
1768 /* set meta data information from input file if required */
1769 for (i=0;i<nb_meta_data_maps;i++) {
1770 AVFormatContext *out_file;
1771 AVFormatContext *in_file;
1773 int out_file_index = meta_data_maps[i].out_file;
1774 int in_file_index = meta_data_maps[i].in_file;
1775 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1776 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1777 ret = AVERROR(EINVAL);
1780 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1781 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1782 ret = AVERROR(EINVAL);
1786 out_file = output_files[out_file_index];
1787 in_file = input_files[in_file_index];
1789 strcpy(out_file->title, in_file->title);
1790 strcpy(out_file->author, in_file->author);
1791 strcpy(out_file->copyright, in_file->copyright);
1792 strcpy(out_file->comment, in_file->comment);
1793 strcpy(out_file->album, in_file->album);
1794 out_file->year = in_file->year;
1795 out_file->track = in_file->track;
1796 strcpy(out_file->genre, in_file->genre);
1799 /* open files and write file headers */
1800 for(i=0;i<nb_output_files;i++) {
1801 os = output_files[i];
1802 if (av_write_header(os) < 0) {
1803 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1804 ret = AVERROR(EINVAL);
1809 if ( !using_stdin && verbose >= 0) {
1810 fprintf(stderr, "Press [q] to stop encoding\n");
1811 url_set_interrupt_cb(decode_interrupt_cb);
1816 timer_start = av_gettime();
1818 for(; received_sigterm == 0;) {
1819 int file_index, ist_index;
1827 /* if 'q' pressed, exits */
1831 /* read_key() returns 0 on EOF */
1837 /* select the stream that we must read now by looking at the
1838 smallest output pts */
1840 for(i=0;i<nb_ostreams;i++) {
1843 os = output_files[ost->file_index];
1844 ist = ist_table[ost->source_index];
1845 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1846 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1848 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1849 ipts = (double)ist->pts;
1850 if (!file_table[ist->file_index].eof_reached){
1851 if(ipts < ipts_min) {
1853 if(input_sync ) file_index = ist->file_index;
1855 if(opts < opts_min) {
1857 if(!input_sync) file_index = ist->file_index;
1860 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1865 /* if none, if is finished */
1866 if (file_index < 0) {
1870 /* finish if recording time exhausted */
1871 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1874 /* finish if limit size exhausted */
1875 if (limit_filesize != 0 && limit_filesize < url_ftell(&output_files[0]->pb))
1878 /* read a frame from it and output it in the fifo */
1879 is = input_files[file_index];
1880 if (av_read_frame(is, &pkt) < 0) {
1881 file_table[file_index].eof_reached = 1;
1882 if (opt_shortest) break; else continue; //
1886 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
1888 /* the following test is needed in case new streams appear
1889 dynamically in stream : we ignore them */
1890 if (pkt.stream_index >= file_table[file_index].nb_streams)
1891 goto discard_packet;
1892 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1893 ist = ist_table[ist_index];
1895 goto discard_packet;
1897 // 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);
1898 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1899 int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
1900 if(FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
1901 input_files_ts_offset[ist->file_index]-= delta;
1903 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1904 for(i=0; i<file_table[file_index].nb_streams; i++){
1905 int index= file_table[file_index].ist_index + i;
1906 ist_table[index]->next_pts += delta;
1907 ist_table[index]->is_start=1;
1912 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1913 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1916 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1917 ist->file_index, ist->index);
1919 av_free_packet(&pkt);
1924 av_free_packet(&pkt);
1926 /* dump report by using the output first video and audio streams */
1927 print_report(output_files, ost_table, nb_ostreams, 0);
1930 /* at the end of stream, we must flush the decoder buffers */
1931 for(i=0;i<nb_istreams;i++) {
1933 if (ist->decoding_needed) {
1934 output_packet(ist, i, ost_table, nb_ostreams, NULL);
1940 /* write the trailer if needed and close file */
1941 for(i=0;i<nb_output_files;i++) {
1942 os = output_files[i];
1943 av_write_trailer(os);
1946 /* dump report by using the first video and audio streams */
1947 print_report(output_files, ost_table, nb_ostreams, 1);
1949 /* close each encoder */
1950 for(i=0;i<nb_ostreams;i++) {
1952 if (ost->encoding_needed) {
1953 av_freep(&ost->st->codec->stats_in);
1954 avcodec_close(ost->st->codec);
1958 /* close each decoder */
1959 for(i=0;i<nb_istreams;i++) {
1961 if (ist->decoding_needed) {
1962 avcodec_close(ist->st->codec);
1970 av_freep(&bit_buffer);
1971 av_free(file_table);
1974 for(i=0;i<nb_istreams;i++) {
1981 for(i=0;i<nb_ostreams;i++) {
1985 fclose(ost->logfile);
1986 ost->logfile = NULL;
1988 av_fifo_free(&ost->fifo); /* works even if fifo is not
1989 initialized but set to zero */
1990 av_free(ost->pict_tmp.data[0]);
1991 if (ost->video_resample)
1992 sws_freeContext(ost->img_resample_ctx);
1993 if (ost->audio_resample)
1994 audio_resample_close(ost->resample);
2002 ret = AVERROR(ENOMEM);
2007 int file_read(const char *filename)
2010 unsigned char buffer[1024];
2013 if (url_open(&h, filename, O_RDONLY) < 0) {
2014 printf("could not open '%s'\n", filename);
2018 len = url_read(h, buffer, sizeof(buffer));
2021 for(i=0;i<len;i++) putchar(buffer[i]);
2028 static void opt_format(const char *arg)
2030 /* compatibility stuff for pgmyuv */
2031 if (!strcmp(arg, "pgmyuv")) {
2032 pgmyuv_compatibility_hack=1;
2033 // opt_image_format(arg);
2035 fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2038 file_iformat = av_find_input_format(arg);
2039 file_oformat = guess_format(arg, NULL, NULL);
2040 if (!file_iformat && !file_oformat) {
2041 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2046 static void opt_video_rc_eq(char *arg)
2051 static void opt_video_rc_override_string(char *arg)
2053 video_rc_override_string = arg;
2056 static void opt_me_threshold(const char *arg)
2058 me_threshold = atoi(arg);
2061 static void opt_verbose(const char *arg)
2063 verbose = atoi(arg);
2064 av_log_level = atoi(arg);
2067 static void opt_frame_rate(const char *arg)
2069 if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2070 fprintf(stderr, "Incorrect frame rate\n");
2075 static void opt_frame_crop_top(const char *arg)
2077 frame_topBand = atoi(arg);
2078 if (frame_topBand < 0) {
2079 fprintf(stderr, "Incorrect top crop size\n");
2082 if ((frame_topBand % 2) != 0) {
2083 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2086 if ((frame_topBand) >= frame_height){
2087 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2090 frame_height -= frame_topBand;
2093 static void opt_frame_crop_bottom(const char *arg)
2095 frame_bottomBand = atoi(arg);
2096 if (frame_bottomBand < 0) {
2097 fprintf(stderr, "Incorrect bottom crop size\n");
2100 if ((frame_bottomBand % 2) != 0) {
2101 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2104 if ((frame_bottomBand) >= frame_height){
2105 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2108 frame_height -= frame_bottomBand;
2111 static void opt_frame_crop_left(const char *arg)
2113 frame_leftBand = atoi(arg);
2114 if (frame_leftBand < 0) {
2115 fprintf(stderr, "Incorrect left crop size\n");
2118 if ((frame_leftBand % 2) != 0) {
2119 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2122 if ((frame_leftBand) >= frame_width){
2123 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2126 frame_width -= frame_leftBand;
2129 static void opt_frame_crop_right(const char *arg)
2131 frame_rightBand = atoi(arg);
2132 if (frame_rightBand < 0) {
2133 fprintf(stderr, "Incorrect right crop size\n");
2136 if ((frame_rightBand % 2) != 0) {
2137 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2140 if ((frame_rightBand) >= frame_width){
2141 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2144 frame_width -= frame_rightBand;
2147 static void opt_frame_size(const char *arg)
2149 if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2150 fprintf(stderr, "Incorrect frame size\n");
2153 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2154 fprintf(stderr, "Frame size must be a multiple of 2\n");
2160 #define SCALEBITS 10
2161 #define ONE_HALF (1 << (SCALEBITS - 1))
2162 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2164 #define RGB_TO_Y(r, g, b) \
2165 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2166 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2168 #define RGB_TO_U(r1, g1, b1, shift)\
2169 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2170 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2172 #define RGB_TO_V(r1, g1, b1, shift)\
2173 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2174 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2176 static void opt_pad_color(const char *arg) {
2177 /* Input is expected to be six hex digits similar to
2178 how colors are expressed in html tags (but without the #) */
2179 int rgb = strtol(arg, NULL, 16);
2183 g = ((rgb >> 8) & 255);
2186 padcolor[0] = RGB_TO_Y(r,g,b);
2187 padcolor[1] = RGB_TO_U(r,g,b,0);
2188 padcolor[2] = RGB_TO_V(r,g,b,0);
2191 static void opt_frame_pad_top(const char *arg)
2193 frame_padtop = atoi(arg);
2194 if (frame_padtop < 0) {
2195 fprintf(stderr, "Incorrect top pad size\n");
2198 if ((frame_padtop % 2) != 0) {
2199 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2204 static void opt_frame_pad_bottom(const char *arg)
2206 frame_padbottom = atoi(arg);
2207 if (frame_padbottom < 0) {
2208 fprintf(stderr, "Incorrect bottom pad size\n");
2211 if ((frame_padbottom % 2) != 0) {
2212 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2218 static void opt_frame_pad_left(const char *arg)
2220 frame_padleft = atoi(arg);
2221 if (frame_padleft < 0) {
2222 fprintf(stderr, "Incorrect left pad size\n");
2225 if ((frame_padleft % 2) != 0) {
2226 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2232 static void opt_frame_pad_right(const char *arg)
2234 frame_padright = atoi(arg);
2235 if (frame_padright < 0) {
2236 fprintf(stderr, "Incorrect right pad size\n");
2239 if ((frame_padright % 2) != 0) {
2240 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2245 void list_pix_fmts(void)
2248 char pix_fmt_str[128];
2249 for (i=-1; i < PIX_FMT_NB; i++) {
2250 avcodec_pix_fmt_string (pix_fmt_str, sizeof(pix_fmt_str), i);
2251 fprintf(stdout, "%s\n", pix_fmt_str);
2255 static void opt_frame_pix_fmt(const char *arg)
2257 if (strcmp(arg, "list"))
2258 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_strict(const char *arg)
2313 static void opt_top_field_first(const char *arg)
2315 top_field_first= atoi(arg);
2318 static void opt_thread_count(const char *arg)
2320 thread_count= atoi(arg);
2321 #if !defined(HAVE_THREADS)
2323 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2327 static void opt_audio_rate(const char *arg)
2329 audio_sample_rate = atoi(arg);
2332 static void opt_audio_channels(const char *arg)
2334 audio_channels = atoi(arg);
2337 static void opt_video_channel(const char *arg)
2339 video_channel = strtol(arg, NULL, 0);
2342 static void opt_video_standard(const char *arg)
2344 video_standard = av_strdup(arg);
2347 static void opt_codec(int *pstream_copy, int *pcodec_id,
2348 int codec_type, const char *arg)
2352 if (!strcmp(arg, "copy")) {
2357 if (!strcmp(p->name, arg) && p->type == codec_type)
2362 fprintf(stderr, "Unknown codec '%s'\n", arg);
2370 static void opt_audio_codec(const char *arg)
2372 opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2375 static void opt_audio_tag(const char *arg)
2378 audio_codec_tag= strtol(arg, &tail, 0);
2381 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2384 static void opt_video_tag(const char *arg)
2387 video_codec_tag= strtol(arg, &tail, 0);
2390 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2393 static void add_frame_hooker(const char *arg)
2398 char *args = av_strdup(arg);
2402 argv[0] = strtok(args, " ");
2403 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2406 i = frame_hook_add(argc, argv);
2409 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2414 static void opt_video_codec(const char *arg)
2416 opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2419 static void opt_subtitle_codec(const char *arg)
2421 opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2424 static void opt_map(const char *arg)
2430 m = &stream_maps[nb_stream_maps++];
2432 m->file_index = strtol(arg, (char **)&p, 0);
2436 m->stream_index = strtol(p, (char **)&p, 0);
2439 m->sync_file_index = strtol(p, (char **)&p, 0);
2442 m->sync_stream_index = strtol(p, (char **)&p, 0);
2444 m->sync_file_index = m->file_index;
2445 m->sync_stream_index = m->stream_index;
2449 static void opt_map_meta_data(const char *arg)
2455 m = &meta_data_maps[nb_meta_data_maps++];
2457 m->out_file = strtol(arg, (char **)&p, 0);
2461 m->in_file = strtol(p, (char **)&p, 0);
2464 static void opt_recording_time(const char *arg)
2466 recording_time = parse_date(arg, 1);
2469 static void opt_start_time(const char *arg)
2471 start_time = parse_date(arg, 1);
2474 static void opt_rec_timestamp(const char *arg)
2476 rec_timestamp = parse_date(arg, 0) / 1000000;
2479 static void opt_input_ts_offset(const char *arg)
2481 input_ts_offset = parse_date(arg, 1);
2484 static void opt_input_file(const char *filename)
2486 AVFormatContext *ic;
2487 AVFormatParameters params, *ap = ¶ms;
2488 int err, i, ret, rfps, rfps_base;
2491 if (!strcmp(filename, "-"))
2494 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2495 !strcmp( filename, "/dev/stdin" );
2497 /* get default parameters from command line */
2498 ic = av_alloc_format_context();
2500 memset(ap, 0, sizeof(*ap));
2501 ap->prealloced_context = 1;
2502 ap->sample_rate = audio_sample_rate;
2503 ap->channels = audio_channels;
2504 ap->time_base.den = frame_rate.num;
2505 ap->time_base.num = frame_rate.den;
2506 ap->width = frame_width + frame_padleft + frame_padright;
2507 ap->height = frame_height + frame_padtop + frame_padbottom;
2508 ap->pix_fmt = frame_pix_fmt;
2509 ap->channel = video_channel;
2510 ap->standard = video_standard;
2511 ap->video_codec_id = video_codec_id;
2512 ap->audio_codec_id = audio_codec_id;
2513 if(pgmyuv_compatibility_hack)
2514 ap->video_codec_id= CODEC_ID_PGMYUV;
2516 for(i=0; i<opt_name_count; i++){
2517 const AVOption *opt;
2518 double d= av_get_double(avformat_opts, opt_names[i], &opt);
2519 if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2520 av_set_double(ic, opt_names[i], d);
2522 /* open the input file with generic libav function */
2523 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2525 print_error(filename, err);
2529 ic->loop_input = loop_input;
2531 /* If not enough info to get the stream parameters, we decode the
2532 first frames to get it. (used in mpeg case for example) */
2533 ret = av_find_stream_info(ic);
2534 if (ret < 0 && verbose >= 0) {
2535 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2539 timestamp = start_time;
2540 /* add the stream start time */
2541 if (ic->start_time != AV_NOPTS_VALUE)
2542 timestamp += ic->start_time;
2544 /* if seeking requested, we execute it */
2545 if (start_time != 0) {
2546 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2548 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2549 filename, (double)timestamp / AV_TIME_BASE);
2551 /* reset seek info */
2555 /* update the current parameters so that they match the one of the input stream */
2556 for(i=0;i<ic->nb_streams;i++) {
2558 AVCodecContext *enc = ic->streams[i]->codec;
2560 avcodec_thread_init(enc, thread_count);
2561 enc->thread_count= thread_count;
2562 switch(enc->codec_type) {
2563 case CODEC_TYPE_AUDIO:
2564 for(j=0; j<opt_name_count; j++){
2565 const AVOption *opt;
2566 double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[j], &opt);
2567 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2568 av_set_double(enc, opt_names[j], d);
2570 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2571 audio_channels = enc->channels;
2572 audio_sample_rate = enc->sample_rate;
2574 ic->streams[i]->discard= AVDISCARD_ALL;
2576 case CODEC_TYPE_VIDEO:
2577 for(j=0; j<opt_name_count; j++){
2578 const AVOption *opt;
2579 double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[j], &opt);
2580 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2581 av_set_double(enc, opt_names[j], d);
2583 frame_height = enc->height;
2584 frame_width = enc->width;
2585 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2586 frame_pix_fmt = enc->pix_fmt;
2587 rfps = ic->streams[i]->r_frame_rate.num;
2588 rfps_base = ic->streams[i]->r_frame_rate.den;
2589 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2591 enc->debug |= FF_DEBUG_MV;
2593 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2596 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2597 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2599 (float)rfps / rfps_base, rfps, rfps_base);
2601 /* update the current frame rate to match the stream frame rate */
2602 frame_rate.num = rfps;
2603 frame_rate.den = rfps_base;
2605 enc->rate_emu = rate_emu;
2607 ic->streams[i]->discard= AVDISCARD_ALL;
2608 else if(video_discard)
2609 ic->streams[i]->discard= video_discard;
2611 case CODEC_TYPE_DATA:
2613 case CODEC_TYPE_SUBTITLE:
2615 case CODEC_TYPE_UNKNOWN:
2622 input_files[nb_input_files] = ic;
2623 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2624 /* dump the file content */
2626 dump_format(ic, nb_input_files, filename, 0);
2629 file_iformat = NULL;
2630 file_oformat = NULL;
2637 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2639 int has_video, has_audio, i, j;
2640 AVFormatContext *ic;
2644 for(j=0;j<nb_input_files;j++) {
2645 ic = input_files[j];
2646 for(i=0;i<ic->nb_streams;i++) {
2647 AVCodecContext *enc = ic->streams[i]->codec;
2648 switch(enc->codec_type) {
2649 case CODEC_TYPE_AUDIO:
2652 case CODEC_TYPE_VIDEO:
2655 case CODEC_TYPE_DATA:
2656 case CODEC_TYPE_UNKNOWN:
2657 case CODEC_TYPE_SUBTITLE:
2664 *has_video_ptr = has_video;
2665 *has_audio_ptr = has_audio;
2668 static void new_video_stream(AVFormatContext *oc)
2671 AVCodecContext *video_enc;
2674 st = av_new_stream(oc, oc->nb_streams);
2676 fprintf(stderr, "Could not alloc stream\n");
2679 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2680 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2681 video_bitstream_filters= NULL;
2684 avcodec_thread_init(st->codec, thread_count);
2686 video_enc = st->codec;
2689 video_enc->codec_tag= video_codec_tag;
2691 if( (video_global_header&1)
2692 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2693 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2694 avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2696 if(video_global_header&2){
2697 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2698 avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2701 if (video_stream_copy) {
2702 st->stream_copy = 1;
2703 video_enc->codec_type = CODEC_TYPE_VIDEO;
2709 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2710 if (video_codec_id != CODEC_ID_NONE)
2711 codec_id = video_codec_id;
2713 video_enc->codec_id = codec_id;
2714 codec = avcodec_find_encoder(codec_id);
2716 for(i=0; i<opt_name_count; i++){
2717 const AVOption *opt;
2718 double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt);
2719 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2720 av_set_double(video_enc, opt_names[i], d);
2723 video_enc->time_base.den = frame_rate.num;
2724 video_enc->time_base.num = frame_rate.den;
2725 if(codec && codec->supported_framerates){
2726 const AVRational *p= codec->supported_framerates;
2727 AVRational req= (AVRational){frame_rate.num, frame_rate.den};
2728 const AVRational *best=NULL;
2729 AVRational best_error= (AVRational){INT_MAX, 1};
2730 for(; p->den!=0; p++){
2731 AVRational error= av_sub_q(req, *p);
2732 if(error.num <0) error.num *= -1;
2733 if(av_cmp_q(error, best_error) < 0){
2738 video_enc->time_base.den= best->num;
2739 video_enc->time_base.num= best->den;
2742 video_enc->width = frame_width + frame_padright + frame_padleft;
2743 video_enc->height = frame_height + frame_padtop + frame_padbottom;
2744 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2745 video_enc->pix_fmt = frame_pix_fmt;
2747 if(codec && codec->pix_fmts){
2748 const enum PixelFormat *p= codec->pix_fmts;
2750 if(*p == video_enc->pix_fmt)
2754 video_enc->pix_fmt = codec->pix_fmts[0];
2758 video_enc->gop_size = 0;
2759 if (video_qscale || same_quality) {
2760 video_enc->flags |= CODEC_FLAG_QSCALE;
2761 video_enc->global_quality=
2762 st->quality = FF_QP2LAMBDA * video_qscale;
2766 video_enc->intra_matrix = intra_matrix;
2768 video_enc->inter_matrix = inter_matrix;
2770 video_enc->max_qdiff = video_qdiff;
2771 video_enc->rc_eq = video_rc_eq;
2772 video_enc->thread_count = thread_count;
2773 p= video_rc_override_string;
2776 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2778 fprintf(stderr, "error parsing rc_override\n");
2781 video_enc->rc_override=
2782 av_realloc(video_enc->rc_override,
2783 sizeof(RcOverride)*(i+1));
2784 video_enc->rc_override[i].start_frame= start;
2785 video_enc->rc_override[i].end_frame = end;
2787 video_enc->rc_override[i].qscale= q;
2788 video_enc->rc_override[i].quality_factor= 1.0;
2791 video_enc->rc_override[i].qscale= 0;
2792 video_enc->rc_override[i].quality_factor= -q/100.0;
2797 video_enc->rc_override_count=i;
2798 if (!video_enc->rc_initial_buffer_occupancy)
2799 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2800 video_enc->me_threshold= me_threshold;
2801 video_enc->intra_dc_precision= intra_dc_precision - 8;
2802 video_enc->strict_std_compliance = strict;
2805 video_enc->flags|= CODEC_FLAG_PSNR;
2810 video_enc->flags |= CODEC_FLAG_PASS1;
2812 video_enc->flags |= CODEC_FLAG_PASS2;
2817 /* reset some key parameters */
2819 video_codec_id = CODEC_ID_NONE;
2820 video_stream_copy = 0;
2823 static void new_audio_stream(AVFormatContext *oc)
2826 AVCodecContext *audio_enc;
2829 st = av_new_stream(oc, oc->nb_streams);
2831 fprintf(stderr, "Could not alloc stream\n");
2834 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
2836 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2837 audio_bitstream_filters= NULL;
2840 avcodec_thread_init(st->codec, thread_count);
2842 audio_enc = st->codec;
2843 audio_enc->codec_type = CODEC_TYPE_AUDIO;
2844 audio_enc->strict_std_compliance = strict;
2847 audio_enc->codec_tag= audio_codec_tag;
2849 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
2850 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2851 avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2853 if (audio_stream_copy) {
2854 st->stream_copy = 1;
2855 audio_enc->channels = audio_channels;
2857 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
2859 for(i=0; i<opt_name_count; i++){
2860 const AVOption *opt;
2861 double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt);
2862 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2863 av_set_double(audio_enc, opt_names[i], d);
2866 if (audio_codec_id != CODEC_ID_NONE)
2867 codec_id = audio_codec_id;
2868 audio_enc->codec_id = codec_id;
2870 if (audio_qscale > QSCALE_NONE) {
2871 audio_enc->flags |= CODEC_FLAG_QSCALE;
2872 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
2874 audio_enc->thread_count = thread_count;
2875 audio_enc->channels = audio_channels;
2877 audio_enc->sample_rate = audio_sample_rate;
2878 audio_enc->time_base= (AVRational){1, audio_sample_rate};
2879 if (audio_language) {
2880 av_strlcpy(st->language, audio_language, sizeof(st->language));
2881 av_free(audio_language);
2882 audio_language = NULL;
2885 /* reset some key parameters */
2887 audio_codec_id = CODEC_ID_NONE;
2888 audio_stream_copy = 0;
2891 static void opt_new_subtitle_stream(void)
2893 AVFormatContext *oc;
2895 AVCodecContext *subtitle_enc;
2898 if (nb_output_files <= 0) {
2899 fprintf(stderr, "At least one output file must be specified\n");
2902 oc = output_files[nb_output_files - 1];
2904 st = av_new_stream(oc, oc->nb_streams);
2906 fprintf(stderr, "Could not alloc stream\n");
2909 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
2911 subtitle_enc = st->codec;
2912 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
2913 if (subtitle_stream_copy) {
2914 st->stream_copy = 1;
2916 for(i=0; i<opt_name_count; i++){
2917 const AVOption *opt;
2918 double d= av_get_double(avctx_opts[CODEC_TYPE_SUBTITLE], opt_names[i], &opt);
2919 if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2920 av_set_double(subtitle_enc, opt_names[i], d);
2922 subtitle_enc->codec_id = subtitle_codec_id;
2925 if (subtitle_language) {
2926 av_strlcpy(st->language, subtitle_language, sizeof(st->language));
2927 av_free(subtitle_language);
2928 subtitle_language = NULL;
2931 subtitle_codec_id = CODEC_ID_NONE;
2932 subtitle_stream_copy = 0;
2935 static void opt_new_audio_stream(void)
2937 AVFormatContext *oc;
2938 if (nb_output_files <= 0) {
2939 fprintf(stderr, "At least one output file must be specified\n");
2942 oc = output_files[nb_output_files - 1];
2943 new_audio_stream(oc);
2946 static void opt_new_video_stream(void)
2948 AVFormatContext *oc;
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];
2954 new_video_stream(oc);
2957 static void opt_output_file(const char *filename)
2959 AVFormatContext *oc;
2960 int use_video, use_audio, input_has_video, input_has_audio, i;
2961 AVFormatParameters params, *ap = ¶ms;
2963 if (!strcmp(filename, "-"))
2966 oc = av_alloc_format_context();
2968 if (!file_oformat) {
2969 file_oformat = guess_format(NULL, filename, NULL);
2970 if (!file_oformat) {
2971 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
2977 oc->oformat = file_oformat;
2978 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
2980 if (!strcmp(file_oformat->name, "ffm") &&
2981 av_strstart(filename, "http:", NULL)) {
2982 /* special case for files sent to ffserver: we get the stream
2983 parameters from ffserver */
2984 if (read_ffserver_streams(oc, filename) < 0) {
2985 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
2989 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
2990 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
2992 /* disable if no corresponding type found and at least one
2994 if (nb_input_files > 0) {
2995 check_audio_video_inputs(&input_has_video, &input_has_audio);
2996 if (!input_has_video)
2998 if (!input_has_audio)
3002 /* manual disable */
3003 if (audio_disable) {
3006 if (video_disable) {
3011 new_video_stream(oc);
3015 new_audio_stream(oc);
3018 oc->timestamp = rec_timestamp;
3021 av_strlcpy(oc->title, str_title, sizeof(oc->title));
3023 av_strlcpy(oc->author, str_author, sizeof(oc->author));
3025 av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3027 av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3029 av_strlcpy(oc->album, str_album, sizeof(oc->album));
3032 output_files[nb_output_files++] = oc;
3034 /* check filename in case of an image number is expected */
3035 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3036 if (!av_filename_number_test(oc->filename)) {
3037 print_error(oc->filename, AVERROR_NUMEXPECTED);
3042 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3043 /* test if it already exists to avoid loosing precious files */
3044 if (!file_overwrite &&
3045 (strchr(filename, ':') == NULL ||
3046 av_strstart(filename, "file:", NULL))) {
3047 if (url_exist(filename)) {
3050 if ( !using_stdin ) {
3051 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3054 if (toupper(c) != 'Y') {
3055 fprintf(stderr, "Not overwriting - exiting\n");
3060 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3067 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3068 fprintf(stderr, "Could not open '%s'\n", filename);
3073 memset(ap, 0, sizeof(*ap));
3074 if (av_set_parameters(oc, ap) < 0) {
3075 fprintf(stderr, "%s: Invalid encoding parameters\n",
3080 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3081 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3082 oc->loop_output = loop_output;
3084 for(i=0; i<opt_name_count; i++){
3085 const AVOption *opt;
3086 double d = av_get_double(avformat_opts, opt_names[i], &opt);
3087 if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3088 av_set_double(oc, opt_names[i], d);
3091 /* reset some options */
3092 file_oformat = NULL;
3093 file_iformat = NULL;
3096 /* same option as mencoder */
3097 static void opt_pass(const char *pass_str)
3100 pass = atoi(pass_str);
3101 if (pass != 1 && pass != 2) {
3102 fprintf(stderr, "pass number can be only 1 or 2\n");
3108 #if defined(__MINGW32__)
3109 static int64_t getutime(void)
3111 return av_gettime();
3114 static int64_t getutime(void)
3116 struct rusage rusage;
3118 getrusage(RUSAGE_SELF, &rusage);
3119 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3123 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3124 extern int ffm_nopts;
3127 static void show_formats(void)
3129 AVInputFormat *ifmt;
3130 AVOutputFormat *ofmt;
3133 const char *last_name;
3135 printf("File formats:\n");
3140 const char *name=NULL;
3141 const char *long_name=NULL;
3143 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3144 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3145 strcmp(ofmt->name, last_name)>0){
3147 long_name= ofmt->long_name;
3151 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3152 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3153 strcmp(ifmt->name, last_name)>0){
3155 long_name= ifmt->long_name;
3158 if(name && strcmp(ifmt->name, name)==0)
3170 long_name ? long_name:" ");
3174 printf("Codecs:\n");
3180 const char *type_str;
3183 for(p = first_avcodec; p != NULL; p = p->next) {
3184 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3185 strcmp(p->name, last_name)>0){
3187 decode= encode= cap=0;
3189 if(p2 && strcmp(p->name, p2->name)==0){
3190 if(p->decode) decode=1;
3191 if(p->encode) encode=1;
3192 cap |= p->capabilities;
3197 last_name= p2->name;
3200 case CODEC_TYPE_VIDEO:
3203 case CODEC_TYPE_AUDIO:
3206 case CODEC_TYPE_SUBTITLE:
3215 decode ? "D": (/*p2->decoder ? "d":*/" "),
3218 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3219 cap & CODEC_CAP_DR1 ? "D":" ",
3220 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3222 /* if(p2->decoder && decode==0)
3223 printf(" use %s for decoding", p2->decoder->name);*/
3228 printf("Supported file protocols:\n");
3229 for(up = first_protocol; up != NULL; up = up->next)
3230 printf(" %s:", up->name);
3233 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3236 "Note, the names of encoders and decoders do not always match, so there are\n"
3237 "several cases where the above table shows encoder only or decoder only entries\n"
3238 "even though both encoding and decoding are supported. For example, the h263\n"
3239 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
3244 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3247 const char *p = str;
3254 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3261 static void opt_inter_matrix(const char *arg)
3263 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3264 parse_matrix_coeffs(inter_matrix, arg);
3267 static void opt_intra_matrix(const char *arg)
3269 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3270 parse_matrix_coeffs(intra_matrix, arg);
3273 static void opt_target(const char *arg)
3276 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3278 if(!strncmp(arg, "pal-", 4)) {
3281 } else if(!strncmp(arg, "ntsc-", 5)) {
3284 } else if(!strncmp(arg, "film-", 5)) {
3289 /* Calculate FR via float to avoid int overflow */
3290 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3293 } else if((fr == 29970) || (fr == 23976)) {
3296 /* Try to determine PAL/NTSC by peeking in the input files */
3297 if(nb_input_files) {
3299 for(j = 0; j < nb_input_files; j++) {
3300 for(i = 0; i < input_files[j]->nb_streams; i++) {
3301 AVCodecContext *c = input_files[j]->streams[i]->codec;
3302 if(c->codec_type != CODEC_TYPE_VIDEO)
3304 fr = c->time_base.den * 1000 / c->time_base.num;
3308 } else if((fr == 29970) || (fr == 23976)) {
3318 if(verbose && norm >= 0)
3319 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3323 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3324 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3325 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3329 if(!strcmp(arg, "vcd")) {
3331 opt_video_codec("mpeg1video");
3332 opt_audio_codec("mp2");
3335 opt_frame_size(norm ? "352x240" : "352x288");
3336 opt_frame_rate(frame_rates[norm]);
3337 opt_default("gop", norm ? "18" : "15");
3339 opt_default("b", "1150000");
3340 opt_default("maxrate", "1150000");
3341 opt_default("minrate", "1150000");
3342 opt_default("bufsize", "327680"); // 40*1024*8;
3344 opt_default("ab", "224000");
3345 audio_sample_rate = 44100;
3348 opt_default("packetsize", "2324");
3349 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3351 /* We have to offset the PTS, so that it is consistent with the SCR.
3352 SCR starts at 36000, but the first two packs contain only padding
3353 and the first pack from the other stream, respectively, may also have
3354 been written before.
3355 So the real data starts at SCR 36000+3*1200. */
3356 mux_preload= (36000+3*1200) / 90000.0; //0.44
3357 } else if(!strcmp(arg, "svcd")) {
3359 opt_video_codec("mpeg2video");
3360 opt_audio_codec("mp2");
3363 opt_frame_size(norm ? "480x480" : "480x576");
3364 opt_frame_rate(frame_rates[norm]);
3365 opt_default("gop", norm ? "18" : "15");
3367 opt_default("b", "2040000");
3368 opt_default("maxrate", "2516000");
3369 opt_default("minrate", "0"); //1145000;
3370 opt_default("bufsize", "1835008"); //224*1024*8;
3371 opt_default("flags", "+SCAN_OFFSET");
3374 opt_default("ab", "224000");
3375 audio_sample_rate = 44100;
3377 opt_default("packetsize", "2324");
3379 } else if(!strcmp(arg, "dvd")) {
3381 opt_video_codec("mpeg2video");
3382 opt_audio_codec("ac3");
3385 opt_frame_size(norm ? "720x480" : "720x576");
3386 opt_frame_rate(frame_rates[norm]);
3387 opt_default("gop", norm ? "18" : "15");
3389 opt_default("b", "6000000");
3390 opt_default("maxrate", "9000000");
3391 opt_default("minrate", "0"); //1500000;
3392 opt_default("bufsize", "1835008"); //224*1024*8;
3394 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3395 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3397 opt_default("ab", "448000");
3398 audio_sample_rate = 48000;
3400 } else if(!strncmp(arg, "dv", 2)) {
3404 opt_frame_size(norm ? "720x480" : "720x576");
3405 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3406 (norm ? "yuv411p" : "yuv420p"));
3407 opt_frame_rate(frame_rates[norm]);
3409 audio_sample_rate = 48000;
3413 fprintf(stderr, "Unknown target: %s\n", arg);
3418 static void opt_vstats_file (const char *arg)
3420 av_free (vstats_filename);
3421 vstats_filename=av_strdup (arg);
3424 static void opt_vstats (void)
3427 time_t today2 = time(NULL);
3428 struct tm *today = localtime(&today2);
3430 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3432 opt_vstats_file(filename);
3435 static void opt_video_bsf(const char *arg)
3437 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3438 AVBitStreamFilterContext **bsfp;
3441 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3445 bsfp= &video_bitstream_filters;
3447 bsfp= &(*bsfp)->next;
3452 //FIXME avoid audio - video code duplication
3453 static void opt_audio_bsf(const char *arg)
3455 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3456 AVBitStreamFilterContext **bsfp;
3459 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3463 bsfp= &audio_bitstream_filters;
3465 bsfp= &(*bsfp)->next;
3470 static void show_version(void)
3472 /* TODO: add function interface to avutil and avformat */
3473 fprintf(stderr, "ffmpeg " FFMPEG_VERSION "\n"
3477 LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3481 static int opt_default(const char *opt, const char *arg){
3483 const AVOption *o= NULL;
3484 int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
3486 for(type=0; type<CODEC_TYPE_NB; type++){
3487 const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
3489 o = av_set_string(avctx_opts[type], opt, arg);
3492 o = av_set_string(avformat_opts, opt, arg);
3494 o = av_set_string(sws_opts, opt, arg);
3497 o = av_set_string(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg);
3498 else if(opt[0] == 'v')
3499 o = av_set_string(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg);
3500 else if(opt[0] == 's')
3501 o = av_set_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg);
3506 // 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));
3508 //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
3509 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
3510 opt_names[opt_name_count++]= o->name;
3512 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3513 /* disable generate of real time pts in ffm (need to be supressed anyway) */
3514 if(avctx_opts[0]->flags & CODEC_FLAG_BITEXACT)
3518 if(avctx_opts[0]->debug)
3519 av_log_level = AV_LOG_DEBUG;
3523 const OptionDef options[] = {
3525 { "L", 0, {(void*)show_license}, "show license" },
3526 { "h", 0, {(void*)show_help}, "show help" },
3527 { "version", 0, {(void*)show_version}, "show version" },
3528 { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3529 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3530 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3531 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3532 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3533 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3534 { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3535 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3536 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3537 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3538 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3539 { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3540 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3541 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3542 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3543 { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3544 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3545 "add timings for benchmarking" },
3546 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3547 "dump each input packet" },
3548 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3549 "when dumping packets, also dump the payload" },
3550 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3551 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3552 { "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)", "" },
3553 { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3554 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3555 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3556 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3557 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3558 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3559 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3560 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3561 { "dts_delta_threshold", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
3564 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3565 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3566 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3567 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3568 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3569 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format, 'list' as argument shows all the pixel formats supported", "format" },
3570 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3571 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3572 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3573 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3574 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3575 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3576 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3577 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3578 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3579 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3580 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3581 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3582 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3583 { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantizer scale (VBR)", "q" },
3584 { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3585 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3586 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3587 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "" },
3588 { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3589 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3590 "use same video quality as source (implies VBR)" },
3591 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3592 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3593 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3594 "deinterlace pictures" },
3595 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3596 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3597 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3598 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3599 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3600 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3601 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3602 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3603 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3604 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3605 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3608 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3609 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3610 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3611 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3612 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3613 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3614 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3615 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3616 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3617 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3619 /* subtitle options */
3620 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3621 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3622 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3625 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3626 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3627 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3630 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3631 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3633 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
3634 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
3636 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3640 static void show_banner(void)
3642 fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2007 Fabrice Bellard, et al.\n");
3643 fprintf(stderr, " configuration: " FFMPEG_CONFIGURATION "\n");
3644 fprintf(stderr, " libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
3645 fprintf(stderr, " libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
3646 fprintf(stderr, " libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
3647 fprintf(stderr, " built on " __DATE__ " " __TIME__);
3649 fprintf(stderr, ", gcc: " __VERSION__ "\n");
3651 fprintf(stderr, ", using a non-gcc compiler\n");
3655 static void show_license(void)
3660 "FFmpeg is free software; you can redistribute it and/or modify\n"
3661 "it under the terms of the GNU General Public License as published by\n"
3662 "the Free Software Foundation; either version 2 of the License, or\n"
3663 "(at your option) any later version.\n"
3665 "FFmpeg is distributed in the hope that it will be useful,\n"
3666 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3667 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
3668 "GNU General Public License for more details.\n"
3670 "You should have received a copy of the GNU General Public License\n"
3671 "along with FFmpeg; if not, write to the Free Software\n"
3672 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
3676 "FFmpeg is free software; you can redistribute it and/or\n"
3677 "modify it under the terms of the GNU Lesser General Public\n"
3678 "License as published by the Free Software Foundation; either\n"
3679 "version 2.1 of the License, or (at your option) any later version.\n"
3681 "FFmpeg is distributed in the hope that it will be useful,\n"
3682 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3683 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
3684 "Lesser General Public License for more details.\n"
3686 "You should have received a copy of the GNU Lesser General Public\n"
3687 "License along with FFmpeg; if not, write to the Free Software\n"
3688 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
3695 * Trivial log callback.
3696 * Only suitable for show_help and similar since it lacks prefix handling.
3698 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3700 vfprintf(stdout, fmt, vl);
3703 static void show_help(void)
3705 av_log_set_callback(log_callback_help);
3707 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3708 "Hyper fast Audio and Video encoder\n");
3710 show_help_options(options, "Main options:\n",
3711 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3712 show_help_options(options, "\nVideo options:\n",
3713 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3715 show_help_options(options, "\nAdvanced Video options:\n",
3716 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3717 OPT_VIDEO | OPT_EXPERT);
3718 show_help_options(options, "\nAudio options:\n",
3719 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3721 show_help_options(options, "\nAdvanced Audio options:\n",
3722 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3723 OPT_AUDIO | OPT_EXPERT);
3724 show_help_options(options, "\nSubtitle options:\n",
3725 OPT_SUBTITLE | OPT_GRAB,
3727 show_help_options(options, "\nAudio/Video grab options:\n",
3730 show_help_options(options, "\nAdvanced options:\n",
3731 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3733 av_opt_show(avctx_opts[0], NULL);
3734 av_opt_show(avformat_opts, NULL);
3735 av_opt_show(sws_opts, NULL);
3740 void parse_arg_file(const char *filename)
3742 opt_output_file(filename);
3745 int main(int argc, char **argv)
3752 for(i=0; i<CODEC_TYPE_NB; i++){
3753 avctx_opts[i]= avcodec_alloc_context2(i);
3755 avformat_opts = av_alloc_format_context();
3756 sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3764 parse_options(argc, argv, options);
3766 /* file converter / grab */
3767 if (nb_output_files <= 0) {
3768 fprintf(stderr, "Must supply at least one output file\n");
3772 if (nb_input_files == 0) {
3773 fprintf(stderr, "Must supply at least one input file\n");
3778 av_encode(output_files, nb_output_files, input_files, nb_input_files,
3779 stream_maps, nb_stream_maps);
3780 ti = getutime() - ti;
3782 printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3786 for(i=0;i<nb_output_files;i++) {
3787 /* maybe av_close_output_file ??? */
3788 AVFormatContext *s = output_files[i];
3790 if (!(s->oformat->flags & AVFMT_NOFILE))
3792 for(j=0;j<s->nb_streams;j++) {
3793 av_free(s->streams[j]->codec);
3794 av_free(s->streams[j]);
3798 for(i=0;i<nb_input_files;i++)
3799 av_close_input_file(input_files[i]);
3803 av_free(intra_matrix);
3804 av_free(inter_matrix);
3808 av_free(vstats_filename);
3812 av_free(video_standard);
3814 #ifdef CONFIG_POWERPC_PERF
3815 extern void powerpc_display_perf_report(void);
3816 powerpc_display_perf_report();
3817 #endif /* CONFIG_POWERPC_PERF */
3819 if (received_sigterm) {
3821 "Received signal %d: terminating.\n",
3822 (int) received_sigterm);
3826 exit(0); /* not all OS-es handle main() return value */