3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21 #define HAVE_AV_CONFIG_H
26 #include "framehook.h"
36 #include <sys/ioctl.h>
39 #include <sys/resource.h>
42 #include <sys/types.h>
43 #include <sys/select.h>
46 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
55 #if !defined(INFINITY) && defined(HUGE_VAL)
56 #define INFINITY HUGE_VAL
59 /* select an input stream for an output stream */
60 typedef struct AVStreamMap {
64 int sync_stream_index;
67 /** select an input file for an output file */
68 typedef struct AVMetaDataMap {
73 extern const OptionDef options[];
75 static void show_help(void);
76 static void show_license(void);
77 static int opt_default(const char *opt, const char *arg);
81 static AVFormatContext *input_files[MAX_FILES];
82 static int64_t input_files_ts_offset[MAX_FILES];
83 static int nb_input_files = 0;
85 static AVFormatContext *output_files[MAX_FILES];
86 static int nb_output_files = 0;
88 static AVStreamMap stream_maps[MAX_FILES];
89 static int nb_stream_maps;
91 static AVMetaDataMap meta_data_maps[MAX_FILES];
92 static int nb_meta_data_maps;
94 static AVInputFormat *file_iformat;
95 static AVOutputFormat *file_oformat;
96 static int frame_width = 0;
97 static int frame_height = 0;
98 static float frame_aspect_ratio = 0;
99 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
100 static int frame_padtop = 0;
101 static int frame_padbottom = 0;
102 static int frame_padleft = 0;
103 static int frame_padright = 0;
104 static int padcolor[3] = {16,128,128}; /* default to black */
105 static int frame_topBand = 0;
106 static int frame_bottomBand = 0;
107 static int frame_leftBand = 0;
108 static int frame_rightBand = 0;
109 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
110 static int frame_rate = 25;
111 static int frame_rate_base = 1;
112 static float video_qscale = 0;
113 static int video_qdiff = 3;
114 static uint16_t *intra_matrix = NULL;
115 static uint16_t *inter_matrix = NULL;
116 #if 0 //experimental, (can be removed)
117 static float video_rc_qsquish=1.0;
118 static float video_rc_qmod_amp=0;
119 static int video_rc_qmod_freq=0;
121 static char *video_rc_override_string=NULL;
122 static char *video_rc_eq="tex^qComp";
123 static int me_method = ME_EPZS;
124 static int video_disable = 0;
125 static int video_discard = 0;
126 static int video_codec_id = CODEC_ID_NONE;
127 static int video_codec_tag = 0;
128 static int same_quality = 0;
129 static int do_deinterlace = 0;
130 static int strict = 0;
131 static int top_field_first = -1;
132 static int me_threshold = 0;
133 static int intra_dc_precision = 8;
134 static int loop_input = 0;
135 static int loop_output = AVFMT_NOOUTPUTLOOP;
136 static int qp_hist = 0;
138 static int intra_only = 0;
139 static int audio_sample_rate = 44100;
140 #define QSCALE_NONE -99999
141 static float audio_qscale = QSCALE_NONE;
142 static int audio_disable = 0;
143 static int audio_channels = 1;
144 static int audio_codec_id = CODEC_ID_NONE;
145 static int audio_codec_tag = 0;
146 static char *audio_language = NULL;
148 static int subtitle_codec_id = CODEC_ID_NONE;
149 static char *subtitle_language = NULL;
151 static float mux_preload= 0.5;
152 static float mux_max_delay= 0.7;
154 static int64_t recording_time = 0;
155 static int64_t start_time = 0;
156 static int64_t rec_timestamp = 0;
157 static int64_t input_ts_offset = 0;
158 static int file_overwrite = 0;
159 static char *str_title = NULL;
160 static char *str_author = NULL;
161 static char *str_copyright = NULL;
162 static char *str_comment = NULL;
163 static char *str_album = NULL;
164 static int do_benchmark = 0;
165 static int do_hex_dump = 0;
166 static int do_pkt_dump = 0;
167 static int do_psnr = 0;
168 static int do_vstats = 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;
180 static int rate_emu = 0;
182 static int video_channel = 0;
183 static char *video_standard = "ntsc";
185 static int audio_volume = 256;
187 static int using_stdin = 0;
188 static int using_vhook = 0;
189 static int verbose = 1;
190 static int thread_count= 1;
191 static int q_pressed = 0;
192 static int64_t video_size = 0;
193 static int64_t audio_size = 0;
194 static int64_t extra_size = 0;
195 static int nb_frames_dup = 0;
196 static int nb_frames_drop = 0;
197 static int input_sync;
198 static int limit_filesize = 0; //
200 static int pgmyuv_compatibility_hack=0;
201 static int dts_delta_threshold = 10;
203 static int sws_flags = SWS_BICUBIC;
205 const char **opt_names=NULL;
206 int opt_name_count=0;
207 AVCodecContext *avctx_opts[CODEC_TYPE_NB];
208 AVFormatContext *avformat_opts;
210 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
211 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
212 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
214 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
216 struct AVInputStream;
218 typedef struct AVOutputStream {
219 int file_index; /* file index */
220 int index; /* stream index in the output file */
221 int source_index; /* AVInputStream index */
222 AVStream *st; /* stream in the output file */
223 int encoding_needed; /* true if encoding needed for this stream */
225 /* input pts and corresponding output pts
227 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
228 struct AVInputStream *sync_ist; /* input stream to sync against */
229 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
232 AVFrame pict_tmp; /* temporary image for resampling */
233 struct SwsContext *img_resample_ctx; /* for image resampling */
237 int topBand; /* cropping area sizes */
241 int padtop; /* padding area sizes */
248 ReSampleContext *resample; /* for audio resampling */
249 AVFifoBuffer fifo; /* for compression: one audio fifo per codec */
253 typedef struct AVInputStream {
257 int discard; /* true if stream data should be discarded */
258 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
259 int64_t sample_index; /* current sample */
261 int64_t start; /* time when read started */
262 unsigned long frame; /* current frame */
263 int64_t next_pts; /* synthetic pts for cases where pkt.pts
265 int64_t pts; /* current pts */
266 int is_start; /* is 1 at the start and after a discontinuity */
269 typedef struct AVInputFile {
270 int eof_reached; /* true if eof reached */
271 int ist_index; /* index of first stream in ist_table */
272 int buffer_size; /* current total buffer size */
273 int nb_streams; /* nb streams we are aware of */
278 /* init terminal so that we can grab keys */
279 static struct termios oldtty;
282 static void term_exit(void)
285 tcsetattr (0, TCSANOW, &oldtty);
289 static volatile sig_atomic_t received_sigterm = 0;
292 sigterm_handler(int sig)
294 received_sigterm = sig;
298 static void term_init(void)
306 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
307 |INLCR|IGNCR|ICRNL|IXON);
308 tty.c_oflag |= OPOST;
309 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
310 tty.c_cflag &= ~(CSIZE|PARENB);
315 tcsetattr (0, TCSANOW, &tty);
316 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
319 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
320 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
322 register a function to be called at normal program termination
325 #ifdef CONFIG_BEOS_NETSERVER
326 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
330 /* read a key without blocking */
331 static int read_key(void)
339 #ifndef CONFIG_BEOS_NETSERVER
347 n = select(1, &rfds, NULL, NULL, &tv);
360 static int decode_interrupt_cb(void)
362 return q_pressed || (q_pressed = read_key() == 'q');
365 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
370 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
373 /* copy stream format */
374 s->nb_streams = ic->nb_streams;
375 for(i=0;i<ic->nb_streams;i++) {
378 // FIXME: a more elegant solution is needed
379 st = av_mallocz(sizeof(AVStream));
380 memcpy(st, ic->streams[i], sizeof(AVStream));
381 st->codec = avcodec_alloc_context();
382 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
386 av_close_input_file(ic);
391 get_sync_ipts(const AVOutputStream *ost)
393 const AVInputStream *ist = ost->sync_ist;
394 return (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/AV_TIME_BASE;
397 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
399 AVPacket new_pkt= *pkt;
400 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
401 &new_pkt.data, &new_pkt.size,
402 pkt->data, pkt->size,
403 pkt->flags & PKT_FLAG_KEY);
406 new_pkt.destruct= av_destruct_packet;
413 av_interleaved_write_frame(s, pkt);
416 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
418 static void do_audio_out(AVFormatContext *s,
421 unsigned char *buf, int size)
424 static uint8_t *audio_buf = NULL;
425 static uint8_t *audio_out = NULL;
426 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
428 int size_out, frame_bytes, ret;
429 AVCodecContext *enc= ost->st->codec;
431 /* SC: dynamic allocation of buffers */
433 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
435 audio_out = av_malloc(audio_out_size);
436 if (!audio_buf || !audio_out)
437 return; /* Should signal an error ! */
439 if(audio_sync_method){
440 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
441 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
442 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
443 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
445 //FIXME resample delay
446 if(fabs(delta) > 50){
449 byte_delta= FFMAX(byte_delta, -size);
453 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
458 static uint8_t *input_tmp= NULL;
459 input_tmp= av_realloc(input_tmp, byte_delta + size);
461 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
464 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
466 memset(input_tmp, 0, byte_delta);
467 memcpy(input_tmp + byte_delta, buf, size);
471 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
473 }else if(audio_sync_method>1){
474 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
475 assert(ost->audio_resample);
477 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
478 // 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));
479 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
483 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
484 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
486 if (ost->audio_resample) {
488 size_out = audio_resample(ost->resample,
489 (short *)buftmp, (short *)buf,
490 size / (ist->st->codec->channels * 2));
491 size_out = size_out * enc->channels * 2;
497 /* now encode as many frames as possible */
498 if (enc->frame_size > 1) {
499 /* output resampled raw samples */
500 av_fifo_write(&ost->fifo, buftmp, size_out);
502 frame_bytes = enc->frame_size * 2 * enc->channels;
504 while (av_fifo_read(&ost->fifo, audio_buf, frame_bytes) == 0) {
506 av_init_packet(&pkt);
508 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
511 pkt.stream_index= ost->index;
514 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
515 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
516 pkt.flags |= PKT_FLAG_KEY;
517 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
519 ost->sync_opts += enc->frame_size;
523 av_init_packet(&pkt);
525 ost->sync_opts += size_out / (2 * enc->channels);
527 /* output a pcm frame */
528 /* XXX: change encoding codec API to avoid this ? */
529 switch(enc->codec->id) {
530 case CODEC_ID_PCM_S32LE:
531 case CODEC_ID_PCM_S32BE:
532 case CODEC_ID_PCM_U32LE:
533 case CODEC_ID_PCM_U32BE:
534 size_out = size_out << 1;
536 case CODEC_ID_PCM_S24LE:
537 case CODEC_ID_PCM_S24BE:
538 case CODEC_ID_PCM_U24LE:
539 case CODEC_ID_PCM_U24BE:
540 case CODEC_ID_PCM_S24DAUD:
541 size_out = size_out / 2 * 3;
543 case CODEC_ID_PCM_S16LE:
544 case CODEC_ID_PCM_S16BE:
545 case CODEC_ID_PCM_U16LE:
546 case CODEC_ID_PCM_U16BE:
549 size_out = size_out >> 1;
552 ret = avcodec_encode_audio(enc, audio_out, size_out,
555 pkt.stream_index= ost->index;
558 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
559 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
560 pkt.flags |= PKT_FLAG_KEY;
561 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
565 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
569 AVPicture picture_tmp;
572 dec = ist->st->codec;
574 /* deinterlace : must be done before any resize */
575 if (do_deinterlace || using_vhook) {
578 /* create temporary picture */
579 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
580 buf = av_malloc(size);
584 picture2 = &picture_tmp;
585 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
588 if(avpicture_deinterlace(picture2, picture,
589 dec->pix_fmt, dec->width, dec->height) < 0) {
590 /* if error, do not deinterlace */
596 av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
602 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
604 if (picture != picture2)
605 *picture = *picture2;
609 /* we begin to correct av delay at this threshold */
610 #define AV_DELAY_MAX 0.100
612 static void do_subtitle_out(AVFormatContext *s,
618 static uint8_t *subtitle_out = NULL;
619 int subtitle_out_max_size = 65536;
620 int subtitle_out_size, nb, i;
624 if (pts == AV_NOPTS_VALUE) {
625 fprintf(stderr, "Subtitle packets must have a pts\n");
629 enc = ost->st->codec;
632 subtitle_out = av_malloc(subtitle_out_max_size);
635 /* Note: DVB subtitle need one packet to draw them and one other
636 packet to clear them */
637 /* XXX: signal it in the codec context ? */
638 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
643 for(i = 0; i < nb; i++) {
644 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
645 subtitle_out_max_size, sub);
647 av_init_packet(&pkt);
648 pkt.stream_index = ost->index;
649 pkt.data = subtitle_out;
650 pkt.size = subtitle_out_size;
651 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);
652 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
653 /* XXX: the pts correction is handled here. Maybe handling
654 it in the codec would be better */
656 pkt.pts += 90 * sub->start_display_time;
658 pkt.pts += 90 * sub->end_display_time;
660 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
664 static int bit_buffer_size= 1024*256;
665 static uint8_t *bit_buffer= NULL;
667 static void do_video_out(AVFormatContext *s,
673 int nb_frames, i, ret;
674 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
675 AVFrame picture_crop_temp, picture_pad_temp;
676 AVCodecContext *enc, *dec;
678 avcodec_get_frame_defaults(&picture_crop_temp);
679 avcodec_get_frame_defaults(&picture_pad_temp);
681 enc = ost->st->codec;
682 dec = ist->st->codec;
684 /* by default, we output a single frame */
689 if(video_sync_method){
691 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
692 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
695 else if (vdelta > 1.1)
696 nb_frames = lrintf(vdelta);
697 //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);
701 fprintf(stderr, "*** drop!\n");
702 }else if (nb_frames > 1) {
703 nb_frames_dup += nb_frames;
705 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
708 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
710 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
714 if (ost->video_crop) {
715 if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
716 av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
719 formatted_picture = &picture_crop_temp;
721 formatted_picture = in_picture;
724 final_picture = formatted_picture;
725 padding_src = formatted_picture;
726 resampling_dst = &ost->pict_tmp;
727 if (ost->video_pad) {
728 final_picture = &ost->pict_tmp;
729 if (ost->video_resample) {
730 if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
731 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
734 resampling_dst = &picture_pad_temp;
738 if (ost->video_resample) {
740 final_picture = &ost->pict_tmp;
741 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
742 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
745 if (ost->video_pad) {
746 av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
747 enc->height, enc->width, enc->pix_fmt,
748 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
751 /* duplicates frame if needed */
752 for(i=0;i<nb_frames;i++) {
754 av_init_packet(&pkt);
755 pkt.stream_index= ost->index;
757 if (s->oformat->flags & AVFMT_RAWPICTURE) {
758 /* raw pictures are written as AVPicture structure to
759 avoid any copies. We support temorarily the older
761 AVFrame* old_frame = enc->coded_frame;
762 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
763 pkt.data= (uint8_t *)final_picture;
764 pkt.size= sizeof(AVPicture);
765 if(dec->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
766 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
767 if(dec->coded_frame && dec->coded_frame->key_frame)
768 pkt.flags |= PKT_FLAG_KEY;
770 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
771 enc->coded_frame = old_frame;
775 big_picture= *final_picture;
776 /* better than nothing: use input picture interlaced
778 big_picture.interlaced_frame = in_picture->interlaced_frame;
779 if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
780 if(top_field_first == -1)
781 big_picture.top_field_first = in_picture->top_field_first;
783 big_picture.top_field_first = top_field_first;
786 /* handles sameq here. This is not correct because it may
787 not be a global option */
789 big_picture.quality = ist->st->quality;
791 big_picture.quality = ost->st->quality;
793 big_picture.pict_type = 0;
794 // big_picture.pts = AV_NOPTS_VALUE;
795 big_picture.pts= ost->sync_opts;
796 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
797 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
798 ret = avcodec_encode_video(enc,
799 bit_buffer, bit_buffer_size,
802 fprintf(stderr, "Video encoding failed\n");
805 //enc->frame_number = enc->real_pict_num;
807 pkt.data= bit_buffer;
809 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
810 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
811 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
812 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
813 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
815 if(enc->coded_frame && enc->coded_frame->key_frame)
816 pkt.flags |= PKT_FLAG_KEY;
817 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
819 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
820 // enc->frame_number-1, enc->real_pict_num, ret,
822 /* if two pass, output log */
823 if (ost->logfile && enc->stats_out) {
824 fprintf(ost->logfile, "%s", enc->stats_out);
833 static double psnr(double d){
834 if(d==0) return INFINITY;
835 return -10.0*log(d)/log(10.0);
838 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
841 static FILE *fvstats=NULL;
848 double ti1, bitrate, avg_bitrate;
852 today = localtime(&today2);
853 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
856 fvstats = fopen(filename,"w");
864 enc = ost->st->codec;
865 if (enc->codec_type == CODEC_TYPE_VIDEO) {
866 frame_number = ost->frame_number;
867 fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
868 if (enc->flags&CODEC_FLAG_PSNR)
869 fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
871 fprintf(fvstats,"f_size= %6d ", frame_size);
872 /* compute pts value */
873 ti1 = ost->sync_opts * av_q2d(enc->time_base);
877 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
878 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
879 fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
880 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
881 fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
885 static void print_report(AVFormatContext **output_files,
886 AVOutputStream **ost_table, int nb_ostreams,
891 AVFormatContext *oc, *os;
894 int frame_number, vid, i;
895 double bitrate, ti1, pts;
896 static int64_t last_time = -1;
897 static int qp_histogram[52];
899 if (!is_last_report) {
901 /* display the report every 0.5 seconds */
902 cur_time = av_gettime();
903 if (last_time == -1) {
904 last_time = cur_time;
907 if ((cur_time - last_time) < 500000)
909 last_time = cur_time;
913 oc = output_files[0];
915 total_size = url_ftell(&oc->pb);
920 for(i=0;i<nb_ostreams;i++) {
922 os = output_files[ost->file_index];
923 enc = ost->st->codec;
924 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
925 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
926 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
928 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
929 frame_number = ost->frame_number;
930 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d q=%3.1f ",
931 frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
933 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
934 if(qp_hist && enc->coded_frame){
936 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
937 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
940 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
942 if (enc->flags&CODEC_FLAG_PSNR){
944 double error, error_sum=0;
945 double scale, scale_sum=0;
946 char type[3]= {'Y','U','V'};
947 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
950 error= enc->error[j];
951 scale= enc->width*enc->height*255.0*255.0*frame_number;
953 error= enc->coded_frame->error[j];
954 scale= enc->width*enc->height*255.0*255.0;
959 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
961 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
965 /* compute min output value */
966 pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
967 if ((pts < ti1) && (pts > 0))
973 if (verbose || is_last_report) {
974 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
976 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
977 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
978 (double)total_size / 1024, ti1, bitrate);
981 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
982 nb_frames_dup, nb_frames_drop);
985 fprintf(stderr, "%s \r", buf);
990 if (is_last_report && verbose >= 0){
991 int64_t raw= audio_size + video_size + extra_size;
992 fprintf(stderr, "\n");
993 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
997 100.0*(total_size - raw)/raw
1002 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1003 static int output_packet(AVInputStream *ist, int ist_index,
1004 AVOutputStream **ost_table, int nb_ostreams,
1005 const AVPacket *pkt)
1007 AVFormatContext *os;
1008 AVOutputStream *ost;
1012 int data_size, got_picture;
1014 void *buffer_to_free;
1015 static unsigned int samples_size= 0;
1016 static short *samples= NULL;
1017 AVSubtitle subtitle, *subtitle_to_free;
1021 ist->pts= ist->next_pts; // needed for last packet if vsync=0
1022 } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1023 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1025 // assert(ist->pts == ist->next_pts);
1039 /* decode the packet if needed */
1040 data_buf = NULL; /* fail safe */
1042 subtitle_to_free = NULL;
1043 if (ist->decoding_needed) {
1044 switch(ist->st->codec->codec_type) {
1045 case CODEC_TYPE_AUDIO:{
1047 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
1048 data_size= samples_size;
1049 /* XXX: could avoid copy if PCM 16 bits with same
1050 endianness as CPU */
1051 ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1057 /* Some bug in mpeg audio decoder gives */
1058 /* data_size < 0, it seems they are overflows */
1059 if (data_size <= 0) {
1060 /* no audio frame */
1063 data_buf = (uint8_t *)samples;
1064 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1065 (ist->st->codec->sample_rate * ist->st->codec->channels);
1067 case CODEC_TYPE_VIDEO:
1068 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1069 /* XXX: allocate picture correctly */
1070 avcodec_get_frame_defaults(&picture);
1072 ret = avcodec_decode_video(ist->st->codec,
1073 &picture, &got_picture, ptr, len);
1074 ist->st->quality= picture.quality;
1078 /* no picture yet */
1079 goto discard_packet;
1081 if (ist->st->codec->time_base.num != 0) {
1082 ist->next_pts += ((int64_t)AV_TIME_BASE *
1083 ist->st->codec->time_base.num) /
1084 ist->st->codec->time_base.den;
1088 case CODEC_TYPE_SUBTITLE:
1089 ret = avcodec_decode_subtitle(ist->st->codec,
1090 &subtitle, &got_subtitle, ptr, len);
1093 if (!got_subtitle) {
1094 goto discard_packet;
1096 subtitle_to_free = &subtitle;
1103 switch(ist->st->codec->codec_type) {
1104 case CODEC_TYPE_AUDIO:
1105 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1106 (ist->st->codec->sample_rate * ist->st->codec->channels);
1108 case CODEC_TYPE_VIDEO:
1109 if (ist->st->codec->time_base.num != 0) {
1110 ist->next_pts += ((int64_t)AV_TIME_BASE *
1111 ist->st->codec->time_base.num) /
1112 ist->st->codec->time_base.den;
1122 buffer_to_free = NULL;
1123 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1124 pre_process_video_frame(ist, (AVPicture *)&picture,
1128 // preprocess audio (volume)
1129 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1130 if (audio_volume != 256) {
1133 for(i=0;i<(data_size / sizeof(short));i++) {
1134 int v = ((*volp) * audio_volume + 128) >> 8;
1135 if (v < -32768) v = -32768;
1136 if (v > 32767) v = 32767;
1142 /* frame rate emulation */
1143 if (ist->st->codec->rate_emu) {
1144 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1145 int64_t now = av_gettime() - ist->start;
1153 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1154 is the one of the next displayed one */
1155 /* XXX: add mpeg4 too ? */
1156 if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1157 if (ist->st->codec->pict_type != B_TYPE) {
1159 tmp = ist->last_ip_pts;
1160 ist->last_ip_pts = ist->frac_pts.val;
1161 ist->frac_pts.val = tmp;
1165 /* if output time reached then transcode raw format,
1166 encode packets and output them */
1167 if (start_time == 0 || ist->pts >= start_time)
1168 for(i=0;i<nb_ostreams;i++) {
1172 if (ost->source_index == ist_index) {
1173 os = output_files[ost->file_index];
1176 printf("%d: got pts=%0.3f %0.3f\n", i,
1177 (double)pkt->pts / AV_TIME_BASE,
1178 ((double)ist->pts / AV_TIME_BASE) -
1179 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1181 /* set the input output pts pairs */
1182 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1184 if (ost->encoding_needed) {
1185 switch(ost->st->codec->codec_type) {
1186 case CODEC_TYPE_AUDIO:
1187 do_audio_out(os, ost, ist, data_buf, data_size);
1189 case CODEC_TYPE_VIDEO:
1190 do_video_out(os, ost, ist, &picture, &frame_size);
1191 video_size += frame_size;
1192 if (do_vstats && frame_size)
1193 do_video_stats(os, ost, frame_size);
1195 case CODEC_TYPE_SUBTITLE:
1196 do_subtitle_out(os, ost, ist, &subtitle,
1203 AVFrame avframe; //FIXME/XXX remove this
1205 av_init_packet(&opkt);
1207 /* no reencoding needed : output the packet directly */
1208 /* force the input stream PTS */
1210 avcodec_get_frame_defaults(&avframe);
1211 ost->st->codec->coded_frame= &avframe;
1212 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1214 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1215 audio_size += data_size;
1216 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1217 video_size += data_size;
1221 opkt.stream_index= ost->index;
1222 if(pkt->pts != AV_NOPTS_VALUE)
1223 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);
1225 opkt.pts= AV_NOPTS_VALUE;
1229 if (pkt->dts == AV_NOPTS_VALUE)
1230 dts = ist->next_pts;
1232 dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1233 opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
1235 opkt.flags= pkt->flags;
1237 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1238 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1239 opkt.destruct= av_destruct_packet;
1241 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
1242 ost->st->codec->frame_number++;
1243 ost->frame_number++;
1244 av_free_packet(&opkt);
1248 av_free(buffer_to_free);
1249 /* XXX: allocate the subtitles in the codec ? */
1250 if (subtitle_to_free) {
1251 if (subtitle_to_free->rects != NULL) {
1252 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1253 av_free(subtitle_to_free->rects[i].bitmap);
1254 av_free(subtitle_to_free->rects[i].rgba_palette);
1256 av_freep(&subtitle_to_free->rects);
1258 subtitle_to_free->num_rects = 0;
1259 subtitle_to_free = NULL;
1266 for(i=0;i<nb_ostreams;i++) {
1268 if (ost->source_index == ist_index) {
1269 AVCodecContext *enc= ost->st->codec;
1270 os = output_files[ost->file_index];
1272 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1274 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1277 if (ost->encoding_needed) {
1281 av_init_packet(&pkt);
1282 pkt.stream_index= ost->index;
1284 switch(ost->st->codec->codec_type) {
1285 case CODEC_TYPE_AUDIO:
1286 fifo_bytes = av_fifo_size(&ost->fifo);
1288 /* encode any samples remaining in fifo */
1289 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1290 int fs_tmp = enc->frame_size;
1291 enc->frame_size = fifo_bytes / (2 * enc->channels);
1292 if(av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes) == 0) {
1293 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1295 enc->frame_size = fs_tmp;
1298 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1301 pkt.flags |= PKT_FLAG_KEY;
1303 case CODEC_TYPE_VIDEO:
1304 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1306 if(enc->coded_frame && enc->coded_frame->key_frame)
1307 pkt.flags |= PKT_FLAG_KEY;
1308 if (ost->logfile && enc->stats_out) {
1309 fprintf(ost->logfile, "%s", enc->stats_out);
1318 pkt.data= bit_buffer;
1320 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1321 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1322 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1336 * The following code is the main loop of the file converter
1338 static int av_encode(AVFormatContext **output_files,
1339 int nb_output_files,
1340 AVFormatContext **input_files,
1342 AVStreamMap *stream_maps, int nb_stream_maps)
1344 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1345 AVFormatContext *is, *os;
1346 AVCodecContext *codec, *icodec;
1347 AVOutputStream *ost, **ost_table = NULL;
1348 AVInputStream *ist, **ist_table = NULL;
1349 AVInputFile *file_table;
1350 AVFormatContext *stream_no_data;
1353 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1357 /* input stream init */
1359 for(i=0;i<nb_input_files;i++) {
1360 is = input_files[i];
1361 file_table[i].ist_index = j;
1362 file_table[i].nb_streams = is->nb_streams;
1363 j += is->nb_streams;
1367 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1371 for(i=0;i<nb_istreams;i++) {
1372 ist = av_mallocz(sizeof(AVInputStream));
1378 for(i=0;i<nb_input_files;i++) {
1379 is = input_files[i];
1380 for(k=0;k<is->nb_streams;k++) {
1381 ist = ist_table[j++];
1382 ist->st = is->streams[k];
1383 ist->file_index = i;
1385 ist->discard = 1; /* the stream is discarded by default
1388 if (ist->st->codec->rate_emu) {
1389 ist->start = av_gettime();
1395 /* output stream init */
1397 for(i=0;i<nb_output_files;i++) {
1398 os = output_files[i];
1399 if (!os->nb_streams) {
1400 fprintf(stderr, "Output file does not contain any stream\n");
1403 nb_ostreams += os->nb_streams;
1405 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1406 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1410 /* Sanity check the mapping args -- do the input files & streams exist? */
1411 for(i=0;i<nb_stream_maps;i++) {
1412 int fi = stream_maps[i].file_index;
1413 int si = stream_maps[i].stream_index;
1415 if (fi < 0 || fi > nb_input_files - 1 ||
1416 si < 0 || si > file_table[fi].nb_streams - 1) {
1417 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1420 fi = stream_maps[i].sync_file_index;
1421 si = stream_maps[i].sync_stream_index;
1422 if (fi < 0 || fi > nb_input_files - 1 ||
1423 si < 0 || si > file_table[fi].nb_streams - 1) {
1424 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1429 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1432 for(i=0;i<nb_ostreams;i++) {
1433 ost = av_mallocz(sizeof(AVOutputStream));
1440 for(k=0;k<nb_output_files;k++) {
1441 os = output_files[k];
1442 for(i=0;i<os->nb_streams;i++) {
1444 ost = ost_table[n++];
1445 ost->file_index = k;
1447 ost->st = os->streams[i];
1448 if (nb_stream_maps > 0) {
1449 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1450 stream_maps[n-1].stream_index;
1452 /* Sanity check that the stream types match */
1453 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1454 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1455 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1456 ost->file_index, ost->index);
1461 /* get corresponding input stream index : we select the first one with the right type */
1463 for(j=0;j<nb_istreams;j++) {
1466 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1467 ost->source_index = j;
1474 /* try again and reuse existing stream */
1475 for(j=0;j<nb_istreams;j++) {
1477 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1478 ost->source_index = j;
1483 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1484 ost->file_index, ost->index);
1489 ist = ist_table[ost->source_index];
1491 ost->sync_ist = (nb_stream_maps > 0) ?
1492 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1493 stream_maps[n-1].sync_stream_index] : ist;
1497 /* for each output stream, we compute the right encoding parameters */
1498 for(i=0;i<nb_ostreams;i++) {
1500 ist = ist_table[ost->source_index];
1502 codec = ost->st->codec;
1503 icodec = ist->st->codec;
1505 if (ost->st->stream_copy) {
1506 /* if stream_copy is selected, no need to decode or encode */
1507 codec->codec_id = icodec->codec_id;
1508 codec->codec_type = icodec->codec_type;
1509 if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1510 codec->bit_rate = icodec->bit_rate;
1511 codec->extradata= icodec->extradata;
1512 codec->extradata_size= icodec->extradata_size;
1513 if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1514 codec->time_base = icodec->time_base;
1516 codec->time_base = ist->st->time_base;
1517 switch(codec->codec_type) {
1518 case CODEC_TYPE_AUDIO:
1519 codec->sample_rate = icodec->sample_rate;
1520 codec->channels = icodec->channels;
1521 codec->frame_size = icodec->frame_size;
1522 codec->block_align= icodec->block_align;
1524 case CODEC_TYPE_VIDEO:
1526 fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1529 codec->pix_fmt = icodec->pix_fmt;
1530 codec->width = icodec->width;
1531 codec->height = icodec->height;
1532 codec->has_b_frames = icodec->has_b_frames;
1534 case CODEC_TYPE_SUBTITLE:
1540 switch(codec->codec_type) {
1541 case CODEC_TYPE_AUDIO:
1542 if (av_fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1545 if (codec->channels == icodec->channels &&
1546 codec->sample_rate == icodec->sample_rate) {
1547 ost->audio_resample = 0;
1549 if (codec->channels != icodec->channels &&
1550 (icodec->codec_id == CODEC_ID_AC3 ||
1551 icodec->codec_id == CODEC_ID_DTS)) {
1552 /* Special case for 5:1 AC3 and DTS input */
1553 /* and mono or stereo output */
1554 /* Request specific number of channels */
1555 icodec->channels = codec->channels;
1556 if (codec->sample_rate == icodec->sample_rate)
1557 ost->audio_resample = 0;
1559 ost->audio_resample = 1;
1562 ost->audio_resample = 1;
1565 if(audio_sync_method>1)
1566 ost->audio_resample = 1;
1568 if(ost->audio_resample){
1569 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1570 codec->sample_rate, icodec->sample_rate);
1572 printf("Can't resample. Aborting.\n");
1576 ist->decoding_needed = 1;
1577 ost->encoding_needed = 1;
1579 case CODEC_TYPE_VIDEO:
1580 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1581 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1582 ost->video_resample = ((codec->width != icodec->width -
1583 (frame_leftBand + frame_rightBand) +
1584 (frame_padleft + frame_padright)) ||
1585 (codec->height != icodec->height -
1586 (frame_topBand + frame_bottomBand) +
1587 (frame_padtop + frame_padbottom)) ||
1588 (codec->pix_fmt != icodec->pix_fmt));
1589 if (ost->video_crop) {
1590 ost->topBand = frame_topBand;
1591 ost->leftBand = frame_leftBand;
1593 if (ost->video_pad) {
1594 ost->padtop = frame_padtop;
1595 ost->padleft = frame_padleft;
1596 ost->padbottom = frame_padbottom;
1597 ost->padright = frame_padright;
1598 if (!ost->video_resample) {
1599 avcodec_get_frame_defaults(&ost->pict_tmp);
1600 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1601 codec->width, codec->height ) )
1605 if (ost->video_resample) {
1606 avcodec_get_frame_defaults(&ost->pict_tmp);
1607 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1608 codec->width, codec->height ) )
1611 ost->img_resample_ctx = sws_getContext(
1612 icodec->width - (frame_leftBand + frame_rightBand),
1613 icodec->height - (frame_topBand + frame_bottomBand),
1615 codec->width - (frame_padleft + frame_padright),
1616 codec->height - (frame_padtop + frame_padbottom),
1618 sws_flags, NULL, NULL, NULL);
1619 if (ost->img_resample_ctx == NULL) {
1620 fprintf(stderr, "Cannot get resampling context\n");
1623 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1625 ost->encoding_needed = 1;
1626 ist->decoding_needed = 1;
1628 case CODEC_TYPE_SUBTITLE:
1629 ost->encoding_needed = 1;
1630 ist->decoding_needed = 1;
1637 if (ost->encoding_needed &&
1638 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1639 char logfilename[1024];
1644 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1646 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1647 if (codec->flags & CODEC_FLAG_PASS1) {
1648 f = fopen(logfilename, "w");
1650 perror(logfilename);
1655 /* read the log file */
1656 f = fopen(logfilename, "r");
1658 perror(logfilename);
1661 fseek(f, 0, SEEK_END);
1663 fseek(f, 0, SEEK_SET);
1664 logbuffer = av_malloc(size + 1);
1666 fprintf(stderr, "Could not allocate log buffer\n");
1669 size = fread(logbuffer, 1, size, f);
1671 logbuffer[size] = '\0';
1672 codec->stats_in = logbuffer;
1676 if(codec->codec_type == CODEC_TYPE_VIDEO){
1677 int size= codec->width * codec->height;
1678 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1683 bit_buffer = av_malloc(bit_buffer_size);
1687 /* dump the file output parameters - cannot be done before in case
1689 for(i=0;i<nb_output_files;i++) {
1690 dump_format(output_files[i], i, output_files[i]->filename, 1);
1693 /* dump the stream mapping */
1695 fprintf(stderr, "Stream mapping:\n");
1696 for(i=0;i<nb_ostreams;i++) {
1698 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1699 ist_table[ost->source_index]->file_index,
1700 ist_table[ost->source_index]->index,
1703 if (ost->sync_ist != ist_table[ost->source_index])
1704 fprintf(stderr, " [sync #%d.%d]",
1705 ost->sync_ist->file_index,
1706 ost->sync_ist->index);
1707 fprintf(stderr, "\n");
1711 /* open each encoder */
1712 for(i=0;i<nb_ostreams;i++) {
1714 if (ost->encoding_needed) {
1716 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1718 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1719 ost->file_index, ost->index);
1722 if (avcodec_open(ost->st->codec, codec) < 0) {
1723 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1724 ost->file_index, ost->index);
1727 extra_size += ost->st->codec->extradata_size;
1731 /* open each decoder */
1732 for(i=0;i<nb_istreams;i++) {
1734 if (ist->decoding_needed) {
1736 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1738 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1739 ist->st->codec->codec_id, ist->file_index, ist->index);
1742 if (avcodec_open(ist->st->codec, codec) < 0) {
1743 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1744 ist->file_index, ist->index);
1747 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1748 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1753 for(i=0;i<nb_istreams;i++) {
1755 is = input_files[ist->file_index];
1757 ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1758 if(ist->st->start_time == AV_NOPTS_VALUE)
1760 if(input_files_ts_offset[ist->file_index])
1761 ist->next_pts= AV_NOPTS_VALUE;
1765 /* set meta data information from input file if required */
1766 for (i=0;i<nb_meta_data_maps;i++) {
1767 AVFormatContext *out_file;
1768 AVFormatContext *in_file;
1770 int out_file_index = meta_data_maps[i].out_file;
1771 int in_file_index = meta_data_maps[i].in_file;
1772 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1773 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1774 ret = AVERROR(EINVAL);
1777 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1778 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1779 ret = AVERROR(EINVAL);
1783 out_file = output_files[out_file_index];
1784 in_file = input_files[in_file_index];
1786 strcpy(out_file->title, in_file->title);
1787 strcpy(out_file->author, in_file->author);
1788 strcpy(out_file->copyright, in_file->copyright);
1789 strcpy(out_file->comment, in_file->comment);
1790 strcpy(out_file->album, in_file->album);
1791 out_file->year = in_file->year;
1792 out_file->track = in_file->track;
1793 strcpy(out_file->genre, in_file->genre);
1796 /* open files and write file headers */
1797 for(i=0;i<nb_output_files;i++) {
1798 os = output_files[i];
1799 if (av_write_header(os) < 0) {
1800 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1801 ret = AVERROR(EINVAL);
1806 if ( !using_stdin && verbose >= 0) {
1807 fprintf(stderr, "Press [q] to stop encoding\n");
1808 url_set_interrupt_cb(decode_interrupt_cb);
1815 for(; received_sigterm == 0;) {
1816 int file_index, ist_index;
1824 /* if 'q' pressed, exits */
1828 /* read_key() returns 0 on EOF */
1834 /* select the stream that we must read now by looking at the
1835 smallest output pts */
1837 for(i=0;i<nb_ostreams;i++) {
1840 os = output_files[ost->file_index];
1841 ist = ist_table[ost->source_index];
1842 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1843 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1845 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1846 ipts = (double)ist->pts;
1847 if (!file_table[ist->file_index].eof_reached){
1848 if(ipts < ipts_min) {
1850 if(input_sync ) file_index = ist->file_index;
1852 if(opts < opts_min) {
1854 if(!input_sync) file_index = ist->file_index;
1857 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1862 /* if none, if is finished */
1863 if (file_index < 0) {
1867 /* finish if recording time exhausted */
1868 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1871 /* finish if limit size exhausted */
1872 if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
1875 /* read a frame from it and output it in the fifo */
1876 is = input_files[file_index];
1877 if (av_read_frame(is, &pkt) < 0) {
1878 file_table[file_index].eof_reached = 1;
1879 if (opt_shortest) break; else continue; //
1883 stream_no_data = is;
1888 av_pkt_dump(stdout, &pkt, do_hex_dump);
1890 /* the following test is needed in case new streams appear
1891 dynamically in stream : we ignore them */
1892 if (pkt.stream_index >= file_table[file_index].nb_streams)
1893 goto discard_packet;
1894 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1895 ist = ist_table[ist_index];
1897 goto discard_packet;
1899 // 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);
1900 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1901 int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
1902 if(FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
1903 input_files_ts_offset[ist->file_index]-= delta;
1905 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1906 for(i=0; i<file_table[file_index].nb_streams; i++){
1907 int index= file_table[file_index].ist_index + i;
1908 ist_table[index]->next_pts += delta;
1909 ist_table[index]->is_start=1;
1914 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1915 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1918 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1919 ist->file_index, ist->index);
1921 av_free_packet(&pkt);
1926 av_free_packet(&pkt);
1928 /* dump report by using the output first video and audio streams */
1929 print_report(output_files, ost_table, nb_ostreams, 0);
1932 /* at the end of stream, we must flush the decoder buffers */
1933 for(i=0;i<nb_istreams;i++) {
1935 if (ist->decoding_needed) {
1936 output_packet(ist, i, ost_table, nb_ostreams, NULL);
1942 /* write the trailer if needed and close file */
1943 for(i=0;i<nb_output_files;i++) {
1944 os = output_files[i];
1945 av_write_trailer(os);
1948 /* dump report by using the first video and audio streams */
1949 print_report(output_files, ost_table, nb_ostreams, 1);
1951 /* close each encoder */
1952 for(i=0;i<nb_ostreams;i++) {
1954 if (ost->encoding_needed) {
1955 av_freep(&ost->st->codec->stats_in);
1956 avcodec_close(ost->st->codec);
1960 /* close each decoder */
1961 for(i=0;i<nb_istreams;i++) {
1963 if (ist->decoding_needed) {
1964 avcodec_close(ist->st->codec);
1972 av_freep(&bit_buffer);
1973 av_free(file_table);
1976 for(i=0;i<nb_istreams;i++) {
1983 for(i=0;i<nb_ostreams;i++) {
1987 fclose(ost->logfile);
1988 ost->logfile = NULL;
1990 av_fifo_free(&ost->fifo); /* works even if fifo is not
1991 initialized but set to zero */
1992 av_free(ost->pict_tmp.data[0]);
1993 if (ost->video_resample)
1994 sws_freeContext(ost->img_resample_ctx);
1995 if (ost->audio_resample)
1996 audio_resample_close(ost->resample);
2004 ret = AVERROR(ENOMEM);
2009 int file_read(const char *filename)
2012 unsigned char buffer[1024];
2015 if (url_open(&h, filename, O_RDONLY) < 0) {
2016 printf("could not open '%s'\n", filename);
2020 len = url_read(h, buffer, sizeof(buffer));
2023 for(i=0;i<len;i++) putchar(buffer[i]);
2030 static void opt_format(const char *arg)
2032 /* compatibility stuff for pgmyuv */
2033 if (!strcmp(arg, "pgmyuv")) {
2034 pgmyuv_compatibility_hack=1;
2035 // opt_image_format(arg);
2039 file_iformat = av_find_input_format(arg);
2040 file_oformat = guess_format(arg, NULL, NULL);
2041 if (!file_iformat && !file_oformat) {
2042 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2047 static void opt_video_rc_eq(char *arg)
2052 static void opt_video_rc_override_string(char *arg)
2054 video_rc_override_string = arg;
2057 static void opt_me_threshold(const char *arg)
2059 me_threshold = atoi(arg);
2062 static void opt_verbose(const char *arg)
2064 verbose = atoi(arg);
2065 av_log_level = atoi(arg);
2068 static void opt_frame_rate(const char *arg)
2070 if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2071 fprintf(stderr, "Incorrect frame rate\n");
2076 static void opt_frame_crop_top(const char *arg)
2078 frame_topBand = atoi(arg);
2079 if (frame_topBand < 0) {
2080 fprintf(stderr, "Incorrect top crop size\n");
2083 if ((frame_topBand % 2) != 0) {
2084 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2087 if ((frame_topBand) >= frame_height){
2088 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2091 frame_height -= frame_topBand;
2094 static void opt_frame_crop_bottom(const char *arg)
2096 frame_bottomBand = atoi(arg);
2097 if (frame_bottomBand < 0) {
2098 fprintf(stderr, "Incorrect bottom crop size\n");
2101 if ((frame_bottomBand % 2) != 0) {
2102 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2105 if ((frame_bottomBand) >= frame_height){
2106 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2109 frame_height -= frame_bottomBand;
2112 static void opt_frame_crop_left(const char *arg)
2114 frame_leftBand = atoi(arg);
2115 if (frame_leftBand < 0) {
2116 fprintf(stderr, "Incorrect left crop size\n");
2119 if ((frame_leftBand % 2) != 0) {
2120 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2123 if ((frame_leftBand) >= frame_width){
2124 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2127 frame_width -= frame_leftBand;
2130 static void opt_frame_crop_right(const char *arg)
2132 frame_rightBand = atoi(arg);
2133 if (frame_rightBand < 0) {
2134 fprintf(stderr, "Incorrect right crop size\n");
2137 if ((frame_rightBand % 2) != 0) {
2138 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2141 if ((frame_rightBand) >= frame_width){
2142 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2145 frame_width -= frame_rightBand;
2148 static void opt_frame_size(const char *arg)
2150 if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2151 fprintf(stderr, "Incorrect frame size\n");
2154 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2155 fprintf(stderr, "Frame size must be a multiple of 2\n");
2161 #define SCALEBITS 10
2162 #define ONE_HALF (1 << (SCALEBITS - 1))
2163 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2165 #define RGB_TO_Y(r, g, b) \
2166 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2167 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2169 #define RGB_TO_U(r1, g1, b1, shift)\
2170 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2171 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2173 #define RGB_TO_V(r1, g1, b1, shift)\
2174 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2175 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2177 static void opt_pad_color(const char *arg) {
2178 /* Input is expected to be six hex digits similar to
2179 how colors are expressed in html tags (but without the #) */
2180 int rgb = strtol(arg, NULL, 16);
2184 g = ((rgb >> 8) & 255);
2187 padcolor[0] = RGB_TO_Y(r,g,b);
2188 padcolor[1] = RGB_TO_U(r,g,b,0);
2189 padcolor[2] = RGB_TO_V(r,g,b,0);
2192 static void opt_frame_pad_top(const char *arg)
2194 frame_padtop = atoi(arg);
2195 if (frame_padtop < 0) {
2196 fprintf(stderr, "Incorrect top pad size\n");
2199 if ((frame_padtop % 2) != 0) {
2200 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2205 static void opt_frame_pad_bottom(const char *arg)
2207 frame_padbottom = atoi(arg);
2208 if (frame_padbottom < 0) {
2209 fprintf(stderr, "Incorrect bottom pad size\n");
2212 if ((frame_padbottom % 2) != 0) {
2213 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2219 static void opt_frame_pad_left(const char *arg)
2221 frame_padleft = atoi(arg);
2222 if (frame_padleft < 0) {
2223 fprintf(stderr, "Incorrect left pad size\n");
2226 if ((frame_padleft % 2) != 0) {
2227 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2233 static void opt_frame_pad_right(const char *arg)
2235 frame_padright = atoi(arg);
2236 if (frame_padright < 0) {
2237 fprintf(stderr, "Incorrect right pad size\n");
2240 if ((frame_padright % 2) != 0) {
2241 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2247 static void opt_frame_pix_fmt(const char *arg)
2249 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2252 static void opt_frame_aspect_ratio(const char *arg)
2258 p = strchr(arg, ':');
2260 x = strtol(arg, (char **)&arg, 10);
2262 y = strtol(arg+1, (char **)&arg, 10);
2264 ar = (double)x / (double)y;
2266 ar = strtod(arg, (char **)&arg);
2269 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2272 frame_aspect_ratio = ar;
2275 static void opt_qscale(const char *arg)
2277 video_qscale = atof(arg);
2278 if (video_qscale <= 0 ||
2279 video_qscale > 255) {
2280 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2285 static void opt_qdiff(const char *arg)
2287 video_qdiff = atoi(arg);
2288 if (video_qdiff < 0 ||
2290 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2295 static void opt_strict(const char *arg)
2300 static void opt_top_field_first(const char *arg)
2302 top_field_first= atoi(arg);
2305 static void opt_thread_count(const char *arg)
2307 thread_count= atoi(arg);
2308 #if !defined(HAVE_THREADS)
2310 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2314 static void opt_audio_rate(const char *arg)
2316 audio_sample_rate = atoi(arg);
2319 static void opt_audio_channels(const char *arg)
2321 audio_channels = atoi(arg);
2324 static void opt_video_channel(const char *arg)
2326 video_channel = strtol(arg, NULL, 0);
2329 static void opt_video_standard(const char *arg)
2331 video_standard = av_strdup(arg);
2334 static void opt_codec(int *pstream_copy, int *pcodec_id,
2335 int codec_type, const char *arg)
2339 if (!strcmp(arg, "copy")) {
2344 if (!strcmp(p->name, arg) && p->type == codec_type)
2349 fprintf(stderr, "Unknown codec '%s'\n", arg);
2357 static void opt_audio_codec(const char *arg)
2359 opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2362 static void opt_audio_tag(const char *arg)
2365 audio_codec_tag= strtol(arg, &tail, 0);
2368 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2371 static void opt_video_tag(const char *arg)
2374 video_codec_tag= strtol(arg, &tail, 0);
2377 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2380 static void add_frame_hooker(const char *arg)
2385 char *args = av_strdup(arg);
2389 argv[0] = strtok(args, " ");
2390 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2393 i = frame_hook_add(argc, argv);
2396 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2401 const char *motion_str[] = {
2414 static void opt_motion_estimation(const char *arg)
2420 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2423 if (!strcmp(*p, arg))
2427 me_method = (p - motion_str) + 1;
2430 static void opt_video_codec(const char *arg)
2432 opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2435 static void opt_subtitle_codec(const char *arg)
2437 opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2440 static void opt_map(const char *arg)
2446 m = &stream_maps[nb_stream_maps++];
2448 m->file_index = strtol(arg, (char **)&p, 0);
2452 m->stream_index = strtol(p, (char **)&p, 0);
2455 m->sync_file_index = strtol(p, (char **)&p, 0);
2458 m->sync_stream_index = strtol(p, (char **)&p, 0);
2460 m->sync_file_index = m->file_index;
2461 m->sync_stream_index = m->stream_index;
2465 static void opt_map_meta_data(const char *arg)
2471 m = &meta_data_maps[nb_meta_data_maps++];
2473 m->out_file = strtol(arg, (char **)&p, 0);
2477 m->in_file = strtol(p, (char **)&p, 0);
2480 static void opt_recording_time(const char *arg)
2482 recording_time = parse_date(arg, 1);
2485 static void opt_start_time(const char *arg)
2487 start_time = parse_date(arg, 1);
2490 static void opt_rec_timestamp(const char *arg)
2492 rec_timestamp = parse_date(arg, 0) / 1000000;
2495 static void opt_input_ts_offset(const char *arg)
2497 input_ts_offset = parse_date(arg, 1);
2500 static void opt_input_file(const char *filename)
2502 AVFormatContext *ic;
2503 AVFormatParameters params, *ap = ¶ms;
2504 int err, i, ret, rfps, rfps_base;
2507 if (!strcmp(filename, "-"))
2510 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2511 !strcmp( filename, "/dev/stdin" );
2513 /* get default parameters from command line */
2514 ic = av_alloc_format_context();
2516 memset(ap, 0, sizeof(*ap));
2517 ap->prealloced_context = 1;
2518 ap->sample_rate = audio_sample_rate;
2519 ap->channels = audio_channels;
2520 ap->time_base.den = frame_rate;
2521 ap->time_base.num = frame_rate_base;
2522 ap->width = frame_width + frame_padleft + frame_padright;
2523 ap->height = frame_height + frame_padtop + frame_padbottom;
2524 ap->pix_fmt = frame_pix_fmt;
2525 ap->channel = video_channel;
2526 ap->standard = video_standard;
2527 ap->video_codec_id = video_codec_id;
2528 ap->audio_codec_id = audio_codec_id;
2529 if(pgmyuv_compatibility_hack)
2530 ap->video_codec_id= CODEC_ID_PGMYUV;
2532 for(i=0; i<opt_name_count; i++){
2533 const AVOption *opt;
2534 double d= av_get_double(avformat_opts, opt_names[i], &opt);
2535 if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2536 av_set_double(ic, opt_names[i], d);
2538 /* open the input file with generic libav function */
2539 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2541 print_error(filename, err);
2545 ic->loop_input = loop_input;
2547 /* If not enough info to get the stream parameters, we decode the
2548 first frames to get it. (used in mpeg case for example) */
2549 ret = av_find_stream_info(ic);
2550 if (ret < 0 && verbose >= 0) {
2551 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2555 timestamp = start_time;
2556 /* add the stream start time */
2557 if (ic->start_time != AV_NOPTS_VALUE)
2558 timestamp += ic->start_time;
2560 /* if seeking requested, we execute it */
2561 if (start_time != 0) {
2562 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2564 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2565 filename, (double)timestamp / AV_TIME_BASE);
2567 /* reset seek info */
2571 /* update the current parameters so that they match the one of the input stream */
2572 for(i=0;i<ic->nb_streams;i++) {
2574 AVCodecContext *enc = ic->streams[i]->codec;
2575 #if defined(HAVE_THREADS)
2577 avcodec_thread_init(enc, thread_count);
2579 enc->thread_count= thread_count;
2580 switch(enc->codec_type) {
2581 case CODEC_TYPE_AUDIO:
2582 for(j=0; j<opt_name_count; j++){
2583 const AVOption *opt;
2584 double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[j], &opt);
2585 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2586 av_set_double(enc, opt_names[j], d);
2588 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2589 audio_channels = enc->channels;
2590 audio_sample_rate = enc->sample_rate;
2592 ic->streams[i]->discard= AVDISCARD_ALL;
2594 case CODEC_TYPE_VIDEO:
2595 for(j=0; j<opt_name_count; j++){
2596 const AVOption *opt;
2597 double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[j], &opt);
2598 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2599 av_set_double(enc, opt_names[j], d);
2601 frame_height = enc->height;
2602 frame_width = enc->width;
2603 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2604 frame_pix_fmt = enc->pix_fmt;
2605 rfps = ic->streams[i]->r_frame_rate.num;
2606 rfps_base = ic->streams[i]->r_frame_rate.den;
2607 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2609 enc->debug |= FF_DEBUG_MV;
2611 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2614 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2615 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2617 (float)rfps / rfps_base, rfps, rfps_base);
2619 /* update the current frame rate to match the stream frame rate */
2621 frame_rate_base = rfps_base;
2623 enc->rate_emu = rate_emu;
2625 ic->streams[i]->discard= AVDISCARD_ALL;
2626 else if(video_discard)
2627 ic->streams[i]->discard= video_discard;
2629 case CODEC_TYPE_DATA:
2631 case CODEC_TYPE_SUBTITLE:
2633 case CODEC_TYPE_UNKNOWN:
2640 input_files[nb_input_files] = ic;
2641 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2642 /* dump the file content */
2644 dump_format(ic, nb_input_files, filename, 0);
2647 file_iformat = NULL;
2648 file_oformat = NULL;
2655 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2657 int has_video, has_audio, i, j;
2658 AVFormatContext *ic;
2662 for(j=0;j<nb_input_files;j++) {
2663 ic = input_files[j];
2664 for(i=0;i<ic->nb_streams;i++) {
2665 AVCodecContext *enc = ic->streams[i]->codec;
2666 switch(enc->codec_type) {
2667 case CODEC_TYPE_AUDIO:
2670 case CODEC_TYPE_VIDEO:
2673 case CODEC_TYPE_DATA:
2674 case CODEC_TYPE_UNKNOWN:
2675 case CODEC_TYPE_SUBTITLE:
2682 *has_video_ptr = has_video;
2683 *has_audio_ptr = has_audio;
2686 static void new_video_stream(AVFormatContext *oc)
2689 AVCodecContext *video_enc;
2692 st = av_new_stream(oc, oc->nb_streams);
2694 fprintf(stderr, "Could not alloc stream\n");
2697 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2698 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2699 video_bitstream_filters= NULL;
2701 #if defined(HAVE_THREADS)
2703 avcodec_thread_init(st->codec, thread_count);
2706 video_enc = st->codec;
2709 video_enc->codec_tag= video_codec_tag;
2711 if( (video_global_header&1)
2712 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2713 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2714 avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2716 if(video_global_header&2){
2717 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2718 avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2721 if (video_stream_copy) {
2722 st->stream_copy = 1;
2723 video_enc->codec_type = CODEC_TYPE_VIDEO;
2729 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2730 if (video_codec_id != CODEC_ID_NONE)
2731 codec_id = video_codec_id;
2733 video_enc->codec_id = codec_id;
2734 codec = avcodec_find_encoder(codec_id);
2736 for(i=0; i<opt_name_count; i++){
2737 const AVOption *opt;
2738 double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt);
2739 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2740 av_set_double(video_enc, opt_names[i], d);
2743 video_enc->time_base.den = frame_rate;
2744 video_enc->time_base.num = frame_rate_base;
2745 if(codec && codec->supported_framerates){
2746 const AVRational *p= codec->supported_framerates;
2747 AVRational req= (AVRational){frame_rate, frame_rate_base};
2748 const AVRational *best=NULL;
2749 AVRational best_error= (AVRational){INT_MAX, 1};
2750 for(; p->den!=0; p++){
2751 AVRational error= av_sub_q(req, *p);
2752 if(error.num <0) error.num *= -1;
2753 if(av_cmp_q(error, best_error) < 0){
2758 video_enc->time_base.den= best->num;
2759 video_enc->time_base.num= best->den;
2762 video_enc->width = frame_width + frame_padright + frame_padleft;
2763 video_enc->height = frame_height + frame_padtop + frame_padbottom;
2764 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2765 video_enc->pix_fmt = frame_pix_fmt;
2767 if(codec && codec->pix_fmts){
2768 const enum PixelFormat *p= codec->pix_fmts;
2770 if(*p == video_enc->pix_fmt)
2774 video_enc->pix_fmt = codec->pix_fmts[0];
2778 video_enc->gop_size = 0;
2779 if (video_qscale || same_quality) {
2780 video_enc->flags |= CODEC_FLAG_QSCALE;
2781 video_enc->global_quality=
2782 st->quality = FF_QP2LAMBDA * video_qscale;
2786 video_enc->intra_matrix = intra_matrix;
2788 video_enc->inter_matrix = inter_matrix;
2790 video_enc->max_qdiff = video_qdiff;
2791 video_enc->rc_eq = video_rc_eq;
2792 video_enc->thread_count = thread_count;
2793 p= video_rc_override_string;
2796 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2798 fprintf(stderr, "error parsing rc_override\n");
2801 video_enc->rc_override=
2802 av_realloc(video_enc->rc_override,
2803 sizeof(RcOverride)*(i+1));
2804 video_enc->rc_override[i].start_frame= start;
2805 video_enc->rc_override[i].end_frame = end;
2807 video_enc->rc_override[i].qscale= q;
2808 video_enc->rc_override[i].quality_factor= 1.0;
2811 video_enc->rc_override[i].qscale= 0;
2812 video_enc->rc_override[i].quality_factor= -q/100.0;
2817 video_enc->rc_override_count=i;
2818 if (!video_enc->rc_initial_buffer_occupancy)
2819 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2820 video_enc->me_threshold= me_threshold;
2821 video_enc->intra_dc_precision= intra_dc_precision - 8;
2822 video_enc->strict_std_compliance = strict;
2825 video_enc->flags|= CODEC_FLAG_PSNR;
2827 video_enc->me_method = me_method;
2832 video_enc->flags |= CODEC_FLAG_PASS1;
2834 video_enc->flags |= CODEC_FLAG_PASS2;
2839 /* reset some key parameters */
2841 video_codec_id = CODEC_ID_NONE;
2842 video_stream_copy = 0;
2845 static void new_audio_stream(AVFormatContext *oc)
2848 AVCodecContext *audio_enc;
2851 st = av_new_stream(oc, oc->nb_streams);
2853 fprintf(stderr, "Could not alloc stream\n");
2856 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
2858 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2859 audio_bitstream_filters= NULL;
2861 #if defined(HAVE_THREADS)
2863 avcodec_thread_init(st->codec, thread_count);
2866 audio_enc = st->codec;
2867 audio_enc->codec_type = CODEC_TYPE_AUDIO;
2868 audio_enc->strict_std_compliance = strict;
2871 audio_enc->codec_tag= audio_codec_tag;
2873 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
2874 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2875 avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2877 if (audio_stream_copy) {
2878 st->stream_copy = 1;
2879 audio_enc->channels = audio_channels;
2881 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
2883 for(i=0; i<opt_name_count; i++){
2884 const AVOption *opt;
2885 double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt);
2886 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2887 av_set_double(audio_enc, opt_names[i], d);
2890 if (audio_codec_id != CODEC_ID_NONE)
2891 codec_id = audio_codec_id;
2892 audio_enc->codec_id = codec_id;
2894 if (audio_qscale > QSCALE_NONE) {
2895 audio_enc->flags |= CODEC_FLAG_QSCALE;
2896 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
2898 audio_enc->thread_count = thread_count;
2899 audio_enc->channels = audio_channels;
2901 audio_enc->sample_rate = audio_sample_rate;
2902 audio_enc->time_base= (AVRational){1, audio_sample_rate};
2903 if (audio_language) {
2904 pstrcpy(st->language, sizeof(st->language), audio_language);
2905 av_free(audio_language);
2906 audio_language = NULL;
2909 /* reset some key parameters */
2911 audio_codec_id = CODEC_ID_NONE;
2912 audio_stream_copy = 0;
2915 static void opt_new_subtitle_stream(void)
2917 AVFormatContext *oc;
2919 AVCodecContext *subtitle_enc;
2922 if (nb_output_files <= 0) {
2923 fprintf(stderr, "At least one output file must be specified\n");
2926 oc = output_files[nb_output_files - 1];
2928 st = av_new_stream(oc, oc->nb_streams);
2930 fprintf(stderr, "Could not alloc stream\n");
2933 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
2935 subtitle_enc = st->codec;
2936 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
2937 if (subtitle_stream_copy) {
2938 st->stream_copy = 1;
2940 for(i=0; i<opt_name_count; i++){
2941 const AVOption *opt;
2942 double d= av_get_double(avctx_opts[CODEC_TYPE_SUBTITLE], opt_names[i], &opt);
2943 if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2944 av_set_double(subtitle_enc, opt_names[i], d);
2946 subtitle_enc->codec_id = subtitle_codec_id;
2949 if (subtitle_language) {
2950 pstrcpy(st->language, sizeof(st->language), subtitle_language);
2951 av_free(subtitle_language);
2952 subtitle_language = NULL;
2955 subtitle_codec_id = CODEC_ID_NONE;
2956 subtitle_stream_copy = 0;
2959 static void opt_new_audio_stream(void)
2961 AVFormatContext *oc;
2962 if (nb_output_files <= 0) {
2963 fprintf(stderr, "At least one output file must be specified\n");
2966 oc = output_files[nb_output_files - 1];
2967 new_audio_stream(oc);
2970 static void opt_new_video_stream(void)
2972 AVFormatContext *oc;
2973 if (nb_output_files <= 0) {
2974 fprintf(stderr, "At least one output file must be specified\n");
2977 oc = output_files[nb_output_files - 1];
2978 new_video_stream(oc);
2981 static void opt_output_file(const char *filename)
2983 AVFormatContext *oc;
2984 int use_video, use_audio, input_has_video, input_has_audio, i;
2985 AVFormatParameters params, *ap = ¶ms;
2987 if (!strcmp(filename, "-"))
2990 oc = av_alloc_format_context();
2992 if (!file_oformat) {
2993 file_oformat = guess_format(NULL, filename, NULL);
2994 if (!file_oformat) {
2995 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3001 oc->oformat = file_oformat;
3002 pstrcpy(oc->filename, sizeof(oc->filename), filename);
3004 if (!strcmp(file_oformat->name, "ffm") &&
3005 strstart(filename, "http:", NULL)) {
3006 /* special case for files sent to ffserver: we get the stream
3007 parameters from ffserver */
3008 if (read_ffserver_streams(oc, filename) < 0) {
3009 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3013 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3014 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3016 /* disable if no corresponding type found and at least one
3018 if (nb_input_files > 0) {
3019 check_audio_video_inputs(&input_has_video, &input_has_audio);
3020 if (!input_has_video)
3022 if (!input_has_audio)
3026 /* manual disable */
3027 if (audio_disable) {
3030 if (video_disable) {
3035 new_video_stream(oc);
3039 new_audio_stream(oc);
3042 oc->timestamp = rec_timestamp;
3045 pstrcpy(oc->title, sizeof(oc->title), str_title);
3047 pstrcpy(oc->author, sizeof(oc->author), str_author);
3049 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3051 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3053 pstrcpy(oc->album, sizeof(oc->album), str_album);
3056 output_files[nb_output_files++] = oc;
3058 /* check filename in case of an image number is expected */
3059 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3060 if (!av_filename_number_test(oc->filename)) {
3061 print_error(oc->filename, AVERROR_NUMEXPECTED);
3066 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3067 /* test if it already exists to avoid loosing precious files */
3068 if (!file_overwrite &&
3069 (strchr(filename, ':') == NULL ||
3070 strstart(filename, "file:", NULL))) {
3071 if (url_exist(filename)) {
3074 if ( !using_stdin ) {
3075 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3078 if (toupper(c) != 'Y') {
3079 fprintf(stderr, "Not overwriting - exiting\n");
3084 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3091 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3092 fprintf(stderr, "Could not open '%s'\n", filename);
3097 memset(ap, 0, sizeof(*ap));
3098 if (av_set_parameters(oc, ap) < 0) {
3099 fprintf(stderr, "%s: Invalid encoding parameters\n",
3104 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3105 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3106 oc->loop_output = loop_output;
3108 for(i=0; i<opt_name_count; i++){
3109 const AVOption *opt;
3110 double d = av_get_double(avformat_opts, opt_names[i], &opt);
3111 if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3112 av_set_double(oc, opt_names[i], d);
3115 /* reset some options */
3116 file_oformat = NULL;
3117 file_iformat = NULL;
3120 /* same option as mencoder */
3121 static void opt_pass(const char *pass_str)
3124 pass = atoi(pass_str);
3125 if (pass != 1 && pass != 2) {
3126 fprintf(stderr, "pass number can be only 1 or 2\n");
3132 #if defined(__MINGW32__) || defined(CONFIG_OS2)
3133 static int64_t getutime(void)
3135 return av_gettime();
3138 static int64_t getutime(void)
3140 struct rusage rusage;
3142 getrusage(RUSAGE_SELF, &rusage);
3143 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3147 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3148 extern int ffm_nopts;
3151 static void show_formats(void)
3153 AVInputFormat *ifmt;
3154 AVOutputFormat *ofmt;
3157 const char **pp, *last_name;
3159 printf("File formats:\n");
3164 const char *name=NULL;
3165 const char *long_name=NULL;
3167 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3168 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3169 strcmp(ofmt->name, last_name)>0){
3171 long_name= ofmt->long_name;
3175 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3176 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3177 strcmp(ifmt->name, last_name)>0){
3179 long_name= ifmt->long_name;
3182 if(name && strcmp(ifmt->name, name)==0)
3194 long_name ? long_name:" ");
3198 printf("Codecs:\n");
3204 const char *type_str;
3207 for(p = first_avcodec; p != NULL; p = p->next) {
3208 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3209 strcmp(p->name, last_name)>0){
3211 decode= encode= cap=0;
3213 if(p2 && strcmp(p->name, p2->name)==0){
3214 if(p->decode) decode=1;
3215 if(p->encode) encode=1;
3216 cap |= p->capabilities;
3221 last_name= p2->name;
3224 case CODEC_TYPE_VIDEO:
3227 case CODEC_TYPE_AUDIO:
3230 case CODEC_TYPE_SUBTITLE:
3239 decode ? "D": (/*p2->decoder ? "d":*/" "),
3242 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3243 cap & CODEC_CAP_DR1 ? "D":" ",
3244 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3246 /* if(p2->decoder && decode==0)
3247 printf(" use %s for decoding", p2->decoder->name);*/
3252 printf("Supported file protocols:\n");
3253 for(up = first_protocol; up != NULL; up = up->next)
3254 printf(" %s:", up->name);
3257 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3258 printf("Motion estimation methods:\n");
3262 if ((pp - motion_str + 1) == ME_ZERO)
3263 printf("(fastest)");
3264 else if ((pp - motion_str + 1) == ME_FULL)
3265 printf("(slowest)");
3266 else if ((pp - motion_str + 1) == ME_EPZS)
3267 printf("(default)");
3272 "Note, the names of encoders and decoders dont always match, so there are\n"
3273 "several cases where the above table shows encoder only or decoder only entries\n"
3274 "even though both encoding and decoding are supported for example, the h263\n"
3275 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3280 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3283 const char *p = str;
3290 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3297 static void opt_inter_matrix(const char *arg)
3299 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3300 parse_matrix_coeffs(inter_matrix, arg);
3303 static void opt_intra_matrix(const char *arg)
3305 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3306 parse_matrix_coeffs(intra_matrix, arg);
3309 static void opt_target(const char *arg)
3312 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3314 if(!strncmp(arg, "pal-", 4)) {
3317 } else if(!strncmp(arg, "ntsc-", 5)) {
3320 } else if(!strncmp(arg, "film-", 5)) {
3325 /* Calculate FR via float to avoid int overflow */
3326 fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3329 } else if((fr == 29970) || (fr == 23976)) {
3332 /* Try to determine PAL/NTSC by peeking in the input files */
3333 if(nb_input_files) {
3335 for(j = 0; j < nb_input_files; j++) {
3336 for(i = 0; i < input_files[j]->nb_streams; i++) {
3337 AVCodecContext *c = input_files[j]->streams[i]->codec;
3338 if(c->codec_type != CODEC_TYPE_VIDEO)
3340 fr = c->time_base.den * 1000 / c->time_base.num;
3344 } else if((fr == 29970) || (fr == 23976)) {
3354 if(verbose && norm >= 0)
3355 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3359 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3360 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3361 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3365 if(!strcmp(arg, "vcd")) {
3367 opt_video_codec("mpeg1video");
3368 opt_audio_codec("mp2");
3371 opt_frame_size(norm ? "352x240" : "352x288");
3372 opt_frame_rate(frame_rates[norm]);
3373 opt_default("gop", norm ? "18" : "15");
3375 opt_default("b", "1150000");
3376 opt_default("maxrate", "1150000");
3377 opt_default("minrate", "1150000");
3378 opt_default("bufsize", "327680"); // 40*1024*8;
3380 opt_default("ab", "224000");
3381 audio_sample_rate = 44100;
3384 opt_default("packetsize", "2324");
3385 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3387 /* We have to offset the PTS, so that it is consistent with the SCR.
3388 SCR starts at 36000, but the first two packs contain only padding
3389 and the first pack from the other stream, respectively, may also have
3390 been written before.
3391 So the real data starts at SCR 36000+3*1200. */
3392 mux_preload= (36000+3*1200) / 90000.0; //0.44
3393 } else if(!strcmp(arg, "svcd")) {
3395 opt_video_codec("mpeg2video");
3396 opt_audio_codec("mp2");
3399 opt_frame_size(norm ? "480x480" : "480x576");
3400 opt_frame_rate(frame_rates[norm]);
3401 opt_default("gop", norm ? "18" : "15");
3403 opt_default("b", "2040000");
3404 opt_default("maxrate", "2516000");
3405 opt_default("minrate", "0"); //1145000;
3406 opt_default("bufsize", "1835008"); //224*1024*8;
3407 opt_default("flags", "+SCAN_OFFSET");
3410 opt_default("ab", "224000");
3411 audio_sample_rate = 44100;
3413 opt_default("packetsize", "2324");
3415 } else if(!strcmp(arg, "dvd")) {
3417 opt_video_codec("mpeg2video");
3418 opt_audio_codec("ac3");
3421 opt_frame_size(norm ? "720x480" : "720x576");
3422 opt_frame_rate(frame_rates[norm]);
3423 opt_default("gop", norm ? "18" : "15");
3425 opt_default("b", "6000000");
3426 opt_default("maxrate", "9000000");
3427 opt_default("minrate", "0"); //1500000;
3428 opt_default("bufsize", "1835008"); //224*1024*8;
3430 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3431 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3433 opt_default("ab", "448000");
3434 audio_sample_rate = 48000;
3436 } else if(!strncmp(arg, "dv", 2)) {
3440 opt_frame_size(norm ? "720x480" : "720x576");
3441 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3442 (norm ? "yuv411p" : "yuv420p"));
3443 opt_frame_rate(frame_rates[norm]);
3445 audio_sample_rate = 48000;
3449 fprintf(stderr, "Unknown target: %s\n", arg);
3454 static void opt_video_bsf(const char *arg)
3456 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3457 AVBitStreamFilterContext **bsfp;
3460 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3464 bsfp= &video_bitstream_filters;
3466 bsfp= &(*bsfp)->next;
3471 //FIXME avoid audio - video code duplication
3472 static void opt_audio_bsf(const char *arg)
3474 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3475 AVBitStreamFilterContext **bsfp;
3478 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3482 bsfp= &audio_bitstream_filters;
3484 bsfp= &(*bsfp)->next;
3489 static void show_version(void)
3491 /* TODO: add function interface to avutil and avformat */
3492 fprintf(stderr, "ffmpeg " FFMPEG_VERSION "\n"
3496 LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3500 static int opt_default(const char *opt, const char *arg){
3502 const AVOption *o= NULL;
3503 int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
3505 for(type=0; type<CODEC_TYPE_NB; type++){
3506 const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
3508 o = av_set_string(avctx_opts[type], opt, arg);
3511 o = av_set_string(avformat_opts, opt, arg);
3514 o = av_set_string(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg);
3515 else if(opt[0] == 'v')
3516 o = av_set_string(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg);
3517 else if(opt[0] == 's')
3518 o = av_set_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg);
3523 // 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));
3525 //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
3526 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
3527 opt_names[opt_name_count++]= o->name;
3529 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3530 /* disable generate of real time pts in ffm (need to be supressed anyway) */
3531 if(avctx_opts[0]->flags & CODEC_FLAG_BITEXACT)
3535 if(avctx_opts[0]->debug)
3536 av_log_level = AV_LOG_DEBUG;
3540 const OptionDef options[] = {
3542 { "L", 0, {(void*)show_license}, "show license" },
3543 { "h", 0, {(void*)show_help}, "show help" },
3544 { "version", 0, {(void*)show_version}, "show version" },
3545 { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3546 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3547 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3548 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3549 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3550 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3551 { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3552 { "fs", HAS_ARG | OPT_INT, {(void*)&limit_filesize}, "set the limit file size", "limit_size" }, //
3553 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3554 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3555 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3556 { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3557 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3558 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3559 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3560 { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3561 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3562 "add timings for benchmarking" },
3563 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3564 "dump each input packet" },
3565 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3566 "when dumping packets, also dump the payload" },
3567 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3568 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3569 { "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)", "" },
3570 { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3571 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3572 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3573 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3574 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3575 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3576 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3577 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3578 { "dts_delta_threshold", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
3581 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3582 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3583 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3584 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3585 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3586 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3587 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3588 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3589 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3590 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3591 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3592 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3593 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3594 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3595 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3596 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3597 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3598 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3599 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3600 { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantizer scale (VBR)", "q" },
3601 { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3602 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3603 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3604 { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
3606 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "" },
3607 { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3608 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3609 "use same video quality as source (implies VBR)" },
3610 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3611 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3612 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3613 "deinterlace pictures" },
3614 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3615 { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
3616 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3617 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3618 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3619 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3620 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3621 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3622 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3623 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3626 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3627 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3628 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3629 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3630 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3631 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3632 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3633 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3634 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3635 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3637 /* subtitle options */
3638 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3639 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3640 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3643 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3644 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3645 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3648 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3649 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3651 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
3652 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
3654 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3658 static void show_banner(void)
3660 fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2007 Fabrice Bellard, et al.\n");
3661 fprintf(stderr, " configuration: " FFMPEG_CONFIGURATION "\n");
3662 fprintf(stderr, " libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
3663 fprintf(stderr, " libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
3664 fprintf(stderr, " libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
3665 fprintf(stderr, " built on " __DATE__ " " __TIME__);
3667 fprintf(stderr, ", gcc: " __VERSION__ "\n");
3669 fprintf(stderr, ", using a non-gcc compiler\n");
3673 static void show_license(void)
3678 "FFmpeg is free software; you can redistribute it and/or modify\n"
3679 "it under the terms of the GNU General Public License as published by\n"
3680 "the Free Software Foundation; either version 2 of the License, or\n"
3681 "(at your option) any later version.\n"
3683 "FFmpeg is distributed in the hope that it will be useful,\n"
3684 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3685 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
3686 "GNU General Public License for more details.\n"
3688 "You should have received a copy of the GNU General Public License\n"
3689 "along with FFmpeg; if not, write to the Free Software\n"
3690 "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n"
3694 "FFmpeg is free software; you can redistribute it and/or\n"
3695 "modify it under the terms of the GNU Lesser General Public\n"
3696 "License as published by the Free Software Foundation; either\n"
3697 "version 2.1 of the License, or (at your option) any later version.\n"
3699 "FFmpeg is distributed in the hope that it will be useful,\n"
3700 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3701 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
3702 "Lesser General Public License for more details.\n"
3704 "You should have received a copy of the GNU Lesser General Public\n"
3705 "License along with FFmpeg; if not, write to the Free Software\n"
3706 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
3712 static void show_help(void)
3715 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3716 "Hyper fast Audio and Video encoder\n");
3718 show_help_options(options, "Main options:\n",
3719 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3720 show_help_options(options, "\nVideo options:\n",
3721 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3723 show_help_options(options, "\nAdvanced Video options:\n",
3724 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3725 OPT_VIDEO | OPT_EXPERT);
3726 show_help_options(options, "\nAudio options:\n",
3727 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3729 show_help_options(options, "\nAdvanced Audio options:\n",
3730 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3731 OPT_AUDIO | OPT_EXPERT);
3732 show_help_options(options, "\nSubtitle options:\n",
3733 OPT_SUBTITLE | OPT_GRAB,
3735 show_help_options(options, "\nAudio/Video grab options:\n",
3738 show_help_options(options, "\nAdvanced options:\n",
3739 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3741 av_opt_show(avctx_opts[0], NULL);
3742 av_opt_show(avformat_opts, NULL);
3747 void parse_arg_file(const char *filename)
3749 opt_output_file(filename);
3752 int main(int argc, char **argv)
3759 for(i=0; i<CODEC_TYPE_NB; i++){
3760 avctx_opts[i]= avcodec_alloc_context2(i);
3762 avformat_opts = av_alloc_format_context();
3770 parse_options(argc, argv, options);
3772 /* file converter / grab */
3773 if (nb_output_files <= 0) {
3774 fprintf(stderr, "Must supply at least one output file\n");
3778 if (nb_input_files == 0) {
3779 fprintf(stderr, "Must supply at least one input file\n");
3784 av_encode(output_files, nb_output_files, input_files, nb_input_files,
3785 stream_maps, nb_stream_maps);
3786 ti = getutime() - ti;
3788 printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3792 for(i=0;i<nb_output_files;i++) {
3793 /* maybe av_close_output_file ??? */
3794 AVFormatContext *s = output_files[i];
3796 if (!(s->oformat->flags & AVFMT_NOFILE))
3798 for(j=0;j<s->nb_streams;j++) {
3799 av_free(s->streams[j]->codec);
3800 av_free(s->streams[j]);
3804 for(i=0;i<nb_input_files;i++)
3805 av_close_input_file(input_files[i]);
3809 av_free(intra_matrix);
3810 av_free(inter_matrix);
3813 #ifdef CONFIG_POWERPC_PERF
3814 extern void powerpc_display_perf_report(void);
3815 powerpc_display_perf_report();
3816 #endif /* CONFIG_POWERPC_PERF */
3818 if (received_sigterm) {
3820 "Received signal %d: terminating.\n",
3821 (int) received_sigterm);
3825 exit(0); /* not all OS-es handle main() return value */