3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 #define HAVE_AV_CONFIG_H
22 #include "framehook.h"
29 #include <sys/ioctl.h>
32 #include <sys/resource.h>
36 #include <sys/types.h>
37 #include <sys/select.h>
40 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
48 #if !defined(INFINITY) && defined(HUGE_VAL)
49 #define INFINITY HUGE_VAL
52 /* select an input stream for an output stream */
53 typedef struct AVStreamMap {
57 int sync_stream_index;
60 /** select an input file for an output file */
61 typedef struct AVMetaDataMap {
66 extern const OptionDef options[];
68 static void show_help(void);
69 static void show_license(void);
70 static int opt_default(const char *opt, const char *arg);
74 static AVFormatContext *input_files[MAX_FILES];
75 static int64_t input_files_ts_offset[MAX_FILES];
76 static int nb_input_files = 0;
78 static AVFormatContext *output_files[MAX_FILES];
79 static int nb_output_files = 0;
81 static AVStreamMap stream_maps[MAX_FILES];
82 static int nb_stream_maps;
84 static AVMetaDataMap meta_data_maps[MAX_FILES];
85 static int nb_meta_data_maps;
87 static AVInputFormat *file_iformat;
88 static AVOutputFormat *file_oformat;
89 static AVImageFormat *image_format;
90 static int frame_width = 0;
91 static int frame_height = 0;
92 static float frame_aspect_ratio = 0;
93 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
94 static int frame_padtop = 0;
95 static int frame_padbottom = 0;
96 static int frame_padleft = 0;
97 static int frame_padright = 0;
98 static int padcolor[3] = {16,128,128}; /* default to black */
99 static int frame_topBand = 0;
100 static int frame_bottomBand = 0;
101 static int frame_leftBand = 0;
102 static int frame_rightBand = 0;
103 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
104 static int frame_rate = 25;
105 static int frame_rate_base = 1;
106 static int video_bit_rate = 200*1000;
107 static int video_bit_rate_tolerance = 4000*1000;
108 static float video_qscale = 0;
109 static int video_qmin = 2;
110 static int video_qmax = 31;
111 static int video_lmin = 2*FF_QP2LAMBDA;
112 static int video_lmax = 31*FF_QP2LAMBDA;
113 static int video_mb_lmin = 2*FF_QP2LAMBDA;
114 static int video_mb_lmax = 31*FF_QP2LAMBDA;
115 static int video_qdiff = 3;
116 static float video_qblur = 0.5;
117 static float video_qsquish = 0.0;
118 static float video_qcomp = 0.5;
119 static uint16_t *intra_matrix = NULL;
120 static uint16_t *inter_matrix = NULL;
121 #if 0 //experimental, (can be removed)
122 static float video_rc_qsquish=1.0;
123 static float video_rc_qmod_amp=0;
124 static int video_rc_qmod_freq=0;
126 static char *video_rc_override_string=NULL;
127 static char *video_rc_eq="tex^qComp";
128 static int video_rc_buffer_size=0;
129 static float video_rc_buffer_aggressivity=1.0;
130 static int video_rc_max_rate=0;
131 static int video_rc_min_rate=0;
132 static float video_rc_initial_cplx=0;
133 static float video_b_qfactor = 1.25;
134 static float video_b_qoffset = 1.25;
135 static float video_i_qfactor = -0.8;
136 static float video_i_qoffset = 0.0;
137 static int video_intra_quant_bias= FF_DEFAULT_QUANT_BIAS;
138 static int video_inter_quant_bias= FF_DEFAULT_QUANT_BIAS;
139 static int me_method = ME_EPZS;
140 static int video_disable = 0;
141 static int video_discard = 0;
142 static int video_codec_id = CODEC_ID_NONE;
143 static int video_codec_tag = 0;
144 static int same_quality = 0;
145 static int b_frames = 0;
146 static int pre_me = 0;
147 static int do_deinterlace = 0;
148 static int workaround_bugs = FF_BUG_AUTODETECT;
149 static int packet_size = 0;
150 static int error_rate = 0;
151 static int strict = 0;
152 static int top_field_first = -1;
153 static int sc_threshold = 0;
154 static int me_threshold = 0;
155 static int mb_threshold = 0;
156 static int intra_dc_precision = 8;
157 static int me_penalty_compensation= 256;
158 static int frame_skip_threshold= 0;
159 static int frame_skip_factor= 0;
160 static int frame_skip_exp= 0;
161 extern int loop_input; /* currently a hack */
162 static int loop_output = AVFMT_NOOUTPUTLOOP;
163 static int genpts = 0;
164 static int qp_hist = 0;
166 static int gop_size = 12;
167 static int intra_only = 0;
168 static int audio_sample_rate = 44100;
169 static int audio_bit_rate = 64000;
170 #define QSCALE_NONE -99999
171 static float audio_qscale = QSCALE_NONE;
172 static int audio_disable = 0;
173 static int audio_channels = 1;
174 static int audio_codec_id = CODEC_ID_NONE;
175 static int audio_codec_tag = 0;
176 static char *audio_language = NULL;
178 static int subtitle_codec_id = CODEC_ID_NONE;
179 static char *subtitle_language = NULL;
181 static int mux_rate= 0;
182 static int mux_packet_size= 0;
183 static float mux_preload= 0.5;
184 static float mux_max_delay= 0.7;
186 static int64_t recording_time = 0;
187 static int64_t start_time = 0;
188 static int64_t rec_timestamp = 0;
189 static int64_t input_ts_offset = 0;
190 static int file_overwrite = 0;
191 static char *str_title = NULL;
192 static char *str_author = NULL;
193 static char *str_copyright = NULL;
194 static char *str_comment = NULL;
195 static int do_benchmark = 0;
196 static int do_hex_dump = 0;
197 static int do_pkt_dump = 0;
198 static int do_psnr = 0;
199 static int do_vstats = 0;
200 static int do_pass = 0;
201 static char *pass_logfilename = NULL;
202 static int audio_stream_copy = 0;
203 static int video_stream_copy = 0;
204 static int subtitle_stream_copy = 0;
205 static int video_sync_method= 1;
206 static int audio_sync_method= 0;
207 static int copy_ts= 0;
208 static int opt_shortest = 0; //
209 static int video_global_header = 0;
211 static int rate_emu = 0;
214 static char *video_grab_format = "bktr";
216 #ifdef CONFIG_VIDEO4LINUX2
217 static char *video_grab_format = "video4linux2";
219 static char *video_grab_format = "video4linux";
222 static char *video_device = NULL;
223 static char *grab_device = NULL;
224 static int video_channel = 0;
225 static char *video_standard = "ntsc";
227 static char *audio_grab_format = "audio_device";
228 static char *audio_device = NULL;
229 static int audio_volume = 256;
231 static int using_stdin = 0;
232 static int using_vhook = 0;
233 static int verbose = 1;
234 static int thread_count= 1;
235 static int q_pressed = 0;
236 static int me_range = 0;
237 static int64_t video_size = 0;
238 static int64_t audio_size = 0;
239 static int64_t extra_size = 0;
240 static int nb_frames_dup = 0;
241 static int nb_frames_drop = 0;
242 static int input_sync;
243 static int limit_filesize = 0; //
245 static int pgmyuv_compatibility_hack=0;
247 const char **opt_names=NULL;
248 int opt_name_count=0;
249 AVCodecContext *avctx_opts;
252 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
254 struct AVInputStream;
256 typedef struct AVOutputStream {
257 int file_index; /* file index */
258 int index; /* stream index in the output file */
259 int source_index; /* AVInputStream index */
260 AVStream *st; /* stream in the output file */
261 int encoding_needed; /* true if encoding needed for this stream */
263 /* input pts and corresponding output pts
265 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
266 struct AVInputStream *sync_ist; /* input stream to sync against */
267 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
269 int video_resample; /* video_resample and video_crop are mutually exclusive */
270 AVFrame pict_tmp; /* temporary image for resampling */
271 ImgReSampleContext *img_resample_ctx; /* for image resampling */
273 int video_crop; /* video_resample and video_crop are mutually exclusive */
274 int topBand; /* cropping area sizes */
277 int video_pad; /* video_resample and video_pad are mutually exclusive */
278 int padtop; /* padding area sizes */
285 ReSampleContext *resample; /* for audio resampling */
286 FifoBuffer fifo; /* for compression: one audio fifo per codec */
290 typedef struct AVInputStream {
294 int discard; /* true if stream data should be discarded */
295 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
296 int64_t sample_index; /* current sample */
298 int64_t start; /* time when read started */
299 unsigned long frame; /* current frame */
300 int64_t next_pts; /* synthetic pts for cases where pkt.pts
302 int64_t pts; /* current pts */
303 int is_start; /* is 1 at the start and after a discontinuity */
306 typedef struct AVInputFile {
307 int eof_reached; /* true if eof reached */
308 int ist_index; /* index of first stream in ist_table */
309 int buffer_size; /* current total buffer size */
310 int buffer_size_max; /* buffer size at which we consider we can stop
312 int nb_streams; /* nb streams we are aware of */
317 /* init terminal so that we can grab keys */
318 static struct termios oldtty;
320 static void term_exit(void)
322 tcsetattr (0, TCSANOW, &oldtty);
325 static volatile sig_atomic_t received_sigterm = 0;
328 sigterm_handler(int sig)
330 received_sigterm = sig;
334 static void term_init(void)
341 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
342 |INLCR|IGNCR|ICRNL|IXON);
343 tty.c_oflag |= OPOST;
344 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
345 tty.c_cflag &= ~(CSIZE|PARENB);
350 tcsetattr (0, TCSANOW, &tty);
352 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
353 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
354 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
356 register a function to be called at normal program termination
359 #ifdef CONFIG_BEOS_NETSERVER
360 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
364 /* read a key without blocking */
365 static int read_key(void)
369 #ifndef CONFIG_BEOS_NETSERVER
377 n = select(1, &rfds, NULL, NULL, &tv);
389 static int decode_interrupt_cb(void)
391 return q_pressed || (q_pressed = read_key() == 'q');
396 static volatile int received_sigterm = 0;
398 /* no interactive support */
399 static void term_exit(void)
403 static void term_init(void)
407 static int read_key(void)
414 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
419 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
422 /* copy stream format */
423 s->nb_streams = ic->nb_streams;
424 for(i=0;i<ic->nb_streams;i++) {
427 // FIXME: a more elegant solution is needed
428 st = av_mallocz(sizeof(AVStream));
429 memcpy(st, ic->streams[i], sizeof(AVStream));
430 st->codec = avcodec_alloc_context();
431 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
435 av_close_input_file(ic);
440 get_sync_ipts(const AVOutputStream *ost)
442 const AVInputStream *ist = ost->sync_ist;
443 return (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/AV_TIME_BASE;
446 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
448 static void do_audio_out(AVFormatContext *s,
451 unsigned char *buf, int size)
454 static uint8_t *audio_buf = NULL;
455 static uint8_t *audio_out = NULL;
456 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
458 int size_out, frame_bytes, ret;
459 AVCodecContext *enc= ost->st->codec;
461 /* SC: dynamic allocation of buffers */
463 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
465 audio_out = av_malloc(audio_out_size);
466 if (!audio_buf || !audio_out)
467 return; /* Should signal an error ! */
469 if(audio_sync_method){
470 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
471 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2);
472 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
473 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
475 //FIXME resample delay
476 if(fabs(delta) > 50){
479 byte_delta= FFMAX(byte_delta, -size);
483 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
488 static uint8_t *input_tmp= NULL;
489 input_tmp= av_realloc(input_tmp, byte_delta + size);
491 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
494 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
496 memset(input_tmp, 0, byte_delta);
497 memcpy(input_tmp + byte_delta, buf, size);
501 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
503 }else if(audio_sync_method>1){
504 int comp= clip(delta, -audio_sync_method, audio_sync_method);
505 assert(ost->audio_resample);
507 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
508 // fprintf(stderr, "drift:%f len:%d opts:%lld ipts:%lld fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2));
509 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
513 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
514 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2); //FIXME wrong
516 if (ost->audio_resample) {
518 size_out = audio_resample(ost->resample,
519 (short *)buftmp, (short *)buf,
520 size / (ist->st->codec->channels * 2));
521 size_out = size_out * enc->channels * 2;
527 /* now encode as many frames as possible */
528 if (enc->frame_size > 1) {
529 /* output resampled raw samples */
530 fifo_write(&ost->fifo, buftmp, size_out,
533 frame_bytes = enc->frame_size * 2 * enc->channels;
535 while (fifo_read(&ost->fifo, audio_buf, frame_bytes,
536 &ost->fifo.rptr) == 0) {
538 av_init_packet(&pkt);
540 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
543 pkt.stream_index= ost->index;
546 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
547 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
548 pkt.flags |= PKT_FLAG_KEY;
549 av_interleaved_write_frame(s, &pkt);
551 ost->sync_opts += enc->frame_size;
555 av_init_packet(&pkt);
557 ost->sync_opts += size_out / (2 * enc->channels);
559 /* output a pcm frame */
560 /* XXX: change encoding codec API to avoid this ? */
561 switch(enc->codec->id) {
562 case CODEC_ID_PCM_S32LE:
563 case CODEC_ID_PCM_S32BE:
564 case CODEC_ID_PCM_U32LE:
565 case CODEC_ID_PCM_U32BE:
566 size_out = size_out << 1;
568 case CODEC_ID_PCM_S24LE:
569 case CODEC_ID_PCM_S24BE:
570 case CODEC_ID_PCM_U24LE:
571 case CODEC_ID_PCM_U24BE:
572 case CODEC_ID_PCM_S24DAUD:
573 size_out = size_out / 2 * 3;
575 case CODEC_ID_PCM_S16LE:
576 case CODEC_ID_PCM_S16BE:
577 case CODEC_ID_PCM_U16LE:
578 case CODEC_ID_PCM_U16BE:
581 size_out = size_out >> 1;
584 ret = avcodec_encode_audio(enc, audio_out, size_out,
587 pkt.stream_index= ost->index;
590 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
591 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
592 pkt.flags |= PKT_FLAG_KEY;
593 av_interleaved_write_frame(s, &pkt);
597 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
601 AVPicture picture_tmp;
604 dec = ist->st->codec;
606 /* deinterlace : must be done before any resize */
607 if (do_deinterlace || using_vhook) {
610 /* create temporary picture */
611 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
612 buf = av_malloc(size);
616 picture2 = &picture_tmp;
617 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
620 if(avpicture_deinterlace(picture2, picture,
621 dec->pix_fmt, dec->width, dec->height) < 0) {
622 /* if error, do not deinterlace */
628 if (img_convert(picture2, dec->pix_fmt, picture,
629 dec->pix_fmt, dec->width, dec->height) < 0) {
630 /* if error, do not copy */
640 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
642 if (picture != picture2)
643 *picture = *picture2;
647 /* we begin to correct av delay at this threshold */
648 #define AV_DELAY_MAX 0.100
651 /* Expects img to be yuv420 */
652 static void fill_pad_region(AVPicture* img, int height, int width,
653 int padtop, int padbottom, int padleft, int padright, int *color) {
658 for (i = 0; i < 3; i++) {
659 shift = (i == 0) ? 0 : 1;
661 if (padtop || padleft) {
662 memset(img->data[i], color[i], (((img->linesize[i] * padtop) +
666 if (padleft || padright) {
667 optr = img->data[i] + (img->linesize[i] * (padtop >> shift)) +
668 (img->linesize[i] - (padright >> shift));
670 for (y = 0; y < ((height - (padtop + padbottom) - 1) >> shift); y++) {
671 memset(optr, color[i], (padleft + padright) >> shift);
672 optr += img->linesize[i];
676 if (padbottom || padright) {
677 optr = img->data[i] + (((img->linesize[i] * (height - padbottom)) - padright) >> shift);
678 memset(optr, color[i], (((img->linesize[i] * padbottom) + padright) >> shift));
683 static void do_subtitle_out(AVFormatContext *s,
689 static uint8_t *subtitle_out = NULL;
690 int subtitle_out_max_size = 65536;
691 int subtitle_out_size, nb, i;
695 if (pts == AV_NOPTS_VALUE) {
696 fprintf(stderr, "Subtitle packets must have a pts\n");
700 enc = ost->st->codec;
703 subtitle_out = av_malloc(subtitle_out_max_size);
706 /* Note: DVB subtitle need one packet to draw them and one other
707 packet to clear them */
708 /* XXX: signal it in the codec context ? */
709 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
714 for(i = 0; i < nb; i++) {
715 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
716 subtitle_out_max_size, sub);
718 av_init_packet(&pkt);
719 pkt.stream_index = ost->index;
720 pkt.data = subtitle_out;
721 pkt.size = subtitle_out_size;
722 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);
723 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
724 /* XXX: the pts correction is handled here. Maybe handling
725 it in the codec would be better */
727 pkt.pts += 90 * sub->start_display_time;
729 pkt.pts += 90 * sub->end_display_time;
731 av_interleaved_write_frame(s, &pkt);
735 static int bit_buffer_size= 1024*256;
736 static uint8_t *bit_buffer= NULL;
738 static void do_video_out(AVFormatContext *s,
744 int nb_frames, i, ret;
745 AVFrame *final_picture, *formatted_picture;
746 AVFrame picture_format_temp, picture_crop_temp;
747 uint8_t *buf = NULL, *buf1 = NULL;
748 AVCodecContext *enc, *dec;
749 enum PixelFormat target_pixfmt;
751 avcodec_get_frame_defaults(&picture_format_temp);
752 avcodec_get_frame_defaults(&picture_crop_temp);
754 enc = ost->st->codec;
755 dec = ist->st->codec;
757 /* by default, we output a single frame */
762 if(video_sync_method){
764 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
765 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
768 else if (vdelta > 1.1)
769 nb_frames = lrintf(vdelta);
770 //fprintf(stderr, "vdelta:%f, ost->sync_opts:%lld, ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, ost->sync_ipts, nb_frames);
774 fprintf(stderr, "*** drop!\n");
775 }else if (nb_frames > 1) {
776 nb_frames_dup += nb_frames;
778 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
781 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
783 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
787 /* convert pixel format if needed */
788 target_pixfmt = ost->video_resample || ost->video_pad
789 ? PIX_FMT_YUV420P : enc->pix_fmt;
790 if (dec->pix_fmt != target_pixfmt) {
793 /* create temporary picture */
794 size = avpicture_get_size(target_pixfmt, dec->width, dec->height);
795 buf = av_malloc(size);
798 formatted_picture = &picture_format_temp;
799 avpicture_fill((AVPicture*)formatted_picture, buf, target_pixfmt, dec->width, dec->height);
801 if (img_convert((AVPicture*)formatted_picture, target_pixfmt,
802 (AVPicture *)in_picture, dec->pix_fmt,
803 dec->width, dec->height) < 0) {
806 fprintf(stderr, "pixel format conversion not handled\n");
811 formatted_picture = in_picture;
814 /* XXX: resampling could be done before raw format conversion in
815 some cases to go faster */
816 /* XXX: only works for YUV420P */
817 if (ost->video_resample) {
818 final_picture = &ost->pict_tmp;
819 img_resample(ost->img_resample_ctx, (AVPicture*)final_picture, (AVPicture*)formatted_picture);
821 if (ost->padtop || ost->padbottom || ost->padleft || ost->padright) {
822 fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
823 ost->padtop, ost->padbottom, ost->padleft, ost->padright,
827 if (enc->pix_fmt != PIX_FMT_YUV420P) {
831 /* create temporary picture */
832 size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
833 buf = av_malloc(size);
836 final_picture = &picture_format_temp;
837 avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
839 if (img_convert((AVPicture*)final_picture, enc->pix_fmt,
840 (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
841 enc->width, enc->height) < 0) {
844 fprintf(stderr, "pixel format conversion not handled\n");
849 } else if (ost->video_crop) {
850 picture_crop_temp.data[0] = formatted_picture->data[0] +
851 (ost->topBand * formatted_picture->linesize[0]) + ost->leftBand;
853 picture_crop_temp.data[1] = formatted_picture->data[1] +
854 ((ost->topBand >> 1) * formatted_picture->linesize[1]) +
855 (ost->leftBand >> 1);
857 picture_crop_temp.data[2] = formatted_picture->data[2] +
858 ((ost->topBand >> 1) * formatted_picture->linesize[2]) +
859 (ost->leftBand >> 1);
861 picture_crop_temp.linesize[0] = formatted_picture->linesize[0];
862 picture_crop_temp.linesize[1] = formatted_picture->linesize[1];
863 picture_crop_temp.linesize[2] = formatted_picture->linesize[2];
864 final_picture = &picture_crop_temp;
865 } else if (ost->video_pad) {
866 final_picture = &ost->pict_tmp;
868 for (i = 0; i < 3; i++) {
869 uint8_t *optr, *iptr;
870 int shift = (i == 0) ? 0 : 1;
873 /* set offset to start writing image into */
874 optr = final_picture->data[i] + (((final_picture->linesize[i] *
875 ost->padtop) + ost->padleft) >> shift);
876 iptr = formatted_picture->data[i];
878 yheight = (enc->height - ost->padtop - ost->padbottom) >> shift;
879 for (y = 0; y < yheight; y++) {
880 /* copy unpadded image row into padded image row */
881 memcpy(optr, iptr, formatted_picture->linesize[i]);
882 optr += final_picture->linesize[i];
883 iptr += formatted_picture->linesize[i];
887 fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
888 ost->padtop, ost->padbottom, ost->padleft, ost->padright,
891 if (enc->pix_fmt != PIX_FMT_YUV420P) {
895 /* create temporary picture */
896 size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
897 buf = av_malloc(size);
900 final_picture = &picture_format_temp;
901 avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
903 if (img_convert((AVPicture*)final_picture, enc->pix_fmt,
904 (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
905 enc->width, enc->height) < 0) {
908 fprintf(stderr, "pixel format conversion not handled\n");
914 final_picture = formatted_picture;
916 /* duplicates frame if needed */
917 for(i=0;i<nb_frames;i++) {
919 av_init_packet(&pkt);
920 pkt.stream_index= ost->index;
922 if (s->oformat->flags & AVFMT_RAWPICTURE) {
923 /* raw pictures are written as AVPicture structure to
924 avoid any copies. We support temorarily the older
926 AVFrame* old_frame = enc->coded_frame;
927 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
928 pkt.data= (uint8_t *)final_picture;
929 pkt.size= sizeof(AVPicture);
930 if(dec->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
931 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
932 if(dec->coded_frame && dec->coded_frame->key_frame)
933 pkt.flags |= PKT_FLAG_KEY;
935 av_interleaved_write_frame(s, &pkt);
936 enc->coded_frame = old_frame;
940 big_picture= *final_picture;
941 /* better than nothing: use input picture interlaced
943 big_picture.interlaced_frame = in_picture->interlaced_frame;
944 if(avctx_opts->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
945 if(top_field_first == -1)
946 big_picture.top_field_first = in_picture->top_field_first;
948 big_picture.top_field_first = top_field_first;
951 /* handles sameq here. This is not correct because it may
952 not be a global option */
954 big_picture.quality = ist->st->quality;
956 big_picture.quality = ost->st->quality;
958 big_picture.pict_type = 0;
959 // big_picture.pts = AV_NOPTS_VALUE;
960 big_picture.pts= ost->sync_opts;
961 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
962 //av_log(NULL, AV_LOG_DEBUG, "%lld -> encoder\n", ost->sync_opts);
963 ret = avcodec_encode_video(enc,
964 bit_buffer, bit_buffer_size,
966 //enc->frame_number = enc->real_pict_num;
968 pkt.data= bit_buffer;
970 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
971 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
972 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %lld/%lld\n",
973 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
974 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
976 if(enc->coded_frame && enc->coded_frame->key_frame)
977 pkt.flags |= PKT_FLAG_KEY;
978 av_interleaved_write_frame(s, &pkt);
980 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
981 // enc->frame_number-1, enc->real_pict_num, ret,
983 /* if two pass, output log */
984 if (ost->logfile && enc->stats_out) {
985 fprintf(ost->logfile, "%s", enc->stats_out);
997 static double psnr(double d){
998 if(d==0) return INFINITY;
999 return -10.0*log(d)/log(10.0);
1002 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1005 static FILE *fvstats=NULL;
1009 AVCodecContext *enc;
1012 double ti1, bitrate, avg_bitrate;
1015 today2 = time(NULL);
1016 today = localtime(&today2);
1017 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
1020 fvstats = fopen(filename,"w");
1028 enc = ost->st->codec;
1029 if (enc->codec_type == CODEC_TYPE_VIDEO) {
1030 frame_number = ost->frame_number;
1031 fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1032 if (enc->flags&CODEC_FLAG_PSNR)
1033 fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1035 fprintf(fvstats,"f_size= %6d ", frame_size);
1036 /* compute pts value */
1037 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1041 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1042 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1043 fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1044 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1045 fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1049 static void print_report(AVFormatContext **output_files,
1050 AVOutputStream **ost_table, int nb_ostreams,
1054 AVOutputStream *ost;
1055 AVFormatContext *oc, *os;
1057 AVCodecContext *enc;
1058 int frame_number, vid, i;
1059 double bitrate, ti1, pts;
1060 static int64_t last_time = -1;
1061 static int qp_histogram[52];
1063 if (!is_last_report) {
1065 /* display the report every 0.5 seconds */
1066 cur_time = av_gettime();
1067 if (last_time == -1) {
1068 last_time = cur_time;
1071 if ((cur_time - last_time) < 500000)
1073 last_time = cur_time;
1077 oc = output_files[0];
1079 total_size = url_ftell(&oc->pb);
1084 for(i=0;i<nb_ostreams;i++) {
1086 os = output_files[ost->file_index];
1087 enc = ost->st->codec;
1088 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1089 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1090 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1092 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1093 frame_number = ost->frame_number;
1094 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d q=%3.1f ",
1095 frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1097 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1098 if(qp_hist && enc->coded_frame){
1100 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1101 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
1104 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1106 if (enc->flags&CODEC_FLAG_PSNR){
1108 double error, error_sum=0;
1109 double scale, scale_sum=0;
1110 char type[3]= {'Y','U','V'};
1111 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1114 error= enc->error[j];
1115 scale= enc->width*enc->height*255.0*255.0*frame_number;
1117 error= enc->coded_frame->error[j];
1118 scale= enc->width*enc->height*255.0*255.0;
1123 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1125 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1129 /* compute min output value */
1130 pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1131 if ((pts < ti1) && (pts > 0))
1137 if (verbose || is_last_report) {
1138 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1140 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1141 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1142 (double)total_size / 1024, ti1, bitrate);
1145 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1146 nb_frames_dup, nb_frames_drop);
1149 fprintf(stderr, "%s \r", buf);
1154 if (is_last_report && verbose >= 0){
1155 int64_t raw= audio_size + video_size + extra_size;
1156 fprintf(stderr, "\n");
1157 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1161 100.0*(total_size - raw)/raw
1166 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1167 static int output_packet(AVInputStream *ist, int ist_index,
1168 AVOutputStream **ost_table, int nb_ostreams,
1169 const AVPacket *pkt)
1171 AVFormatContext *os;
1172 AVOutputStream *ost;
1176 int data_size, got_picture;
1178 void *buffer_to_free;
1179 static unsigned int samples_size= 0;
1180 static short *samples= NULL;
1181 AVSubtitle subtitle, *subtitle_to_free;
1185 ist->pts= ist->next_pts; // needed for last packet if vsync=0
1186 } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1187 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1189 // assert(ist->pts == ist->next_pts);
1203 /* decode the packet if needed */
1204 data_buf = NULL; /* fail safe */
1206 subtitle_to_free = NULL;
1207 if (ist->decoding_needed) {
1208 switch(ist->st->codec->codec_type) {
1209 case CODEC_TYPE_AUDIO:{
1211 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
1212 /* XXX: could avoid copy if PCM 16 bits with same
1213 endianness as CPU */
1214 ret = avcodec_decode_audio(ist->st->codec, samples, &data_size,
1220 /* Some bug in mpeg audio decoder gives */
1221 /* data_size < 0, it seems they are overflows */
1222 if (data_size <= 0) {
1223 /* no audio frame */
1226 data_buf = (uint8_t *)samples;
1227 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1228 (ist->st->codec->sample_rate * ist->st->codec->channels);
1230 case CODEC_TYPE_VIDEO:
1231 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1232 /* XXX: allocate picture correctly */
1233 avcodec_get_frame_defaults(&picture);
1235 ret = avcodec_decode_video(ist->st->codec,
1236 &picture, &got_picture, ptr, len);
1237 ist->st->quality= picture.quality;
1241 /* no picture yet */
1242 goto discard_packet;
1244 if (ist->st->codec->time_base.num != 0) {
1245 ist->next_pts += ((int64_t)AV_TIME_BASE *
1246 ist->st->codec->time_base.num) /
1247 ist->st->codec->time_base.den;
1251 case CODEC_TYPE_SUBTITLE:
1252 ret = avcodec_decode_subtitle(ist->st->codec,
1253 &subtitle, &got_subtitle, ptr, len);
1256 if (!got_subtitle) {
1257 goto discard_packet;
1259 subtitle_to_free = &subtitle;
1266 switch(ist->st->codec->codec_type) {
1267 case CODEC_TYPE_AUDIO:
1268 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1269 (ist->st->codec->sample_rate * ist->st->codec->channels);
1271 case CODEC_TYPE_VIDEO:
1272 if (ist->st->codec->time_base.num != 0) {
1273 ist->next_pts += ((int64_t)AV_TIME_BASE *
1274 ist->st->codec->time_base.num) /
1275 ist->st->codec->time_base.den;
1285 buffer_to_free = NULL;
1286 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1287 pre_process_video_frame(ist, (AVPicture *)&picture,
1291 // preprocess audio (volume)
1292 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1293 if (audio_volume != 256) {
1296 for(i=0;i<(data_size / sizeof(short));i++) {
1297 int v = ((*volp) * audio_volume + 128) >> 8;
1298 if (v < -32768) v = -32768;
1299 if (v > 32767) v = 32767;
1305 /* frame rate emulation */
1306 if (ist->st->codec->rate_emu) {
1307 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1308 int64_t now = av_gettime() - ist->start;
1316 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1317 is the one of the next displayed one */
1318 /* XXX: add mpeg4 too ? */
1319 if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1320 if (ist->st->codec->pict_type != B_TYPE) {
1322 tmp = ist->last_ip_pts;
1323 ist->last_ip_pts = ist->frac_pts.val;
1324 ist->frac_pts.val = tmp;
1328 /* if output time reached then transcode raw format,
1329 encode packets and output them */
1330 if (start_time == 0 || ist->pts >= start_time)
1331 for(i=0;i<nb_ostreams;i++) {
1335 if (ost->source_index == ist_index) {
1336 os = output_files[ost->file_index];
1339 printf("%d: got pts=%0.3f %0.3f\n", i,
1340 (double)pkt->pts / AV_TIME_BASE,
1341 ((double)ist->pts / AV_TIME_BASE) -
1342 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1344 /* set the input output pts pairs */
1345 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1347 if (ost->encoding_needed) {
1348 switch(ost->st->codec->codec_type) {
1349 case CODEC_TYPE_AUDIO:
1350 do_audio_out(os, ost, ist, data_buf, data_size);
1352 case CODEC_TYPE_VIDEO:
1353 do_video_out(os, ost, ist, &picture, &frame_size);
1354 video_size += frame_size;
1355 if (do_vstats && frame_size)
1356 do_video_stats(os, ost, frame_size);
1358 case CODEC_TYPE_SUBTITLE:
1359 do_subtitle_out(os, ost, ist, &subtitle,
1366 AVFrame avframe; //FIXME/XXX remove this
1368 av_init_packet(&opkt);
1370 /* no reencoding needed : output the packet directly */
1371 /* force the input stream PTS */
1373 avcodec_get_frame_defaults(&avframe);
1374 ost->st->codec->coded_frame= &avframe;
1375 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1377 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1378 audio_size += data_size;
1379 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1380 video_size += data_size;
1384 opkt.stream_index= ost->index;
1385 if(pkt->pts != AV_NOPTS_VALUE)
1386 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);
1388 opkt.pts= AV_NOPTS_VALUE;
1392 if (pkt->dts == AV_NOPTS_VALUE)
1393 dts = ist->next_pts;
1395 dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1396 opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
1398 opkt.flags= pkt->flags;
1399 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1400 opkt.destruct= av_destruct_packet;
1401 av_interleaved_write_frame(os, &opkt);
1402 ost->st->codec->frame_number++;
1403 ost->frame_number++;
1404 av_free_packet(&opkt);
1408 av_free(buffer_to_free);
1409 /* XXX: allocate the subtitles in the codec ? */
1410 if (subtitle_to_free) {
1411 if (subtitle_to_free->rects != NULL) {
1412 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1413 av_free(subtitle_to_free->rects[i].bitmap);
1414 av_free(subtitle_to_free->rects[i].rgba_palette);
1416 av_freep(&subtitle_to_free->rects);
1418 subtitle_to_free->num_rects = 0;
1419 subtitle_to_free = NULL;
1426 for(i=0;i<nb_ostreams;i++) {
1428 if (ost->source_index == ist_index) {
1429 AVCodecContext *enc= ost->st->codec;
1430 os = output_files[ost->file_index];
1432 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1434 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1437 if (ost->encoding_needed) {
1440 av_init_packet(&pkt);
1441 pkt.stream_index= ost->index;
1443 switch(ost->st->codec->codec_type) {
1444 case CODEC_TYPE_AUDIO:
1445 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1447 pkt.flags |= PKT_FLAG_KEY;
1449 case CODEC_TYPE_VIDEO:
1450 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1452 if(enc->coded_frame && enc->coded_frame->key_frame)
1453 pkt.flags |= PKT_FLAG_KEY;
1454 if (ost->logfile && enc->stats_out) {
1455 fprintf(ost->logfile, "%s", enc->stats_out);
1464 pkt.data= bit_buffer;
1466 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1467 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1468 av_interleaved_write_frame(os, &pkt);
1482 * The following code is the main loop of the file converter
1484 static int av_encode(AVFormatContext **output_files,
1485 int nb_output_files,
1486 AVFormatContext **input_files,
1488 AVStreamMap *stream_maps, int nb_stream_maps)
1490 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1491 AVFormatContext *is, *os;
1492 AVCodecContext *codec, *icodec;
1493 AVOutputStream *ost, **ost_table = NULL;
1494 AVInputStream *ist, **ist_table = NULL;
1495 AVInputFile *file_table;
1496 AVFormatContext *stream_no_data;
1499 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1503 /* input stream init */
1505 for(i=0;i<nb_input_files;i++) {
1506 is = input_files[i];
1507 file_table[i].ist_index = j;
1508 file_table[i].nb_streams = is->nb_streams;
1509 j += is->nb_streams;
1513 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1517 for(i=0;i<nb_istreams;i++) {
1518 ist = av_mallocz(sizeof(AVInputStream));
1524 for(i=0;i<nb_input_files;i++) {
1525 is = input_files[i];
1526 for(k=0;k<is->nb_streams;k++) {
1527 ist = ist_table[j++];
1528 ist->st = is->streams[k];
1529 ist->file_index = i;
1531 ist->discard = 1; /* the stream is discarded by default
1534 if (ist->st->codec->rate_emu) {
1535 ist->start = av_gettime();
1541 /* output stream init */
1543 for(i=0;i<nb_output_files;i++) {
1544 os = output_files[i];
1545 nb_ostreams += os->nb_streams;
1547 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1548 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1552 /* Sanity check the mapping args -- do the input files & streams exist? */
1553 for(i=0;i<nb_stream_maps;i++) {
1554 int fi = stream_maps[i].file_index;
1555 int si = stream_maps[i].stream_index;
1557 if (fi < 0 || fi > nb_input_files - 1 ||
1558 si < 0 || si > file_table[fi].nb_streams - 1) {
1559 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1562 fi = stream_maps[i].sync_file_index;
1563 si = stream_maps[i].sync_stream_index;
1564 if (fi < 0 || fi > nb_input_files - 1 ||
1565 si < 0 || si > file_table[fi].nb_streams - 1) {
1566 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1571 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1574 for(i=0;i<nb_ostreams;i++) {
1575 ost = av_mallocz(sizeof(AVOutputStream));
1582 for(k=0;k<nb_output_files;k++) {
1583 os = output_files[k];
1584 for(i=0;i<os->nb_streams;i++) {
1586 ost = ost_table[n++];
1587 ost->file_index = k;
1589 ost->st = os->streams[i];
1590 if (nb_stream_maps > 0) {
1591 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1592 stream_maps[n-1].stream_index;
1594 /* Sanity check that the stream types match */
1595 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1596 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1597 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1598 ost->file_index, ost->index);
1603 /* get corresponding input stream index : we select the first one with the right type */
1605 for(j=0;j<nb_istreams;j++) {
1608 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1609 ost->source_index = j;
1616 /* try again and reuse existing stream */
1617 for(j=0;j<nb_istreams;j++) {
1619 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1620 ost->source_index = j;
1625 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1626 ost->file_index, ost->index);
1631 ist = ist_table[ost->source_index];
1633 ost->sync_ist = (nb_stream_maps > 0) ?
1634 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1635 stream_maps[n-1].sync_stream_index] : ist;
1639 /* for each output stream, we compute the right encoding parameters */
1640 for(i=0;i<nb_ostreams;i++) {
1642 ist = ist_table[ost->source_index];
1644 codec = ost->st->codec;
1645 icodec = ist->st->codec;
1647 if (ost->st->stream_copy) {
1648 /* if stream_copy is selected, no need to decode or encode */
1649 codec->codec_id = icodec->codec_id;
1650 codec->codec_type = icodec->codec_type;
1651 if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1652 codec->bit_rate = icodec->bit_rate;
1653 codec->extradata= icodec->extradata;
1654 codec->extradata_size= icodec->extradata_size;
1655 codec->time_base = icodec->time_base;
1656 switch(codec->codec_type) {
1657 case CODEC_TYPE_AUDIO:
1658 codec->sample_rate = icodec->sample_rate;
1659 codec->channels = icodec->channels;
1660 codec->frame_size = icodec->frame_size;
1661 codec->block_align= icodec->block_align;
1663 case CODEC_TYPE_VIDEO:
1664 codec->pix_fmt = icodec->pix_fmt;
1665 codec->width = icodec->width;
1666 codec->height = icodec->height;
1667 codec->has_b_frames = icodec->has_b_frames;
1669 case CODEC_TYPE_SUBTITLE:
1675 switch(codec->codec_type) {
1676 case CODEC_TYPE_AUDIO:
1677 if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1680 if (codec->channels == icodec->channels &&
1681 codec->sample_rate == icodec->sample_rate) {
1682 ost->audio_resample = 0;
1684 if (codec->channels != icodec->channels &&
1685 (icodec->codec_id == CODEC_ID_AC3 ||
1686 icodec->codec_id == CODEC_ID_DTS)) {
1687 /* Special case for 5:1 AC3 and DTS input */
1688 /* and mono or stereo output */
1689 /* Request specific number of channels */
1690 icodec->channels = codec->channels;
1691 if (codec->sample_rate == icodec->sample_rate)
1692 ost->audio_resample = 0;
1694 ost->audio_resample = 1;
1697 ost->audio_resample = 1;
1700 if(audio_sync_method>1)
1701 ost->audio_resample = 1;
1703 if(ost->audio_resample){
1704 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1705 codec->sample_rate, icodec->sample_rate);
1707 printf("Can't resample. Aborting.\n");
1711 ist->decoding_needed = 1;
1712 ost->encoding_needed = 1;
1714 case CODEC_TYPE_VIDEO:
1715 if (codec->width == icodec->width &&
1716 codec->height == icodec->height &&
1717 frame_topBand == 0 &&
1718 frame_bottomBand == 0 &&
1719 frame_leftBand == 0 &&
1720 frame_rightBand == 0 &&
1721 frame_padtop == 0 &&
1722 frame_padbottom == 0 &&
1723 frame_padleft == 0 &&
1724 frame_padright == 0)
1726 ost->video_resample = 0;
1727 ost->video_crop = 0;
1729 } else if ((codec->width == icodec->width -
1730 (frame_leftBand + frame_rightBand)) &&
1731 (codec->height == icodec->height -
1732 (frame_topBand + frame_bottomBand)))
1734 ost->video_resample = 0;
1735 ost->video_crop = 1;
1736 ost->topBand = frame_topBand;
1737 ost->leftBand = frame_leftBand;
1738 } else if ((codec->width == icodec->width +
1739 (frame_padleft + frame_padright)) &&
1740 (codec->height == icodec->height +
1741 (frame_padtop + frame_padbottom))) {
1742 ost->video_resample = 0;
1743 ost->video_crop = 0;
1745 ost->padtop = frame_padtop;
1746 ost->padleft = frame_padleft;
1747 ost->padbottom = frame_padbottom;
1748 ost->padright = frame_padright;
1749 avcodec_get_frame_defaults(&ost->pict_tmp);
1750 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1751 codec->width, codec->height ) )
1754 ost->video_resample = 1;
1755 ost->video_crop = 0; // cropping is handled as part of resample
1756 avcodec_get_frame_defaults(&ost->pict_tmp);
1757 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1758 codec->width, codec->height ) )
1761 ost->img_resample_ctx = img_resample_full_init(
1762 codec->width, codec->height,
1763 icodec->width, icodec->height,
1764 frame_topBand, frame_bottomBand,
1765 frame_leftBand, frame_rightBand,
1766 frame_padtop, frame_padbottom,
1767 frame_padleft, frame_padright);
1769 ost->padtop = frame_padtop;
1770 ost->padleft = frame_padleft;
1771 ost->padbottom = frame_padbottom;
1772 ost->padright = frame_padright;
1775 ost->encoding_needed = 1;
1776 ist->decoding_needed = 1;
1778 case CODEC_TYPE_SUBTITLE:
1779 ost->encoding_needed = 1;
1780 ist->decoding_needed = 1;
1787 if (ost->encoding_needed &&
1788 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1789 char logfilename[1024];
1794 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1796 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1797 if (codec->flags & CODEC_FLAG_PASS1) {
1798 f = fopen(logfilename, "w");
1800 perror(logfilename);
1805 /* read the log file */
1806 f = fopen(logfilename, "r");
1808 perror(logfilename);
1811 fseek(f, 0, SEEK_END);
1813 fseek(f, 0, SEEK_SET);
1814 logbuffer = av_malloc(size + 1);
1816 fprintf(stderr, "Could not allocate log buffer\n");
1819 size = fread(logbuffer, 1, size, f);
1821 logbuffer[size] = '\0';
1822 codec->stats_in = logbuffer;
1826 if(codec->codec_type == CODEC_TYPE_VIDEO){
1827 int size= codec->width * codec->height;
1828 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1833 bit_buffer = av_malloc(bit_buffer_size);
1837 /* dump the file output parameters - cannot be done before in case
1839 for(i=0;i<nb_output_files;i++) {
1840 dump_format(output_files[i], i, output_files[i]->filename, 1);
1843 /* dump the stream mapping */
1845 fprintf(stderr, "Stream mapping:\n");
1846 for(i=0;i<nb_ostreams;i++) {
1848 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1849 ist_table[ost->source_index]->file_index,
1850 ist_table[ost->source_index]->index,
1853 if (ost->sync_ist != ist_table[ost->source_index])
1854 fprintf(stderr, " [sync #%d.%d]",
1855 ost->sync_ist->file_index,
1856 ost->sync_ist->index);
1857 fprintf(stderr, "\n");
1861 /* open each encoder */
1862 for(i=0;i<nb_ostreams;i++) {
1864 if (ost->encoding_needed) {
1866 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1868 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1869 ost->file_index, ost->index);
1872 if (avcodec_open(ost->st->codec, codec) < 0) {
1873 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1874 ost->file_index, ost->index);
1877 extra_size += ost->st->codec->extradata_size;
1881 /* open each decoder */
1882 for(i=0;i<nb_istreams;i++) {
1884 if (ist->decoding_needed) {
1886 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1888 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1889 ist->st->codec->codec_id, ist->file_index, ist->index);
1892 if (avcodec_open(ist->st->codec, codec) < 0) {
1893 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1894 ist->file_index, ist->index);
1897 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1898 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1903 for(i=0;i<nb_istreams;i++) {
1905 is = input_files[ist->file_index];
1907 ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1908 if(ist->st->start_time == AV_NOPTS_VALUE)
1910 if(input_files_ts_offset[ist->file_index])
1911 ist->next_pts= AV_NOPTS_VALUE;
1915 /* compute buffer size max (should use a complete heuristic) */
1916 for(i=0;i<nb_input_files;i++) {
1917 file_table[i].buffer_size_max = 2048;
1920 /* set meta data information from input file if required */
1921 for (i=0;i<nb_meta_data_maps;i++) {
1922 AVFormatContext *out_file;
1923 AVFormatContext *in_file;
1925 int out_file_index = meta_data_maps[i].out_file;
1926 int in_file_index = meta_data_maps[i].in_file;
1927 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1928 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1932 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1933 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1938 out_file = output_files[out_file_index];
1939 in_file = input_files[in_file_index];
1941 strcpy(out_file->title, in_file->title);
1942 strcpy(out_file->author, in_file->author);
1943 strcpy(out_file->copyright, in_file->copyright);
1944 strcpy(out_file->comment, in_file->comment);
1945 strcpy(out_file->album, in_file->album);
1946 out_file->year = in_file->year;
1947 out_file->track = in_file->track;
1948 strcpy(out_file->genre, in_file->genre);
1951 /* open files and write file headers */
1952 for(i=0;i<nb_output_files;i++) {
1953 os = output_files[i];
1954 if (av_write_header(os) < 0) {
1955 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1961 #ifndef CONFIG_WIN32
1962 if ( !using_stdin && verbose >= 0) {
1963 fprintf(stderr, "Press [q] to stop encoding\n");
1964 url_set_interrupt_cb(decode_interrupt_cb);
1972 for(; received_sigterm == 0;) {
1973 int file_index, ist_index;
1981 /* if 'q' pressed, exits */
1985 /* read_key() returns 0 on EOF */
1991 /* select the stream that we must read now by looking at the
1992 smallest output pts */
1994 for(i=0;i<nb_ostreams;i++) {
1997 os = output_files[ost->file_index];
1998 ist = ist_table[ost->source_index];
1999 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2000 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2002 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2003 ipts = (double)ist->pts;
2004 if (!file_table[ist->file_index].eof_reached){
2005 if(ipts < ipts_min) {
2007 if(input_sync ) file_index = ist->file_index;
2009 if(opts < opts_min) {
2011 if(!input_sync) file_index = ist->file_index;
2014 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2019 /* if none, if is finished */
2020 if (file_index < 0) {
2024 /* finish if recording time exhausted */
2025 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
2028 /* finish if limit size exhausted */
2029 if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
2032 /* read a frame from it and output it in the fifo */
2033 is = input_files[file_index];
2034 if (av_read_frame(is, &pkt) < 0) {
2035 file_table[file_index].eof_reached = 1;
2036 if (opt_shortest) break; else continue; //
2040 stream_no_data = is;
2045 av_pkt_dump(stdout, &pkt, do_hex_dump);
2047 /* the following test is needed in case new streams appear
2048 dynamically in stream : we ignore them */
2049 if (pkt.stream_index >= file_table[file_index].nb_streams)
2050 goto discard_packet;
2051 ist_index = file_table[file_index].ist_index + pkt.stream_index;
2052 ist = ist_table[ist_index];
2054 goto discard_packet;
2056 // fprintf(stderr, "next:%lld dts:%lld off:%lld %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec->codec_type);
2057 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
2058 int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
2059 if(ABS(delta) > 10LL*AV_TIME_BASE && !copy_ts){
2060 input_files_ts_offset[ist->file_index]-= delta;
2062 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2063 for(i=0; i<file_table[file_index].nb_streams; i++){
2064 int index= file_table[file_index].ist_index + i;
2065 ist_table[index]->next_pts += delta;
2066 ist_table[index]->is_start=1;
2071 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2072 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2075 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2076 ist->file_index, ist->index);
2078 av_free_packet(&pkt);
2083 av_free_packet(&pkt);
2085 /* dump report by using the output first video and audio streams */
2086 print_report(output_files, ost_table, nb_ostreams, 0);
2089 /* at the end of stream, we must flush the decoder buffers */
2090 for(i=0;i<nb_istreams;i++) {
2092 if (ist->decoding_needed) {
2093 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2099 /* write the trailer if needed and close file */
2100 for(i=0;i<nb_output_files;i++) {
2101 os = output_files[i];
2102 av_write_trailer(os);
2105 /* dump report by using the first video and audio streams */
2106 print_report(output_files, ost_table, nb_ostreams, 1);
2108 /* close each encoder */
2109 for(i=0;i<nb_ostreams;i++) {
2111 if (ost->encoding_needed) {
2112 av_freep(&ost->st->codec->stats_in);
2113 avcodec_close(ost->st->codec);
2117 /* close each decoder */
2118 for(i=0;i<nb_istreams;i++) {
2120 if (ist->decoding_needed) {
2121 avcodec_close(ist->st->codec);
2129 av_freep(&bit_buffer);
2130 av_free(file_table);
2133 for(i=0;i<nb_istreams;i++) {
2140 for(i=0;i<nb_ostreams;i++) {
2144 fclose(ost->logfile);
2145 ost->logfile = NULL;
2147 fifo_free(&ost->fifo); /* works even if fifo is not
2148 initialized but set to zero */
2149 av_free(ost->pict_tmp.data[0]);
2150 if (ost->video_resample)
2151 img_resample_close(ost->img_resample_ctx);
2152 if (ost->audio_resample)
2153 audio_resample_close(ost->resample);
2166 int file_read(const char *filename)
2169 unsigned char buffer[1024];
2172 if (url_open(&h, filename, O_RDONLY) < 0) {
2173 printf("could not open '%s'\n", filename);
2177 len = url_read(h, buffer, sizeof(buffer));
2180 for(i=0;i<len;i++) putchar(buffer[i]);
2187 static void opt_image_format(const char *arg)
2191 for(f = first_image_format; f != NULL; f = f->next) {
2192 if (!strcmp(arg, f->name))
2196 fprintf(stderr, "Unknown image format: '%s'\n", arg);
2202 static void opt_format(const char *arg)
2204 /* compatibility stuff for pgmyuv */
2205 if (!strcmp(arg, "pgmyuv")) {
2206 pgmyuv_compatibility_hack=1;
2207 // opt_image_format(arg);
2211 file_iformat = av_find_input_format(arg);
2212 file_oformat = guess_format(arg, NULL, NULL);
2213 if (!file_iformat && !file_oformat) {
2214 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2219 static void opt_video_bitrate(const char *arg)
2221 video_bit_rate = atoi(arg) * 1000;
2224 static void opt_video_bitrate_tolerance(const char *arg)
2226 video_bit_rate_tolerance = atoi(arg) * 1000;
2229 static void opt_video_bitrate_max(const char *arg)
2231 video_rc_max_rate = atoi(arg) * 1000;
2234 static void opt_video_bitrate_min(const char *arg)
2236 video_rc_min_rate = atoi(arg) * 1000;
2239 static void opt_video_buffer_size(const char *arg)
2241 video_rc_buffer_size = atoi(arg) * 8*1024;
2244 static void opt_video_rc_eq(char *arg)
2249 static void opt_video_rc_override_string(char *arg)
2251 video_rc_override_string = arg;
2255 static void opt_workaround_bugs(const char *arg)
2257 workaround_bugs = atoi(arg);
2260 static void opt_me_threshold(const char *arg)
2262 me_threshold = atoi(arg);
2265 static void opt_mb_threshold(const char *arg)
2267 mb_threshold = atoi(arg);
2270 static void opt_verbose(const char *arg)
2272 verbose = atoi(arg);
2273 av_log_set_level(atoi(arg));
2276 static void opt_frame_rate(const char *arg)
2278 if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2279 fprintf(stderr, "Incorrect frame rate\n");
2284 static void opt_frame_crop_top(const char *arg)
2286 frame_topBand = atoi(arg);
2287 if (frame_topBand < 0) {
2288 fprintf(stderr, "Incorrect top crop size\n");
2291 if ((frame_topBand % 2) != 0) {
2292 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2295 if ((frame_topBand) >= frame_height){
2296 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2299 frame_height -= frame_topBand;
2302 static void opt_frame_crop_bottom(const char *arg)
2304 frame_bottomBand = atoi(arg);
2305 if (frame_bottomBand < 0) {
2306 fprintf(stderr, "Incorrect bottom crop size\n");
2309 if ((frame_bottomBand % 2) != 0) {
2310 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2313 if ((frame_bottomBand) >= frame_height){
2314 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2317 frame_height -= frame_bottomBand;
2320 static void opt_frame_crop_left(const char *arg)
2322 frame_leftBand = atoi(arg);
2323 if (frame_leftBand < 0) {
2324 fprintf(stderr, "Incorrect left crop size\n");
2327 if ((frame_leftBand % 2) != 0) {
2328 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2331 if ((frame_leftBand) >= frame_width){
2332 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2335 frame_width -= frame_leftBand;
2338 static void opt_frame_crop_right(const char *arg)
2340 frame_rightBand = atoi(arg);
2341 if (frame_rightBand < 0) {
2342 fprintf(stderr, "Incorrect right crop size\n");
2345 if ((frame_rightBand % 2) != 0) {
2346 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2349 if ((frame_rightBand) >= frame_width){
2350 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2353 frame_width -= frame_rightBand;
2356 static void opt_frame_size(const char *arg)
2358 if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2359 fprintf(stderr, "Incorrect frame size\n");
2362 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2363 fprintf(stderr, "Frame size must be a multiple of 2\n");
2369 #define SCALEBITS 10
2370 #define ONE_HALF (1 << (SCALEBITS - 1))
2371 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2373 #define RGB_TO_Y(r, g, b) \
2374 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2375 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2377 #define RGB_TO_U(r1, g1, b1, shift)\
2378 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2379 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2381 #define RGB_TO_V(r1, g1, b1, shift)\
2382 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2383 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2385 static void opt_pad_color(const char *arg) {
2386 /* Input is expected to be six hex digits similar to
2387 how colors are expressed in html tags (but without the #) */
2388 int rgb = strtol(arg, NULL, 16);
2392 g = ((rgb >> 8) & 255);
2395 padcolor[0] = RGB_TO_Y(r,g,b);
2396 padcolor[1] = RGB_TO_U(r,g,b,0);
2397 padcolor[2] = RGB_TO_V(r,g,b,0);
2400 static void opt_frame_pad_top(const char *arg)
2402 frame_padtop = atoi(arg);
2403 if (frame_padtop < 0) {
2404 fprintf(stderr, "Incorrect top pad size\n");
2407 if ((frame_padtop % 2) != 0) {
2408 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2413 static void opt_frame_pad_bottom(const char *arg)
2415 frame_padbottom = atoi(arg);
2416 if (frame_padbottom < 0) {
2417 fprintf(stderr, "Incorrect bottom pad size\n");
2420 if ((frame_padbottom % 2) != 0) {
2421 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2427 static void opt_frame_pad_left(const char *arg)
2429 frame_padleft = atoi(arg);
2430 if (frame_padleft < 0) {
2431 fprintf(stderr, "Incorrect left pad size\n");
2434 if ((frame_padleft % 2) != 0) {
2435 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2441 static void opt_frame_pad_right(const char *arg)
2443 frame_padright = atoi(arg);
2444 if (frame_padright < 0) {
2445 fprintf(stderr, "Incorrect right pad size\n");
2448 if ((frame_padright % 2) != 0) {
2449 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2455 static void opt_frame_pix_fmt(const char *arg)
2457 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2460 static void opt_frame_aspect_ratio(const char *arg)
2466 p = strchr(arg, ':');
2468 x = strtol(arg, (char **)&arg, 10);
2470 y = strtol(arg+1, (char **)&arg, 10);
2472 ar = (double)x / (double)y;
2474 ar = strtod(arg, (char **)&arg);
2477 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2480 frame_aspect_ratio = ar;
2483 static void opt_gop_size(const char *arg)
2485 gop_size = atoi(arg);
2488 static void opt_b_frames(const char *arg)
2490 b_frames = atoi(arg);
2491 if (b_frames > FF_MAX_B_FRAMES) {
2492 fprintf(stderr, "\nCannot have more than %d B frames, increase FF_MAX_B_FRAMES.\n", FF_MAX_B_FRAMES);
2494 } else if (b_frames < 1) {
2495 fprintf(stderr, "\nNumber of B frames must be higher than 0\n");
2500 static void opt_pre_me(const char *arg)
2505 static void opt_qscale(const char *arg)
2507 video_qscale = atof(arg);
2508 if (video_qscale < 0.01 ||
2509 video_qscale > 255) {
2510 fprintf(stderr, "qscale must be >= 0.01 and <= 255\n");
2515 static void opt_qsquish(const char *arg)
2517 video_qsquish = atof(arg);
2518 if (video_qsquish < 0.0 ||
2519 video_qsquish > 99.0) {
2520 fprintf(stderr, "qsquish must be >= 0.0 and <= 99.0\n");
2525 static void opt_lmax(const char *arg)
2527 video_lmax = atof(arg)*FF_QP2LAMBDA;
2530 static void opt_lmin(const char *arg)
2532 video_lmin = atof(arg)*FF_QP2LAMBDA;
2535 static void opt_qmin(const char *arg)
2537 video_qmin = atoi(arg);
2538 if (video_qmin < 1 ||
2540 fprintf(stderr, "qmin must be >= 1 and <= 51\n");
2545 static void opt_qmax(const char *arg)
2547 video_qmax = atoi(arg);
2548 if (video_qmax < 1 ||
2550 fprintf(stderr, "qmax must be >= 1 and <= 51\n");
2555 static void opt_mb_lmin(const char *arg)
2557 video_mb_lmin = atof(arg)*FF_QP2LAMBDA;
2558 if (video_mb_lmin < 1 ||
2559 video_mb_lmin > FF_LAMBDA_MAX) {
2560 fprintf(stderr, "mblmin must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2565 static void opt_mb_lmax(const char *arg)
2567 video_mb_lmax = atof(arg)*FF_QP2LAMBDA;
2568 if (video_mb_lmax < 1 ||
2569 video_mb_lmax > FF_LAMBDA_MAX) {
2570 fprintf(stderr, "mblmax must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2575 static void opt_qdiff(const char *arg)
2577 video_qdiff = atoi(arg);
2578 if (video_qdiff < 0 ||
2580 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2585 static void opt_qblur(const char *arg)
2587 video_qblur = atof(arg);
2590 static void opt_qcomp(const char *arg)
2592 video_qcomp = atof(arg);
2595 static void opt_rc_initial_cplx(const char *arg)
2597 video_rc_initial_cplx = atof(arg);
2599 static void opt_b_qfactor(const char *arg)
2601 video_b_qfactor = atof(arg);
2603 static void opt_i_qfactor(const char *arg)
2605 video_i_qfactor = atof(arg);
2607 static void opt_b_qoffset(const char *arg)
2609 video_b_qoffset = atof(arg);
2611 static void opt_i_qoffset(const char *arg)
2613 video_i_qoffset = atof(arg);
2616 static void opt_ibias(const char *arg)
2618 video_intra_quant_bias = atoi(arg);
2620 static void opt_pbias(const char *arg)
2622 video_inter_quant_bias = atoi(arg);
2625 static void opt_packet_size(const char *arg)
2627 packet_size= atoi(arg);
2630 static void opt_error_rate(const char *arg)
2632 error_rate= atoi(arg);
2635 static void opt_strict(const char *arg)
2640 static void opt_top_field_first(const char *arg)
2642 top_field_first= atoi(arg);
2645 static void opt_sc_threshold(const char *arg)
2647 sc_threshold= atoi(arg);
2650 static void opt_me_range(const char *arg)
2652 me_range = atoi(arg);
2655 static void opt_thread_count(const char *arg)
2657 thread_count= atoi(arg);
2658 #if !defined(HAVE_THREADS)
2660 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2664 static void opt_audio_bitrate(const char *arg)
2666 audio_bit_rate = atoi(arg) * 1000;
2669 static void opt_audio_rate(const char *arg)
2671 audio_sample_rate = atoi(arg);
2674 static void opt_audio_channels(const char *arg)
2676 audio_channels = atoi(arg);
2679 static void opt_video_device(const char *arg)
2681 video_device = av_strdup(arg);
2684 static void opt_grab_device(const char *arg)
2686 grab_device = av_strdup(arg);
2689 static void opt_video_channel(const char *arg)
2691 video_channel = strtol(arg, NULL, 0);
2694 static void opt_video_standard(const char *arg)
2696 video_standard = av_strdup(arg);
2699 static void opt_audio_device(const char *arg)
2701 audio_device = av_strdup(arg);
2704 static void opt_codec(int *pstream_copy, int *pcodec_id,
2705 int codec_type, const char *arg)
2709 if (!strcmp(arg, "copy")) {
2714 if (!strcmp(p->name, arg) && p->type == codec_type)
2719 fprintf(stderr, "Unknown codec '%s'\n", arg);
2727 static void opt_audio_codec(const char *arg)
2729 opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2732 static void opt_audio_tag(const char *arg)
2735 audio_codec_tag= strtol(arg, &tail, 0);
2738 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2741 static void opt_video_tag(const char *arg)
2744 video_codec_tag= strtol(arg, &tail, 0);
2747 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2750 static void add_frame_hooker(const char *arg)
2755 char *args = av_strdup(arg);
2759 argv[0] = strtok(args, " ");
2760 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2763 i = frame_hook_add(argc, argv);
2766 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2771 const char *motion_str[] = {
2784 static void opt_motion_estimation(const char *arg)
2790 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2793 if (!strcmp(*p, arg))
2797 me_method = (p - motion_str) + 1;
2800 static void opt_video_codec(const char *arg)
2802 opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2805 static void opt_subtitle_codec(const char *arg)
2807 opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2810 static void opt_map(const char *arg)
2816 m = &stream_maps[nb_stream_maps++];
2818 m->file_index = strtol(arg, (char **)&p, 0);
2822 m->stream_index = strtol(p, (char **)&p, 0);
2825 m->sync_file_index = strtol(p, (char **)&p, 0);
2828 m->sync_stream_index = strtol(p, (char **)&p, 0);
2830 m->sync_file_index = m->file_index;
2831 m->sync_stream_index = m->stream_index;
2835 static void opt_map_meta_data(const char *arg)
2841 m = &meta_data_maps[nb_meta_data_maps++];
2843 m->out_file = strtol(arg, (char **)&p, 0);
2847 m->in_file = strtol(p, (char **)&p, 0);
2850 static void opt_recording_time(const char *arg)
2852 recording_time = parse_date(arg, 1);
2855 static void opt_start_time(const char *arg)
2857 start_time = parse_date(arg, 1);
2860 static void opt_rec_timestamp(const char *arg)
2862 rec_timestamp = parse_date(arg, 0) / 1000000;
2865 static void opt_input_ts_offset(const char *arg)
2867 input_ts_offset = parse_date(arg, 1);
2870 static void opt_input_file(const char *filename)
2872 AVFormatContext *ic;
2873 AVFormatParameters params, *ap = ¶ms;
2874 int err, i, ret, rfps, rfps_base;
2877 if (!strcmp(filename, "-"))
2880 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2881 !strcmp( filename, "/dev/stdin" );
2883 /* get default parameters from command line */
2884 memset(ap, 0, sizeof(*ap));
2885 ap->sample_rate = audio_sample_rate;
2886 ap->channels = audio_channels;
2887 ap->time_base.den = frame_rate;
2888 ap->time_base.num = frame_rate_base;
2889 ap->width = frame_width + frame_padleft + frame_padright;
2890 ap->height = frame_height + frame_padtop + frame_padbottom;
2891 ap->image_format = image_format;
2892 ap->pix_fmt = frame_pix_fmt;
2893 ap->device = grab_device;
2894 ap->channel = video_channel;
2895 ap->standard = video_standard;
2896 ap->video_codec_id = video_codec_id;
2897 ap->audio_codec_id = audio_codec_id;
2898 if(pgmyuv_compatibility_hack)
2899 ap->video_codec_id= CODEC_ID_PGMYUV;
2901 /* open the input file with generic libav function */
2902 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2904 print_error(filename, err);
2909 ic->flags|= AVFMT_FLAG_GENPTS;
2911 /* If not enough info to get the stream parameters, we decode the
2912 first frames to get it. (used in mpeg case for example) */
2913 ret = av_find_stream_info(ic);
2914 if (ret < 0 && verbose >= 0) {
2915 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2919 timestamp = start_time;
2920 /* add the stream start time */
2921 if (ic->start_time != AV_NOPTS_VALUE)
2922 timestamp += ic->start_time;
2924 /* if seeking requested, we execute it */
2925 if (start_time != 0) {
2926 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2928 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2929 filename, (double)timestamp / AV_TIME_BASE);
2931 /* reset seek info */
2935 /* update the current parameters so that they match the one of the input stream */
2936 for(i=0;i<ic->nb_streams;i++) {
2938 AVCodecContext *enc = ic->streams[i]->codec;
2939 #if defined(HAVE_THREADS)
2941 avcodec_thread_init(enc, thread_count);
2943 enc->thread_count= thread_count;
2944 switch(enc->codec_type) {
2945 case CODEC_TYPE_AUDIO:
2946 for(j=0; j<opt_name_count; j++){
2948 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2949 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2950 av_set_double(enc, opt_names[j], d);
2952 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2953 audio_channels = enc->channels;
2954 audio_sample_rate = enc->sample_rate;
2956 ic->streams[i]->discard= AVDISCARD_ALL;
2958 case CODEC_TYPE_VIDEO:
2959 for(j=0; j<opt_name_count; j++){
2961 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2962 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2963 av_set_double(enc, opt_names[j], d);
2965 frame_height = enc->height;
2966 frame_width = enc->width;
2967 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2968 frame_pix_fmt = enc->pix_fmt;
2969 rfps = ic->streams[i]->r_frame_rate.num;
2970 rfps_base = ic->streams[i]->r_frame_rate.den;
2971 enc->workaround_bugs = workaround_bugs;
2972 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2974 enc->debug |= FF_DEBUG_MV;
2976 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2979 fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2980 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2982 (float)rfps / rfps_base, rfps, rfps_base);
2984 /* update the current frame rate to match the stream frame rate */
2986 frame_rate_base = rfps_base;
2988 enc->rate_emu = rate_emu;
2990 ic->streams[i]->discard= AVDISCARD_ALL;
2991 else if(video_discard)
2992 ic->streams[i]->discard= video_discard;
2994 case CODEC_TYPE_DATA:
2996 case CODEC_TYPE_SUBTITLE:
2998 case CODEC_TYPE_UNKNOWN:
3005 input_files[nb_input_files] = ic;
3006 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3007 /* dump the file content */
3009 dump_format(ic, nb_input_files, filename, 0);
3012 file_iformat = NULL;
3013 file_oformat = NULL;
3014 image_format = NULL;
3022 static void opt_grab(const char *arg)
3024 file_iformat = av_find_input_format(arg);
3028 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
3030 int has_video, has_audio, i, j;
3031 AVFormatContext *ic;
3035 for(j=0;j<nb_input_files;j++) {
3036 ic = input_files[j];
3037 for(i=0;i<ic->nb_streams;i++) {
3038 AVCodecContext *enc = ic->streams[i]->codec;
3039 switch(enc->codec_type) {
3040 case CODEC_TYPE_AUDIO:
3043 case CODEC_TYPE_VIDEO:
3046 case CODEC_TYPE_DATA:
3047 case CODEC_TYPE_UNKNOWN:
3048 case CODEC_TYPE_SUBTITLE:
3055 *has_video_ptr = has_video;
3056 *has_audio_ptr = has_audio;
3059 static void new_video_stream(AVFormatContext *oc)
3062 AVCodecContext *video_enc;
3065 st = av_new_stream(oc, oc->nb_streams);
3067 fprintf(stderr, "Could not alloc stream\n");
3070 #if defined(HAVE_THREADS)
3072 avcodec_thread_init(st->codec, thread_count);
3075 video_enc = st->codec;
3078 video_enc->codec_tag= video_codec_tag;
3080 if( (video_global_header&1)
3081 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3082 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3083 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
3085 if(video_global_header&2){
3086 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3087 avctx_opts->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3090 if (video_stream_copy) {
3091 st->stream_copy = 1;
3092 video_enc->codec_type = CODEC_TYPE_VIDEO;
3098 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3099 if (video_codec_id != CODEC_ID_NONE)
3100 codec_id = video_codec_id;
3102 video_enc->codec_id = codec_id;
3103 codec = avcodec_find_encoder(codec_id);
3105 for(i=0; i<opt_name_count; i++){
3107 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3108 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3109 av_set_double(video_enc, opt_names[i], d);
3112 video_enc->bit_rate = video_bit_rate;
3113 video_enc->bit_rate_tolerance = video_bit_rate_tolerance;
3114 video_enc->time_base.den = frame_rate;
3115 video_enc->time_base.num = frame_rate_base;
3116 if(codec && codec->supported_framerates){
3117 const AVRational *p= codec->supported_framerates;
3118 AVRational req= (AVRational){frame_rate, frame_rate_base};
3119 const AVRational *best=NULL;
3120 AVRational best_error= (AVRational){INT_MAX, 1};
3121 for(; p->den!=0; p++){
3122 AVRational error= av_sub_q(req, *p);
3123 if(error.num <0) error.num *= -1;
3124 if(av_cmp_q(error, best_error) < 0){
3129 video_enc->time_base.den= best->num;
3130 video_enc->time_base.num= best->den;
3133 video_enc->width = frame_width + frame_padright + frame_padleft;
3134 video_enc->height = frame_height + frame_padtop + frame_padbottom;
3135 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3136 video_enc->pix_fmt = frame_pix_fmt;
3138 if(codec && codec->pix_fmts){
3139 const enum PixelFormat *p= codec->pix_fmts;
3141 if(*p == video_enc->pix_fmt)
3145 video_enc->pix_fmt = codec->pix_fmts[0];
3149 video_enc->gop_size = gop_size;
3151 video_enc->gop_size = 0;
3152 if (video_qscale || same_quality) {
3153 video_enc->flags |= CODEC_FLAG_QSCALE;
3154 video_enc->global_quality=
3155 st->quality = FF_QP2LAMBDA * video_qscale;
3159 video_enc->intra_matrix = intra_matrix;
3161 video_enc->inter_matrix = inter_matrix;
3163 video_enc->pre_me = pre_me;
3166 video_enc->max_b_frames = b_frames;
3167 video_enc->b_quant_factor = 2.0;
3169 video_enc->qmin = video_qmin;
3170 video_enc->qmax = video_qmax;
3171 video_enc->lmin = video_lmin;
3172 video_enc->lmax = video_lmax;
3173 video_enc->rc_qsquish = video_qsquish;
3174 video_enc->mb_lmin = video_mb_lmin;
3175 video_enc->mb_lmax = video_mb_lmax;
3176 video_enc->max_qdiff = video_qdiff;
3177 video_enc->qblur = video_qblur;
3178 video_enc->qcompress = video_qcomp;
3179 video_enc->rc_eq = video_rc_eq;
3180 video_enc->workaround_bugs = workaround_bugs;
3181 video_enc->thread_count = thread_count;
3182 p= video_rc_override_string;
3185 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3187 fprintf(stderr, "error parsing rc_override\n");
3190 video_enc->rc_override=
3191 av_realloc(video_enc->rc_override,
3192 sizeof(RcOverride)*(i+1));
3193 video_enc->rc_override[i].start_frame= start;
3194 video_enc->rc_override[i].end_frame = end;
3196 video_enc->rc_override[i].qscale= q;
3197 video_enc->rc_override[i].quality_factor= 1.0;
3200 video_enc->rc_override[i].qscale= 0;
3201 video_enc->rc_override[i].quality_factor= -q/100.0;
3206 video_enc->rc_override_count=i;
3208 video_enc->rc_max_rate = video_rc_max_rate;
3209 video_enc->rc_min_rate = video_rc_min_rate;
3210 video_enc->rc_buffer_size = video_rc_buffer_size;
3211 video_enc->rc_initial_buffer_occupancy = video_rc_buffer_size*3/4;
3212 video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
3213 video_enc->rc_initial_cplx= video_rc_initial_cplx;
3214 video_enc->i_quant_factor = video_i_qfactor;
3215 video_enc->b_quant_factor = video_b_qfactor;
3216 video_enc->i_quant_offset = video_i_qoffset;
3217 video_enc->b_quant_offset = video_b_qoffset;
3218 video_enc->intra_quant_bias = video_intra_quant_bias;
3219 video_enc->inter_quant_bias = video_inter_quant_bias;
3220 video_enc->me_threshold= me_threshold;
3221 video_enc->mb_threshold= mb_threshold;
3222 video_enc->intra_dc_precision= intra_dc_precision - 8;
3223 video_enc->strict_std_compliance = strict;
3224 video_enc->error_rate = error_rate;
3225 video_enc->scenechange_threshold= sc_threshold;
3226 video_enc->me_range = me_range;
3227 video_enc->me_penalty_compensation= me_penalty_compensation;
3228 video_enc->frame_skip_threshold= frame_skip_threshold;
3229 video_enc->frame_skip_factor= frame_skip_factor;
3230 video_enc->frame_skip_exp= frame_skip_exp;
3233 video_enc->rtp_mode= 1;
3234 video_enc->rtp_payload_size= packet_size;
3238 video_enc->flags|= CODEC_FLAG_PSNR;
3240 video_enc->me_method = me_method;
3245 video_enc->flags |= CODEC_FLAG_PASS1;
3247 video_enc->flags |= CODEC_FLAG_PASS2;
3252 /* reset some key parameters */
3254 video_codec_id = CODEC_ID_NONE;
3255 video_stream_copy = 0;
3258 static void new_audio_stream(AVFormatContext *oc)
3261 AVCodecContext *audio_enc;
3264 st = av_new_stream(oc, oc->nb_streams);
3266 fprintf(stderr, "Could not alloc stream\n");
3269 #if defined(HAVE_THREADS)
3271 avcodec_thread_init(st->codec, thread_count);
3274 audio_enc = st->codec;
3275 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3278 audio_enc->codec_tag= audio_codec_tag;
3280 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3281 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3282 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
3284 if (audio_stream_copy) {
3285 st->stream_copy = 1;
3286 audio_enc->channels = audio_channels;
3288 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3290 for(i=0; i<opt_name_count; i++){
3292 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3293 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3294 av_set_double(audio_enc, opt_names[i], d);
3297 if (audio_codec_id != CODEC_ID_NONE)
3298 codec_id = audio_codec_id;
3299 audio_enc->codec_id = codec_id;
3301 audio_enc->bit_rate = audio_bit_rate;
3302 if (audio_qscale > QSCALE_NONE) {
3303 audio_enc->flags |= CODEC_FLAG_QSCALE;
3304 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3306 audio_enc->strict_std_compliance = strict;
3307 audio_enc->thread_count = thread_count;
3308 /* For audio codecs other than AC3 or DTS we limit */
3309 /* the number of coded channels to stereo */
3310 if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3311 && codec_id != CODEC_ID_DTS) {
3312 audio_enc->channels = 2;
3314 audio_enc->channels = audio_channels;
3316 audio_enc->sample_rate = audio_sample_rate;
3317 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3318 if (audio_language) {
3319 pstrcpy(st->language, sizeof(st->language), audio_language);
3320 av_free(audio_language);
3321 audio_language = NULL;
3324 /* reset some key parameters */
3326 audio_codec_id = CODEC_ID_NONE;
3327 audio_stream_copy = 0;
3330 static void opt_new_subtitle_stream(void)
3332 AVFormatContext *oc;
3334 AVCodecContext *subtitle_enc;
3337 if (nb_output_files <= 0) {
3338 fprintf(stderr, "At least one output file must be specified\n");
3341 oc = output_files[nb_output_files - 1];
3343 st = av_new_stream(oc, oc->nb_streams);
3345 fprintf(stderr, "Could not alloc stream\n");
3349 subtitle_enc = st->codec;
3350 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3351 if (subtitle_stream_copy) {
3352 st->stream_copy = 1;
3354 for(i=0; i<opt_name_count; i++){
3356 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3357 if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3358 av_set_double(subtitle_enc, opt_names[i], d);
3360 subtitle_enc->codec_id = subtitle_codec_id;
3363 if (subtitle_language) {
3364 pstrcpy(st->language, sizeof(st->language), subtitle_language);
3365 av_free(subtitle_language);
3366 subtitle_language = NULL;
3369 subtitle_codec_id = CODEC_ID_NONE;
3370 subtitle_stream_copy = 0;
3373 static void opt_new_audio_stream(void)
3375 AVFormatContext *oc;
3376 if (nb_output_files <= 0) {
3377 fprintf(stderr, "At least one output file must be specified\n");
3380 oc = output_files[nb_output_files - 1];
3381 new_audio_stream(oc);
3384 static void opt_new_video_stream(void)
3386 AVFormatContext *oc;
3387 if (nb_output_files <= 0) {
3388 fprintf(stderr, "At least one output file must be specified\n");
3391 oc = output_files[nb_output_files - 1];
3392 new_video_stream(oc);
3395 static void opt_output_file(const char *filename)
3397 AVFormatContext *oc;
3398 int use_video, use_audio, input_has_video, input_has_audio;
3399 AVFormatParameters params, *ap = ¶ms;
3401 if (!strcmp(filename, "-"))
3404 oc = av_alloc_format_context();
3406 if (!file_oformat) {
3407 file_oformat = guess_format(NULL, filename, NULL);
3408 if (!file_oformat) {
3409 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3415 oc->oformat = file_oformat;
3416 pstrcpy(oc->filename, sizeof(oc->filename), filename);
3418 if (!strcmp(file_oformat->name, "ffm") &&
3419 strstart(filename, "http:", NULL)) {
3420 /* special case for files sent to ffserver: we get the stream
3421 parameters from ffserver */
3422 if (read_ffserver_streams(oc, filename) < 0) {
3423 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3427 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3428 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3430 /* disable if no corresponding type found and at least one
3432 if (nb_input_files > 0) {
3433 check_audio_video_inputs(&input_has_video, &input_has_audio);
3434 if (!input_has_video)
3436 if (!input_has_audio)
3440 /* manual disable */
3441 if (audio_disable) {
3444 if (video_disable) {
3449 new_video_stream(oc);
3453 new_audio_stream(oc);
3456 if (!oc->nb_streams) {
3457 fprintf(stderr, "No audio or video streams available\n");
3461 oc->timestamp = rec_timestamp;
3464 pstrcpy(oc->title, sizeof(oc->title), str_title);
3466 pstrcpy(oc->author, sizeof(oc->author), str_author);
3468 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3470 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3473 output_files[nb_output_files++] = oc;
3475 /* check filename in case of an image number is expected */
3476 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3477 if (filename_number_test(oc->filename) < 0) {
3478 print_error(oc->filename, AVERROR_NUMEXPECTED);
3483 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3484 /* test if it already exists to avoid loosing precious files */
3485 if (!file_overwrite &&
3486 (strchr(filename, ':') == NULL ||
3487 strstart(filename, "file:", NULL))) {
3488 if (url_exist(filename)) {
3491 if ( !using_stdin ) {
3492 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3495 if (toupper(c) != 'Y') {
3496 fprintf(stderr, "Not overwriting - exiting\n");
3501 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3508 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3509 fprintf(stderr, "Could not open '%s'\n", filename);
3514 memset(ap, 0, sizeof(*ap));
3515 ap->image_format = image_format;
3516 if (av_set_parameters(oc, ap) < 0) {
3517 fprintf(stderr, "%s: Invalid encoding parameters\n",
3522 oc->packet_size= mux_packet_size;
3523 oc->mux_rate= mux_rate;
3524 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3525 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3526 oc->loop_output = loop_output;
3528 /* reset some options */
3529 file_oformat = NULL;
3530 file_iformat = NULL;
3531 image_format = NULL;
3534 /* prepare dummy protocols for grab */
3535 static void prepare_grab(void)
3537 int has_video, has_audio, i, j;
3538 AVFormatContext *oc;
3539 AVFormatContext *ic;
3540 AVFormatParameters vp1, *vp = &vp1;
3541 AVFormatParameters ap1, *ap = &ap1;
3543 /* see if audio/video inputs are needed */
3546 memset(ap, 0, sizeof(*ap));
3547 memset(vp, 0, sizeof(*vp));
3548 vp->time_base.num= 1;
3549 for(j=0;j<nb_output_files;j++) {
3550 oc = output_files[j];
3551 for(i=0;i<oc->nb_streams;i++) {
3552 AVCodecContext *enc = oc->streams[i]->codec;
3553 switch(enc->codec_type) {
3554 case CODEC_TYPE_AUDIO:
3555 if (enc->sample_rate > ap->sample_rate)
3556 ap->sample_rate = enc->sample_rate;
3557 if (enc->channels > ap->channels)
3558 ap->channels = enc->channels;
3561 case CODEC_TYPE_VIDEO:
3562 if (enc->width > vp->width)
3563 vp->width = enc->width;
3564 if (enc->height > vp->height)
3565 vp->height = enc->height;
3567 if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
3568 vp->time_base = enc->time_base;
3578 if (has_video == 0 && has_audio == 0) {
3579 fprintf(stderr, "Output file must have at least one audio or video stream\n");
3584 AVInputFormat *fmt1;
3585 fmt1 = av_find_input_format(video_grab_format);
3586 vp->device = video_device;
3587 vp->channel = video_channel;
3588 vp->standard = video_standard;
3589 vp->pix_fmt = frame_pix_fmt;
3590 if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3591 fprintf(stderr, "Could not find video grab device\n");
3594 /* If not enough info to get the stream parameters, we decode the
3595 first frames to get it. */
3596 if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3597 fprintf(stderr, "Could not find video grab parameters\n");
3600 /* by now video grab has one stream */
3601 ic->streams[0]->r_frame_rate.num = vp->time_base.den;
3602 ic->streams[0]->r_frame_rate.den = vp->time_base.num;
3603 input_files[nb_input_files] = ic;
3606 dump_format(ic, nb_input_files, "", 0);
3610 if (has_audio && audio_grab_format) {
3611 AVInputFormat *fmt1;
3612 fmt1 = av_find_input_format(audio_grab_format);
3613 ap->device = audio_device;
3614 if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3615 fprintf(stderr, "Could not find audio grab device\n");
3618 input_files[nb_input_files] = ic;
3621 dump_format(ic, nb_input_files, "", 0);
3627 /* same option as mencoder */
3628 static void opt_pass(const char *pass_str)
3631 pass = atoi(pass_str);
3632 if (pass != 1 && pass != 2) {
3633 fprintf(stderr, "pass number can be only 1 or 2\n");
3639 #if defined(CONFIG_WIN32) || defined(CONFIG_OS2)
3640 static int64_t getutime(void)
3642 return av_gettime();
3645 static int64_t getutime(void)
3647 struct rusage rusage;
3649 getrusage(RUSAGE_SELF, &rusage);
3650 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3654 extern int ffm_nopts;
3656 static void show_formats(void)
3658 AVInputFormat *ifmt;
3659 AVOutputFormat *ofmt;
3660 AVImageFormat *image_fmt;
3663 const char **pp, *last_name;
3665 printf("File formats:\n");
3670 const char *name=NULL;
3671 const char *long_name=NULL;
3673 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3674 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3675 strcmp(ofmt->name, last_name)>0){
3677 long_name= ofmt->long_name;
3681 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3682 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3683 strcmp(ifmt->name, last_name)>0){
3685 long_name= ifmt->long_name;
3688 if(name && strcmp(ifmt->name, name)==0)
3700 long_name ? long_name:" ");
3704 printf("Image formats (filename extensions, if any, follow):\n");
3705 for(image_fmt = first_image_format; image_fmt != NULL;
3706 image_fmt = image_fmt->next) {
3709 image_fmt->img_read ? "D":" ",
3710 image_fmt->img_write ? "E":" ",
3712 image_fmt->extensions ? image_fmt->extensions:" ");
3716 printf("Codecs:\n");
3722 const char *type_str;
3725 for(p = first_avcodec; p != NULL; p = p->next) {
3726 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3727 strcmp(p->name, last_name)>0){
3729 decode= encode= cap=0;
3731 if(p2 && strcmp(p->name, p2->name)==0){
3732 if(p->decode) decode=1;
3733 if(p->encode) encode=1;
3734 cap |= p->capabilities;
3739 last_name= p2->name;
3742 case CODEC_TYPE_VIDEO:
3745 case CODEC_TYPE_AUDIO:
3748 case CODEC_TYPE_SUBTITLE:
3757 decode ? "D": (/*p2->decoder ? "d":*/" "),
3760 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3761 cap & CODEC_CAP_DR1 ? "D":" ",
3762 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3764 /* if(p2->decoder && decode==0)
3765 printf(" use %s for decoding", p2->decoder->name);*/
3770 printf("Supported file protocols:\n");
3771 for(up = first_protocol; up != NULL; up = up->next)
3772 printf(" %s:", up->name);
3775 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3776 printf("Motion estimation methods:\n");
3780 if ((pp - motion_str + 1) == ME_ZERO)
3781 printf("(fastest)");
3782 else if ((pp - motion_str + 1) == ME_FULL)
3783 printf("(slowest)");
3784 else if ((pp - motion_str + 1) == ME_EPZS)
3785 printf("(default)");
3790 "Note, the names of encoders and decoders dont always match, so there are\n"
3791 "several cases where the above table shows encoder only or decoder only entries\n"
3792 "even though both encoding and decoding are supported for example, the h263\n"
3793 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3798 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3801 const char *p = str;
3808 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3815 static void opt_inter_matrix(const char *arg)
3817 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3818 parse_matrix_coeffs(inter_matrix, arg);
3821 static void opt_intra_matrix(const char *arg)
3823 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3824 parse_matrix_coeffs(intra_matrix, arg);
3827 static void opt_target(const char *arg)
3830 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3832 if(!strncmp(arg, "pal-", 4)) {
3835 } else if(!strncmp(arg, "ntsc-", 5)) {
3838 } else if(!strncmp(arg, "film-", 5)) {
3843 /* Calculate FR via float to avoid int overflow */
3844 fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3847 } else if((fr == 29970) || (fr == 23976)) {
3850 /* Try to determine PAL/NTSC by peeking in the input files */
3851 if(nb_input_files) {
3853 for(j = 0; j < nb_input_files; j++) {
3854 for(i = 0; i < input_files[j]->nb_streams; i++) {
3855 AVCodecContext *c = input_files[j]->streams[i]->codec;
3856 if(c->codec_type != CODEC_TYPE_VIDEO)
3858 fr = c->time_base.den * 1000 / c->time_base.num;
3862 } else if((fr == 29970) || (fr == 23976)) {
3872 if(verbose && norm >= 0)
3873 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3877 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3878 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3879 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3883 if(!strcmp(arg, "vcd")) {
3885 opt_video_codec("mpeg1video");
3886 opt_audio_codec("mp2");
3889 opt_frame_size(norm ? "352x240" : "352x288");
3890 opt_frame_rate(frame_rates[norm]);
3891 opt_gop_size(norm ? "18" : "15");
3893 video_bit_rate = 1150000;
3894 video_rc_max_rate = 1150000;
3895 video_rc_min_rate = 1150000;
3896 video_rc_buffer_size = 40*1024*8;
3898 audio_bit_rate = 224000;
3899 audio_sample_rate = 44100;
3901 mux_packet_size= 2324;
3902 mux_rate= 2352 * 75 * 8;
3904 /* We have to offset the PTS, so that it is consistent with the SCR.
3905 SCR starts at 36000, but the first two packs contain only padding
3906 and the first pack from the other stream, respectively, may also have
3907 been written before.
3908 So the real data starts at SCR 36000+3*1200. */
3909 mux_preload= (36000+3*1200) / 90000.0; //0.44
3910 } else if(!strcmp(arg, "svcd")) {
3912 opt_video_codec("mpeg2video");
3913 opt_audio_codec("mp2");
3916 opt_frame_size(norm ? "480x480" : "480x576");
3917 opt_frame_rate(frame_rates[norm]);
3918 opt_gop_size(norm ? "18" : "15");
3920 video_bit_rate = 2040000;
3921 video_rc_max_rate = 2516000;
3922 video_rc_min_rate = 0; //1145000;
3923 video_rc_buffer_size = 224*1024*8;
3924 opt_default("flags", "+SCAN_OFFSET");
3927 audio_bit_rate = 224000;
3928 audio_sample_rate = 44100;
3930 mux_packet_size= 2324;
3932 } else if(!strcmp(arg, "dvd")) {
3934 opt_video_codec("mpeg2video");
3935 opt_audio_codec("ac3");
3938 opt_frame_size(norm ? "720x480" : "720x576");
3939 opt_frame_rate(frame_rates[norm]);
3940 opt_gop_size(norm ? "18" : "15");
3942 video_bit_rate = 6000000;
3943 video_rc_max_rate = 9000000;
3944 video_rc_min_rate = 0; //1500000;
3945 video_rc_buffer_size = 224*1024*8;
3947 mux_packet_size= 2048; // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3948 mux_rate = 10080000; // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3950 audio_bit_rate = 448000;
3951 audio_sample_rate = 48000;
3953 } else if(!strcmp(arg, "dv")) {
3957 opt_frame_size(norm ? "720x480" : "720x576");
3958 opt_frame_rate(frame_rates[norm]);
3960 audio_sample_rate = 48000;
3964 fprintf(stderr, "Unknown target: %s\n", arg);
3969 static void show_version(void)
3971 /* TODO: add function interface to avutil and avformat */
3972 fprintf(stderr, "ffmpeg " FFMPEG_VERSION "\n"
3976 LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3980 static int opt_default(const char *opt, const char *arg){
3981 AVOption *o= av_set_string(avctx_opts, opt, arg);
3985 // 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));
3987 //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
3988 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
3989 opt_names[opt_name_count++]= o->name;
3991 /* disable generate of real time pts in ffm (need to be supressed anyway) */
3992 if(avctx_opts->flags & CODEC_FLAG_BITEXACT)
3995 if(avctx_opts->debug)
3996 av_log_set_level(AV_LOG_DEBUG);
4000 const OptionDef options[] = {
4002 { "L", 0, {(void*)show_license}, "show license" },
4003 { "h", 0, {(void*)show_help}, "show help" },
4004 { "version", 0, {(void*)show_version}, "show version" },
4005 { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
4006 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4007 { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
4008 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4009 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4010 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
4011 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
4012 { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
4013 { "fs", HAS_ARG | OPT_INT, {(void*)&limit_filesize}, "set the limit file size", "limit_size" }, //
4014 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4015 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4016 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
4017 { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
4018 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
4019 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
4020 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
4021 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4022 "add timings for benchmarking" },
4023 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4024 "dump each input packet" },
4025 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4026 "when dumping packets, also dump the payload" },
4027 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4028 { "loop", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4029 { "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)", "" },
4030 { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
4031 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4032 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4033 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4034 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4035 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4036 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4037 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4040 { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate}, "set video bitrate (in kbit/s)", "bitrate" },
4041 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4042 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4043 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
4044 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4045 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4046 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4047 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
4048 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
4049 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
4050 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
4051 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
4052 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
4053 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
4054 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
4055 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
4056 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
4057 { "g", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_gop_size}, "set the group of picture size", "gop_size" },
4058 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4059 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4060 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4061 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
4062 { "qmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
4063 { "qmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
4064 { "lmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmin}, "min video lagrange factor (VBR)", "lambda" },
4065 { "lmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmax}, "max video lagrange factor (VBR)", "lambda" },
4066 { "mblmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmin}, "min macroblock quantiser scale (VBR)", "q" },
4067 { "mblmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmax}, "max macroblock quantiser scale (VBR)", "q" },
4068 { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
4069 { "qblur", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qblur}, "video quantiser scale blur (VBR)", "blur" },
4070 { "qsquish", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qsquish}, "how to keep quantiser between qmin and qmax (0 = clip, 1 = use differentiable function)", "squish" },
4071 { "qcomp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qcomp}, "video quantiser scale compression (VBR)", "compression" },
4072 { "rc_init_cplx", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_rc_initial_cplx}, "initial complexity for 1-pass encoding", "complexity" },
4073 { "b_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qfactor}, "qp factor between p and b frames", "factor" },
4074 { "i_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qfactor}, "qp factor between p and i frames", "factor" },
4075 { "b_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qoffset}, "qp offset between p and b frames", "offset" },
4076 { "i_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qoffset}, "qp offset between p and i frames", "offset" },
4077 { "ibias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ibias}, "intra quant bias", "bias" },
4078 { "pbias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pbias}, "inter quant bias", "bias" },
4079 { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
4080 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4081 { "bt", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_tolerance}, "set video bitrate tolerance (in kbit/s)", "tolerance" },
4082 { "maxrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_max}, "set max video bitrate tolerance (in kbit/s)", "bitrate" },
4083 { "minrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_min}, "set min video bitrate tolerance (in kbit/s)", "bitrate" },
4084 { "bufsize", HAS_ARG | OPT_VIDEO, {(void*)opt_video_buffer_size}, "set ratecontrol buffer size (in kByte)", "size" },
4085 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4086 { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
4088 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "" },
4089 { "mb_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_threshold}, "macroblock threshold", "" },
4090 { "bf", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_frames}, "use 'frames' B frames", "frames" },
4091 { "preme", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_me}, "pre motion estimation", "" },
4092 { "bug", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_workaround_bugs}, "workaround not auto detected encoder bugs", "param" },
4093 { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
4094 { "error", HAS_ARG | OPT_EXPERT, {(void*)opt_error_rate}, "error rate", "rate" },
4095 { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
4096 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4097 "use same video quality as source (implies VBR)" },
4098 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4099 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
4100 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4101 "deinterlace pictures" },
4102 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4103 { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
4104 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
4105 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4106 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4107 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4108 { "sc_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sc_threshold}, "scene change threshold", "threshold" },
4109 { "me_range", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_range}, "limit motion vectors range (1023 for DivX player)", "range" },
4110 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4111 { "mepc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&me_penalty_compensation}, "motion estimation bitrate penalty compensation", "factor (1.0 = 256)" },
4112 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4113 { "skip_threshold", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_threshold}, "frame skip threshold", "threshold" },
4114 { "skip_factor", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_factor}, "frame skip factor", "factor" },
4115 { "skip_exp", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_exp}, "frame skip exponent", "exponent" },
4116 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
4117 { "genpts", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&genpts }, "generate pts" },
4118 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4121 { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
4122 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4123 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4124 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4125 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4126 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4127 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4128 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4129 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
4130 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4132 /* subtitle options */
4133 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4134 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
4135 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4138 { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
4139 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4140 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4141 { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
4143 /* G.2 grab options */
4144 { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
4145 { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
4148 { "muxrate", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_rate}, "set mux rate", "rate" },
4149 { "packetsize", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_packet_size}, "set packet size", "size" },
4150 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4151 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4152 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4156 static void show_banner(void)
4158 fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2004 Fabrice Bellard\n");
4159 fprintf(stderr, " configuration: " FFMPEG_CONFIGURATION "\n");
4160 fprintf(stderr, " libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
4161 fprintf(stderr, " libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
4162 fprintf(stderr, " libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
4163 fprintf(stderr, " built on " __DATE__ " " __TIME__);
4165 fprintf(stderr, ", gcc: " __VERSION__ "\n");
4167 fprintf(stderr, ", using a non-gcc compiler\n");
4171 static void show_license(void)
4176 "This program is free software; you can redistribute it and/or modify\n"
4177 "it under the terms of the GNU General Public License as published by\n"
4178 "the Free Software Foundation; either version 2 of the License, or\n"
4179 "(at your option) any later version.\n"
4181 "This program is distributed in the hope that it will be useful,\n"
4182 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4183 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
4184 "GNU General Public License for more details.\n"
4186 "You should have received a copy of the GNU General Public License\n"
4187 "along with this program; if not, write to the Free Software\n"
4188 "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n"
4192 "This library is free software; you can redistribute it and/or\n"
4193 "modify it under the terms of the GNU Lesser General Public\n"
4194 "License as published by the Free Software Foundation; either\n"
4195 "version 2 of the License, or (at your option) any later version.\n"
4197 "This library is distributed in the hope that it will be useful,\n"
4198 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4199 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
4200 "Lesser General Public License for more details.\n"
4202 "You should have received a copy of the GNU Lesser General Public\n"
4203 "License along with this library; if not, write to the Free Software\n"
4204 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
4210 static void show_help(void)
4213 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
4214 "Hyper fast Audio and Video encoder\n");
4216 show_help_options(options, "Main options:\n",
4217 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
4218 show_help_options(options, "\nVideo options:\n",
4219 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4221 show_help_options(options, "\nAdvanced Video options:\n",
4222 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4223 OPT_VIDEO | OPT_EXPERT);
4224 show_help_options(options, "\nAudio options:\n",
4225 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4227 show_help_options(options, "\nAdvanced Audio options:\n",
4228 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4229 OPT_AUDIO | OPT_EXPERT);
4230 show_help_options(options, "\nSubtitle options:\n",
4231 OPT_SUBTITLE | OPT_GRAB,
4233 show_help_options(options, "\nAudio/Video grab options:\n",
4236 show_help_options(options, "\nAdvanced options:\n",
4237 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4239 av_opt_show(avctx_opts, NULL);
4244 void parse_arg_file(const char *filename)
4246 opt_output_file(filename);
4249 int main(int argc, char **argv)
4256 avctx_opts= avcodec_alloc_context();
4264 parse_options(argc, argv, options);
4266 /* file converter / grab */
4267 if (nb_output_files <= 0) {
4268 fprintf(stderr, "Must supply at least one output file\n");
4272 if (nb_input_files == 0) {
4278 av_encode(output_files, nb_output_files, input_files, nb_input_files,
4279 stream_maps, nb_stream_maps);
4280 ti = getutime() - ti;
4282 printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4286 for(i=0;i<nb_output_files;i++) {
4287 /* maybe av_close_output_file ??? */
4288 AVFormatContext *s = output_files[i];
4290 if (!(s->oformat->flags & AVFMT_NOFILE))
4292 for(j=0;j<s->nb_streams;j++)
4293 av_free(s->streams[j]);
4296 for(i=0;i<nb_input_files;i++)
4297 av_close_input_file(input_files[i]);
4302 av_free(intra_matrix);
4304 av_free(inter_matrix);
4306 #ifdef POWERPC_PERFORMANCE_REPORT
4307 extern void powerpc_display_perf_report(void);
4308 powerpc_display_perf_report();
4309 #endif /* POWERPC_PERFORMANCE_REPORT */
4311 #ifndef CONFIG_WIN32
4312 if (received_sigterm) {
4314 "Received signal %d: terminating.\n",
4315 (int) received_sigterm);
4319 exit(0); /* not all OS-es handle main() return value */