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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 #define HAVE_AV_CONFIG_H
21 #include "framehook.h"
26 #include <sys/ioctl.h>
29 #include <sys/resource.h>
33 #include <sys/types.h>
34 #include <sys/select.h>
41 #if !defined(INFINITY) && defined(HUGE_VAL)
42 #define INFINITY HUGE_VAL
45 /* select an input stream for an output stream */
46 typedef struct AVStreamMap {
51 extern const OptionDef options[];
53 static void show_help(void);
54 static void show_license(void);
58 static AVFormatContext *input_files[MAX_FILES];
59 static int nb_input_files = 0;
61 static AVFormatContext *output_files[MAX_FILES];
62 static int nb_output_files = 0;
64 static AVStreamMap stream_maps[MAX_FILES];
65 static int nb_stream_maps;
67 static AVInputFormat *file_iformat;
68 static AVOutputFormat *file_oformat;
69 static AVImageFormat *image_format;
70 static int frame_width = 160;
71 static int frame_height = 128;
72 static float frame_aspect_ratio = 0;
73 static enum PixelFormat frame_pix_fmt = PIX_FMT_YUV420P;
74 static int frame_topBand = 0;
75 static int frame_bottomBand = 0;
76 static int frame_leftBand = 0;
77 static int frame_rightBand = 0;
78 static int frame_rate = 25;
79 static int frame_rate_base = 1;
80 static int video_bit_rate = 200*1000;
81 static int video_bit_rate_tolerance = 4000*1000;
82 static float video_qscale = 0;
83 static int video_qmin = 2;
84 static int video_qmax = 31;
85 static int video_mb_qmin = 2;
86 static int video_mb_qmax = 31;
87 static int video_qdiff = 3;
88 static float video_qblur = 0.5;
89 static float video_qcomp = 0.5;
90 static uint16_t *intra_matrix = NULL;
91 static uint16_t *inter_matrix = NULL;
92 #if 0 //experimental, (can be removed)
93 static float video_rc_qsquish=1.0;
94 static float video_rc_qmod_amp=0;
95 static int video_rc_qmod_freq=0;
97 static char *video_rc_override_string=NULL;
98 static char *video_rc_eq="tex^qComp";
99 static int video_rc_buffer_size=0;
100 static float video_rc_buffer_aggressivity=1.0;
101 static int video_rc_max_rate=0;
102 static int video_rc_min_rate=0;
103 static float video_rc_initial_cplx=0;
104 static float video_b_qfactor = 1.25;
105 static float video_b_qoffset = 1.25;
106 static float video_i_qfactor = -0.8;
107 static float video_i_qoffset = 0.0;
108 static int video_intra_quant_bias= FF_DEFAULT_QUANT_BIAS;
109 static int video_inter_quant_bias= FF_DEFAULT_QUANT_BIAS;
110 static int me_method = ME_EPZS;
111 static int video_disable = 0;
112 static int video_codec_id = CODEC_ID_NONE;
113 static int same_quality = 0;
114 static int b_frames = 0;
115 static int mb_decision = FF_MB_DECISION_SIMPLE;
116 static int ildct_cmp = FF_CMP_VSAD;
117 static int mb_cmp = FF_CMP_SAD;
118 static int sub_cmp = FF_CMP_SAD;
119 static int cmp = FF_CMP_SAD;
120 static int pre_cmp = FF_CMP_SAD;
121 static int pre_me = 0;
122 static float lumi_mask = 0;
123 static float dark_mask = 0;
124 static float scplx_mask = 0;
125 static float tcplx_mask = 0;
126 static float p_mask = 0;
127 static int use_4mv = 0;
128 static int use_obmc = 0;
129 static int use_aic = 0;
130 static int use_aiv = 0;
131 static int use_umv = 0;
132 static int use_alt_scan = 0;
133 static int use_trell = 0;
134 static int use_scan_offset = 0;
136 static int closed_gop = 0;
137 static int do_deinterlace = 0;
138 static int do_interlace_dct = 0;
139 static int do_interlace_me = 0;
140 static int workaround_bugs = FF_BUG_AUTODETECT;
141 static int error_resilience = 2;
142 static int error_concealment = 3;
143 static int dct_algo = 0;
144 static int idct_algo = 0;
145 static int use_part = 0;
146 static int packet_size = 0;
147 static int error_rate = 0;
148 static int strict = 0;
149 static int top_field_first = -1;
150 static int noise_reduction = 0;
151 static int sc_threshold = 0;
152 static int debug = 0;
153 static int debug_mv = 0;
154 extern int loop_input; /* currently a hack */
156 static int gop_size = 12;
157 static int intra_only = 0;
158 static int audio_sample_rate = 44100;
159 static int audio_bit_rate = 64000;
160 static int audio_disable = 0;
161 static int audio_channels = 1;
162 static int audio_codec_id = CODEC_ID_NONE;
164 static int64_t recording_time = 0;
165 static int64_t start_time = 0;
166 static int file_overwrite = 0;
167 static char *str_title = NULL;
168 static char *str_author = NULL;
169 static char *str_copyright = NULL;
170 static char *str_comment = NULL;
171 static int do_benchmark = 0;
172 static int do_hex_dump = 0;
173 static int do_pkt_dump = 0;
174 static int do_psnr = 0;
175 static int do_vstats = 0;
176 static int do_pass = 0;
177 static int bitexact = 0;
178 static char *pass_logfilename = NULL;
179 static int audio_stream_copy = 0;
180 static int video_stream_copy = 0;
182 static int rate_emu = 0;
184 static char *video_grab_format = "video4linux";
185 static char *video_device = NULL;
186 static int video_channel = 0;
187 static char *video_standard = "ntsc";
189 static char *audio_grab_format = "audio_device";
190 static char *audio_device = NULL;
192 static int using_stdin = 0;
193 static int using_vhook = 0;
194 static int verbose = 1;
195 static int thread_count= 1;
196 static int q_pressed = 0;
198 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
200 typedef struct AVOutputStream {
201 int file_index; /* file index */
202 int index; /* stream index in the output file */
203 int source_index; /* AVInputStream index */
204 AVStream *st; /* stream in the output file */
205 int encoding_needed; /* true if encoding needed for this stream */
207 /* input pts and corresponding output pts
210 double sync_ipts_offset;
213 int video_resample; /* video_resample and video_crop are mutually exclusive */
214 AVPicture pict_tmp; /* temporary image for resampling */
215 ImgReSampleContext *img_resample_ctx; /* for image resampling */
217 int video_crop; /* video_resample and video_crop are mutually exclusive */
218 int topBand; /* cropping area sizes */
223 ReSampleContext *resample; /* for audio resampling */
224 FifoBuffer fifo; /* for compression: one audio fifo per codec */
228 typedef struct AVInputStream {
232 int discard; /* true if stream data should be discarded */
233 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
234 int64_t sample_index; /* current sample */
236 int64_t start; /* time when read started */
237 unsigned long frame; /* current frame */
238 int64_t next_pts; /* synthetic pts for cases where pkt.pts
240 int64_t pts; /* current pts */
243 typedef struct AVInputFile {
244 int eof_reached; /* true if eof reached */
245 int ist_index; /* index of first stream in ist_table */
246 int buffer_size; /* current total buffer size */
247 int buffer_size_max; /* buffer size at which we consider we can stop
249 int nb_streams; /* nb streams we are aware of */
254 /* init terminal so that we can grab keys */
255 static struct termios oldtty;
257 static void term_exit(void)
259 tcsetattr (0, TCSANOW, &oldtty);
262 static volatile sig_atomic_t received_sigterm = 0;
265 sigterm_handler(int sig)
267 received_sigterm = sig;
271 static void term_init(void)
278 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
279 |INLCR|IGNCR|ICRNL|IXON);
280 tty.c_oflag |= OPOST;
281 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
282 tty.c_cflag &= ~(CSIZE|PARENB);
287 tcsetattr (0, TCSANOW, &tty);
289 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
290 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
291 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
293 register a function to be called at normal program termination
296 #ifdef CONFIG_BEOS_NETSERVER
297 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
301 /* read a key without blocking */
302 static int read_key(void)
306 #ifndef CONFIG_BEOS_NETSERVER
314 n = select(1, &rfds, NULL, NULL, &tv);
326 static int decode_interrupt_cb(void)
328 return q_pressed || (q_pressed = read_key() == 'q');
333 static volatile int received_sigterm = 0;
335 /* no interactive support */
336 static void term_exit(void)
340 static void term_init(void)
344 static int read_key(void)
351 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
356 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
359 /* copy stream format */
360 s->nb_streams = ic->nb_streams;
361 for(i=0;i<ic->nb_streams;i++) {
364 st = av_mallocz(sizeof(AVStream));
365 memcpy(st, ic->streams[i], sizeof(AVStream));
369 av_close_input_file(ic);
373 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
375 static void do_audio_out(AVFormatContext *s,
378 unsigned char *buf, int size)
381 static uint8_t *audio_buf = NULL;
382 static uint8_t *audio_out = NULL;
383 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
385 int size_out, frame_bytes, ret;
388 /* SC: dynamic allocation of buffers */
390 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
392 audio_out = av_malloc(audio_out_size);
393 if (!audio_buf || !audio_out)
394 return; /* Should signal an error ! */
397 enc = &ost->st->codec;
399 if (ost->audio_resample) {
401 size_out = audio_resample(ost->resample,
402 (short *)buftmp, (short *)buf,
403 size / (ist->st->codec.channels * 2));
404 size_out = size_out * enc->channels * 2;
410 /* now encode as many frames as possible */
411 if (enc->frame_size > 1) {
412 /* output resampled raw samples */
413 fifo_write(&ost->fifo, buftmp, size_out,
416 frame_bytes = enc->frame_size * 2 * enc->channels;
418 while (fifo_read(&ost->fifo, audio_buf, frame_bytes,
419 &ost->fifo.rptr) == 0) {
420 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
422 av_write_frame(s, ost->index, audio_out, ret);
425 /* output a pcm frame */
426 /* XXX: change encoding codec API to avoid this ? */
427 switch(enc->codec->id) {
428 case CODEC_ID_PCM_S16LE:
429 case CODEC_ID_PCM_S16BE:
430 case CODEC_ID_PCM_U16LE:
431 case CODEC_ID_PCM_U16BE:
434 size_out = size_out >> 1;
437 ret = avcodec_encode_audio(enc, audio_out, size_out,
439 av_write_frame(s, ost->index, audio_out, ret);
443 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
447 AVPicture picture_tmp;
450 dec = &ist->st->codec;
452 /* deinterlace : must be done before any resize */
453 if (do_deinterlace || using_vhook) {
456 /* create temporary picture */
457 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
458 buf = av_malloc(size);
462 picture2 = &picture_tmp;
463 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
466 if(avpicture_deinterlace(picture2, picture,
467 dec->pix_fmt, dec->width, dec->height) < 0) {
468 /* if error, do not deinterlace */
474 if (img_convert(picture2, dec->pix_fmt, picture,
475 dec->pix_fmt, dec->width, dec->height) < 0) {
476 /* if error, do not copy */
486 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
488 if (picture != picture2)
489 *picture = *picture2;
493 /* we begin to correct av delay at this threshold */
494 #define AV_DELAY_MAX 0.100
496 static void do_video_out(AVFormatContext *s,
500 int *frame_size, AVOutputStream *audio_sync)
502 int nb_frames, i, ret;
503 AVPicture *final_picture, *formatted_picture;
504 AVPicture picture_format_temp, picture_crop_temp;
505 static uint8_t *video_buffer= NULL;
506 uint8_t *buf = NULL, *buf1 = NULL;
507 AVCodecContext *enc, *dec;
508 enum PixelFormat target_pixfmt;
510 #define VIDEO_BUFFER_SIZE (1024*1024)
512 enc = &ost->st->codec;
513 dec = &ist->st->codec;
515 /* by default, we output a single frame */
520 /* NOTE: the A/V sync is always done by considering the audio is
521 the master clock. It is suffisant for transcoding or playing,
522 but not for the general case */
524 /* compute the A-V delay and duplicate/remove frames if needed */
525 double adelta, vdelta, av_delay;
527 adelta = audio_sync->sync_ipts - ((double)audio_sync->sync_opts *
528 s->pts_num / s->pts_den);
530 vdelta = ost->sync_ipts - ((double)ost->sync_opts *
531 s->pts_num / s->pts_den);
533 av_delay = adelta - vdelta;
534 // printf("delay=%f\n", av_delay);
535 if (av_delay < -AV_DELAY_MAX)
537 else if (av_delay > AV_DELAY_MAX)
542 vdelta = (double)(ost->st->pts.val) * s->pts_num / s->pts_den - (ost->sync_ipts - ost->sync_ipts_offset);
543 if (vdelta < 100 && vdelta > -100 && ost->sync_ipts_offset) {
544 if (vdelta < -AV_DELAY_MAX)
546 else if (vdelta > AV_DELAY_MAX)
549 ost->sync_ipts_offset -= vdelta;
550 if (!ost->sync_ipts_offset)
551 ost->sync_ipts_offset = 0.000001; /* one microsecond */
555 #if defined(AVSYNC_DEBUG)
557 static char *action[] = { "drop frame", "copy frame", "dup frame" };
559 fprintf(stderr, "Input APTS %12.6f, output APTS %12.6f, ",
560 (double) audio_sync->sync_ipts,
561 (double) audio_sync->st->pts.val * s->pts_num / s->pts_den);
562 fprintf(stderr, "Input VPTS %12.6f, output VPTS %12.6f: %s\n",
563 (double) ost->sync_ipts,
564 (double) ost->st->pts.val * s->pts_num / s->pts_den,
573 video_buffer = av_malloc(VIDEO_BUFFER_SIZE);
577 /* convert pixel format if needed */
578 target_pixfmt = ost->video_resample ? PIX_FMT_YUV420P : enc->pix_fmt;
579 if (dec->pix_fmt != target_pixfmt) {
582 /* create temporary picture */
583 size = avpicture_get_size(target_pixfmt, dec->width, dec->height);
584 buf = av_malloc(size);
587 formatted_picture = &picture_format_temp;
588 avpicture_fill(formatted_picture, buf, target_pixfmt, dec->width, dec->height);
590 if (img_convert(formatted_picture, target_pixfmt,
591 (AVPicture *)in_picture, dec->pix_fmt,
592 dec->width, dec->height) < 0) {
593 fprintf(stderr, "pixel format conversion not handled\n");
597 formatted_picture = (AVPicture *)in_picture;
600 /* XXX: resampling could be done before raw format convertion in
601 some cases to go faster */
602 /* XXX: only works for YUV420P */
603 if (ost->video_resample) {
604 final_picture = &ost->pict_tmp;
605 img_resample(ost->img_resample_ctx, final_picture, formatted_picture);
606 if (enc->pix_fmt != PIX_FMT_YUV420P) {
610 /* create temporary picture */
611 size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
612 buf = av_malloc(size);
615 final_picture = &picture_format_temp;
616 avpicture_fill(final_picture, buf, enc->pix_fmt, enc->width, enc->height);
618 if (img_convert(final_picture, enc->pix_fmt,
619 &ost->pict_tmp, PIX_FMT_YUV420P,
620 enc->width, enc->height) < 0) {
621 fprintf(stderr, "pixel format conversion not handled\n");
625 } else if (ost->video_crop) {
626 picture_crop_temp.data[0] = formatted_picture->data[0] +
627 (ost->topBand * formatted_picture->linesize[0]) + ost->leftBand;
629 picture_crop_temp.data[1] = formatted_picture->data[1] +
630 ((ost->topBand >> 1) * formatted_picture->linesize[1]) +
631 (ost->leftBand >> 1);
633 picture_crop_temp.data[2] = formatted_picture->data[2] +
634 ((ost->topBand >> 1) * formatted_picture->linesize[2]) +
635 (ost->leftBand >> 1);
637 picture_crop_temp.linesize[0] = formatted_picture->linesize[0];
638 picture_crop_temp.linesize[1] = formatted_picture->linesize[1];
639 picture_crop_temp.linesize[2] = formatted_picture->linesize[2];
640 final_picture = &picture_crop_temp;
642 final_picture = formatted_picture;
644 /* duplicates frame if needed */
645 /* XXX: pb because no interleaving */
646 for(i=0;i<nb_frames;i++) {
647 if (s->oformat->flags & AVFMT_RAWPICTURE) {
648 /* raw pictures are written as AVPicture structure to
649 avoid any copies. We support temorarily the older
651 AVFrame* old_frame = enc->coded_frame;
652 enc->coded_frame = dec->coded_frame;
653 av_write_frame(s, ost->index,
654 (uint8_t *)final_picture, sizeof(AVPicture));
655 enc->coded_frame = old_frame;
659 avcodec_get_frame_defaults(&big_picture);
660 *(AVPicture*)&big_picture= *final_picture;
661 /* better than nothing: use input picture interlaced
663 big_picture.interlaced_frame = in_picture->interlaced_frame;
664 if(do_interlace_me || do_interlace_dct){
665 if(top_field_first == -1)
666 big_picture.top_field_first = in_picture->top_field_first;
668 big_picture.top_field_first = 1;
671 /* handles sameq here. This is not correct because it may
672 not be a global option */
674 big_picture.quality = ist->st->quality;
676 big_picture.quality = ost->st->quality;
677 ret = avcodec_encode_video(enc,
678 video_buffer, VIDEO_BUFFER_SIZE,
680 //enc->frame_number = enc->real_pict_num;
681 av_write_frame(s, ost->index, video_buffer, ret);
683 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
684 // enc->frame_number-1, enc->real_pict_num, ret,
686 /* if two pass, output log */
687 if (ost->logfile && enc->stats_out) {
688 fprintf(ost->logfile, "%s", enc->stats_out);
698 static double psnr(double d){
699 if(d==0) return INFINITY;
700 return -10.0*log(d)/log(10.0);
703 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
706 static FILE *fvstats=NULL;
707 static int64_t total_size = 0;
714 double ti1, bitrate, avg_bitrate;
718 today = localtime(&today2);
719 sprintf(filename, "vstats_%02d%02d%02d.log", today->tm_hour,
722 fvstats = fopen(filename,"w");
730 enc = &ost->st->codec;
731 total_size += frame_size;
732 if (enc->codec_type == CODEC_TYPE_VIDEO) {
733 frame_number = ost->frame_number;
734 fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
735 if (enc->flags&CODEC_FLAG_PSNR)
736 fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
738 fprintf(fvstats,"f_size= %6d ", frame_size);
739 /* compute pts value */
740 ti1 = (double)ost->st->pts.val * os->pts_num / os->pts_den;
744 bitrate = (double)(frame_size * 8) * enc->frame_rate / enc->frame_rate_base / 1000.0;
745 avg_bitrate = (double)(total_size * 8) / ti1 / 1000.0;
746 fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
747 (double)total_size / 1024, ti1, bitrate, avg_bitrate);
748 fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
752 static void print_report(AVFormatContext **output_files,
753 AVOutputStream **ost_table, int nb_ostreams,
758 AVFormatContext *oc, *os;
761 int frame_number, vid, i;
762 double bitrate, ti1, pts;
763 static int64_t last_time = -1;
765 if (!is_last_report) {
767 /* display the report every 0.5 seconds */
768 cur_time = av_gettime();
769 if (last_time == -1) {
770 last_time = cur_time;
773 if ((cur_time - last_time) < 500000)
775 last_time = cur_time;
779 oc = output_files[0];
781 total_size = url_ftell(&oc->pb);
786 for(i=0;i<nb_ostreams;i++) {
788 os = output_files[ost->file_index];
789 enc = &ost->st->codec;
790 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
791 sprintf(buf + strlen(buf), "q=%2.1f ",
792 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
794 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
795 frame_number = ost->frame_number;
796 sprintf(buf + strlen(buf), "frame=%5d q=%2.1f ",
797 frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : 0);
799 sprintf(buf + strlen(buf), "L");
800 if (enc->flags&CODEC_FLAG_PSNR){
802 double error, error_sum=0;
803 double scale, scale_sum=0;
804 char type[3]= {'Y','U','V'};
805 sprintf(buf + strlen(buf), "PSNR=");
808 error= enc->error[j];
809 scale= enc->width*enc->height*255.0*255.0*frame_number;
811 error= enc->coded_frame->error[j];
812 scale= enc->width*enc->height*255.0*255.0;
817 sprintf(buf + strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
819 sprintf(buf + strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
823 /* compute min output value */
824 pts = (double)ost->st->pts.val * os->pts_num / os->pts_den;
825 if ((pts < ti1) && (pts > 0))
831 if (verbose || is_last_report) {
832 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
834 sprintf(buf + strlen(buf),
835 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
836 (double)total_size / 1024, ti1, bitrate);
838 fprintf(stderr, "%s \r", buf);
843 fprintf(stderr, "\n");
846 /* pkt = NULL means EOF (needed to flush decoder buffers) */
847 static int output_packet(AVInputStream *ist, int ist_index,
848 AVOutputStream **ost_table, int nb_ostreams,
856 int data_size, got_picture;
858 short samples[AVCODEC_MAX_AUDIO_FRAME_SIZE / 2];
859 void *buffer_to_free;
861 if (pkt && pkt->pts != AV_NOPTS_VALUE) {
864 ist->pts = ist->next_pts;
878 /* decode the packet if needed */
879 data_buf = NULL; /* fail safe */
881 if (ist->decoding_needed) {
882 switch(ist->st->codec.codec_type) {
883 case CODEC_TYPE_AUDIO:
884 /* XXX: could avoid copy if PCM 16 bits with same
886 ret = avcodec_decode_audio(&ist->st->codec, samples, &data_size,
892 /* Some bug in mpeg audio decoder gives */
893 /* data_size < 0, it seems they are overflows */
894 if (data_size <= 0) {
898 data_buf = (uint8_t *)samples;
899 ist->next_pts += ((int64_t)AV_TIME_BASE * data_size) /
900 (2 * ist->st->codec.channels);
902 case CODEC_TYPE_VIDEO:
903 data_size = (ist->st->codec.width * ist->st->codec.height * 3) / 2;
904 /* XXX: allocate picture correctly */
905 avcodec_get_frame_defaults(&picture);
907 ret = avcodec_decode_video(&ist->st->codec,
908 &picture, &got_picture, ptr, len);
909 ist->st->quality= picture.quality;
916 if (ist->st->codec.frame_rate_base != 0) {
917 ist->next_pts += ((int64_t)AV_TIME_BASE *
918 ist->st->codec.frame_rate_base) /
919 ist->st->codec.frame_rate;
933 buffer_to_free = NULL;
934 if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO) {
935 pre_process_video_frame(ist, (AVPicture *)&picture,
939 /* frame rate emulation */
940 if (ist->st->codec.rate_emu) {
941 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec.frame_rate_base, 1000000, ist->st->codec.frame_rate);
942 int64_t now = av_gettime() - ist->start;
950 /* mpeg PTS deordering : if it is a P or I frame, the PTS
951 is the one of the next displayed one */
952 /* XXX: add mpeg4 too ? */
953 if (ist->st->codec.codec_id == CODEC_ID_MPEG1VIDEO) {
954 if (ist->st->codec.pict_type != B_TYPE) {
956 tmp = ist->last_ip_pts;
957 ist->last_ip_pts = ist->frac_pts.val;
958 ist->frac_pts.val = tmp;
962 /* if output time reached then transcode raw format,
963 encode packets and output them */
964 if (start_time == 0 || ist->pts >= start_time)
965 for(i=0;i<nb_ostreams;i++) {
969 if (ost->source_index == ist_index) {
970 os = output_files[ost->file_index];
973 printf("%d: got pts=%0.3f %0.3f\n", i,
974 (double)pkt->pts / AV_TIME_BASE,
975 ((double)ist->pts / AV_TIME_BASE) -
976 ((double)ost->st->pts.val * os->pts_num / os->pts_den));
978 /* set the input output pts pairs */
979 ost->sync_ipts = (double)ist->pts / AV_TIME_BASE;
980 /* XXX: take into account the various fifos,
981 in particular for audio */
982 ost->sync_opts = ost->st->pts.val;
983 //printf("ipts=%lld sync_ipts=%f sync_opts=%lld pts.val=%lld pkt->pts=%lld\n", ist->pts, ost->sync_ipts, ost->sync_opts, ost->st->pts.val, pkt->pts);
985 if (ost->encoding_needed) {
986 switch(ost->st->codec.codec_type) {
987 case CODEC_TYPE_AUDIO:
988 do_audio_out(os, ost, ist, data_buf, data_size);
990 case CODEC_TYPE_VIDEO:
991 /* find an audio stream for synchro */
994 AVOutputStream *audio_sync, *ost1;
996 for(i=0;i<nb_ostreams;i++) {
998 if (ost1->file_index == ost->file_index &&
999 ost1->st->codec.codec_type == CODEC_TYPE_AUDIO) {
1005 do_video_out(os, ost, ist, &picture, &frame_size, audio_sync);
1006 if (do_vstats && frame_size)
1007 do_video_stats(os, ost, frame_size);
1016 /* no reencoding needed : output the packet directly */
1017 /* force the input stream PTS */
1019 avcodec_get_frame_defaults(&avframe);
1020 ost->st->codec.coded_frame= &avframe;
1021 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1023 av_write_frame(os, ost->index, data_buf, data_size);
1024 ost->st->codec.frame_number++;
1025 ost->frame_number++;
1029 av_free(buffer_to_free);
1039 * The following code is the main loop of the file converter
1041 static int av_encode(AVFormatContext **output_files,
1042 int nb_output_files,
1043 AVFormatContext **input_files,
1045 AVStreamMap *stream_maps, int nb_stream_maps)
1047 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1048 AVFormatContext *is, *os;
1049 AVCodecContext *codec, *icodec;
1050 AVOutputStream *ost, **ost_table = NULL;
1051 AVInputStream *ist, **ist_table = NULL;
1052 AVInputFile *file_table;
1053 AVFormatContext *stream_no_data;
1056 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1060 /* input stream init */
1062 for(i=0;i<nb_input_files;i++) {
1063 is = input_files[i];
1064 file_table[i].ist_index = j;
1065 file_table[i].nb_streams = is->nb_streams;
1066 j += is->nb_streams;
1070 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1074 for(i=0;i<nb_istreams;i++) {
1075 ist = av_mallocz(sizeof(AVInputStream));
1081 for(i=0;i<nb_input_files;i++) {
1082 is = input_files[i];
1083 for(k=0;k<is->nb_streams;k++) {
1084 ist = ist_table[j++];
1085 ist->st = is->streams[k];
1086 ist->file_index = i;
1088 ist->discard = 1; /* the stream is discarded by default
1091 if (ist->st->codec.rate_emu) {
1092 ist->start = av_gettime();
1098 /* output stream init */
1100 for(i=0;i<nb_output_files;i++) {
1101 os = output_files[i];
1102 nb_ostreams += os->nb_streams;
1104 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1105 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1109 /* Sanity check the mapping args -- do the input files & streams exist? */
1110 for(i=0;i<nb_stream_maps;i++) {
1111 int fi = stream_maps[i].file_index;
1112 int si = stream_maps[i].stream_index;
1114 if (fi < 0 || fi > nb_input_files - 1 ||
1115 si < 0 || si > file_table[fi].nb_streams - 1) {
1116 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1121 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1124 for(i=0;i<nb_ostreams;i++) {
1125 ost = av_mallocz(sizeof(AVOutputStream));
1132 for(k=0;k<nb_output_files;k++) {
1133 os = output_files[k];
1134 for(i=0;i<os->nb_streams;i++) {
1136 ost = ost_table[n++];
1137 ost->file_index = k;
1139 ost->st = os->streams[i];
1140 if (nb_stream_maps > 0) {
1141 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1142 stream_maps[n-1].stream_index;
1144 /* Sanity check that the stream types match */
1145 if (ist_table[ost->source_index]->st->codec.codec_type != ost->st->codec.codec_type) {
1146 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1147 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1148 ost->file_index, ost->index);
1153 /* get corresponding input stream index : we select the first one with the right type */
1155 for(j=0;j<nb_istreams;j++) {
1158 ist->st->codec.codec_type == ost->st->codec.codec_type) {
1159 ost->source_index = j;
1165 /* try again and reuse existing stream */
1166 for(j=0;j<nb_istreams;j++) {
1168 if (ist->st->codec.codec_type == ost->st->codec.codec_type) {
1169 ost->source_index = j;
1174 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1175 ost->file_index, ost->index);
1180 ist = ist_table[ost->source_index];
1185 /* for each output stream, we compute the right encoding parameters */
1186 for(i=0;i<nb_ostreams;i++) {
1188 ist = ist_table[ost->source_index];
1190 codec = &ost->st->codec;
1191 icodec = &ist->st->codec;
1193 if (ost->st->stream_copy) {
1194 /* if stream_copy is selected, no need to decode or encode */
1195 codec->codec_id = icodec->codec_id;
1196 codec->codec_type = icodec->codec_type;
1197 codec->codec_tag = icodec->codec_tag;
1198 codec->bit_rate = icodec->bit_rate;
1199 switch(codec->codec_type) {
1200 case CODEC_TYPE_AUDIO:
1201 codec->sample_rate = icodec->sample_rate;
1202 codec->channels = icodec->channels;
1204 case CODEC_TYPE_VIDEO:
1205 codec->frame_rate = icodec->frame_rate;
1206 codec->frame_rate_base = icodec->frame_rate_base;
1207 codec->width = icodec->width;
1208 codec->height = icodec->height;
1214 switch(codec->codec_type) {
1215 case CODEC_TYPE_AUDIO:
1216 if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1219 if (codec->channels == icodec->channels &&
1220 codec->sample_rate == icodec->sample_rate) {
1221 ost->audio_resample = 0;
1223 if (codec->channels != icodec->channels &&
1224 icodec->codec_id == CODEC_ID_AC3) {
1225 /* Special case for 5:1 AC3 input */
1226 /* and mono or stereo output */
1227 /* Request specific number of channels */
1228 icodec->channels = codec->channels;
1229 if (codec->sample_rate == icodec->sample_rate)
1230 ost->audio_resample = 0;
1232 ost->audio_resample = 1;
1233 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1235 icodec->sample_rate);
1238 printf("Can't resample. Aborting.\n");
1242 /* Request specific number of channels */
1243 icodec->channels = codec->channels;
1245 ost->audio_resample = 1;
1246 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1248 icodec->sample_rate);
1251 printf("Can't resample. Aborting.\n");
1256 ist->decoding_needed = 1;
1257 ost->encoding_needed = 1;
1259 case CODEC_TYPE_VIDEO:
1260 if (codec->width == icodec->width &&
1261 codec->height == icodec->height &&
1262 frame_topBand == 0 &&
1263 frame_bottomBand == 0 &&
1264 frame_leftBand == 0 &&
1265 frame_rightBand == 0)
1267 ost->video_resample = 0;
1268 ost->video_crop = 0;
1269 } else if ((codec->width == icodec->width -
1270 (frame_leftBand + frame_rightBand)) &&
1271 (codec->height == icodec->height -
1272 (frame_topBand + frame_bottomBand)))
1274 ost->video_resample = 0;
1275 ost->video_crop = 1;
1276 ost->topBand = frame_topBand;
1277 ost->leftBand = frame_leftBand;
1279 ost->video_resample = 1;
1280 ost->video_crop = 0; // cropping is handled as part of resample
1281 if( avpicture_alloc( &ost->pict_tmp, PIX_FMT_YUV420P,
1282 codec->width, codec->height ) )
1285 ost->img_resample_ctx = img_resample_full_init(
1286 ost->st->codec.width, ost->st->codec.height,
1287 ist->st->codec.width, ist->st->codec.height,
1288 frame_topBand, frame_bottomBand,
1289 frame_leftBand, frame_rightBand);
1291 ost->encoding_needed = 1;
1292 ist->decoding_needed = 1;
1298 if (ost->encoding_needed &&
1299 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1300 char logfilename[1024];
1305 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1307 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1308 if (codec->flags & CODEC_FLAG_PASS1) {
1309 f = fopen(logfilename, "w");
1311 perror(logfilename);
1316 /* read the log file */
1317 f = fopen(logfilename, "r");
1319 perror(logfilename);
1322 fseek(f, 0, SEEK_END);
1324 fseek(f, 0, SEEK_SET);
1325 logbuffer = av_malloc(size + 1);
1327 fprintf(stderr, "Could not allocate log buffer\n");
1330 size = fread(logbuffer, 1, size, f);
1332 logbuffer[size] = '\0';
1333 codec->stats_in = logbuffer;
1339 /* dump the file output parameters - cannot be done before in case
1341 for(i=0;i<nb_output_files;i++) {
1342 dump_format(output_files[i], i, output_files[i]->filename, 1);
1345 /* dump the stream mapping */
1346 fprintf(stderr, "Stream mapping:\n");
1347 for(i=0;i<nb_ostreams;i++) {
1349 fprintf(stderr, " Stream #%d.%d -> #%d.%d\n",
1350 ist_table[ost->source_index]->file_index,
1351 ist_table[ost->source_index]->index,
1356 /* open each encoder */
1357 for(i=0;i<nb_ostreams;i++) {
1359 if (ost->encoding_needed) {
1361 codec = avcodec_find_encoder(ost->st->codec.codec_id);
1363 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1364 ost->file_index, ost->index);
1367 if (avcodec_open(&ost->st->codec, codec) < 0) {
1368 fprintf(stderr, "Error while opening codec for stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1369 ost->file_index, ost->index);
1375 /* open each decoder */
1376 for(i=0;i<nb_istreams;i++) {
1378 if (ist->decoding_needed) {
1380 codec = avcodec_find_decoder(ist->st->codec.codec_id);
1382 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1383 ist->st->codec.codec_id, ist->file_index, ist->index);
1386 if (avcodec_open(&ist->st->codec, codec) < 0) {
1387 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1388 ist->file_index, ist->index);
1391 //if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO)
1392 // ist->st->codec.flags |= CODEC_FLAG_REPEAT_FIELD;
1397 for(i=0;i<nb_istreams;i++) {
1399 is = input_files[ist->file_index];
1404 /* compute buffer size max (should use a complete heuristic) */
1405 for(i=0;i<nb_input_files;i++) {
1406 file_table[i].buffer_size_max = 2048;
1409 /* open files and write file headers */
1410 for(i=0;i<nb_output_files;i++) {
1411 os = output_files[i];
1412 if (av_write_header(os) < 0) {
1413 fprintf(stderr, "Could not write header for output file #%d (incorrect codec paramters ?)\n", i);
1419 #ifndef CONFIG_WIN32
1420 if ( !using_stdin ) {
1421 fprintf(stderr, "Press [q] to stop encoding\n");
1422 url_set_interrupt_cb(decode_interrupt_cb);
1430 for(; received_sigterm == 0;) {
1431 int file_index, ist_index;
1436 /* if 'q' pressed, exits */
1440 /* read_key() returns 0 on EOF */
1446 /* select the stream that we must read now by looking at the
1447 smallest output pts */
1450 for(i=0;i<nb_ostreams;i++) {
1453 os = output_files[ost->file_index];
1454 ist = ist_table[ost->source_index];
1455 pts = (double)ost->st->pts.val * os->pts_num / os->pts_den;
1456 if (!file_table[ist->file_index].eof_reached &&
1459 file_index = ist->file_index;
1462 /* if none, if is finished */
1463 if (file_index < 0) {
1467 /* finish if recording time exhausted */
1468 if (recording_time > 0 && pts_min >= (recording_time / 1000000.0))
1471 /* read a frame from it and output it in the fifo */
1472 is = input_files[file_index];
1473 if (av_read_frame(is, &pkt) < 0) {
1474 file_table[file_index].eof_reached = 1;
1479 stream_no_data = is;
1484 av_pkt_dump(stdout, &pkt, do_hex_dump);
1486 /* the following test is needed in case new streams appear
1487 dynamically in stream : we ignore them */
1488 if (pkt.stream_index >= file_table[file_index].nb_streams)
1489 goto discard_packet;
1490 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1491 ist = ist_table[ist_index];
1493 goto discard_packet;
1495 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1496 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1497 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1498 ist->file_index, ist->index);
1499 av_free_packet(&pkt);
1504 av_free_packet(&pkt);
1506 /* dump report by using the output first video and audio streams */
1507 print_report(output_files, ost_table, nb_ostreams, 0);
1510 /* at the end of stream, we must flush the decoder buffers */
1511 for(i=0;i<nb_istreams;i++) {
1513 if (ist->decoding_needed) {
1514 output_packet(ist, i, ost_table, nb_ostreams, NULL);
1520 /* dump report by using the first video and audio streams */
1521 print_report(output_files, ost_table, nb_ostreams, 1);
1523 /* write the trailer if needed and close file */
1524 for(i=0;i<nb_output_files;i++) {
1525 os = output_files[i];
1526 av_write_trailer(os);
1529 /* close each encoder */
1530 for(i=0;i<nb_ostreams;i++) {
1532 if (ost->encoding_needed) {
1533 av_freep(&ost->st->codec.stats_in);
1534 avcodec_close(&ost->st->codec);
1538 /* close each decoder */
1539 for(i=0;i<nb_istreams;i++) {
1541 if (ist->decoding_needed) {
1542 avcodec_close(&ist->st->codec);
1550 av_free(file_table);
1553 for(i=0;i<nb_istreams;i++) {
1560 for(i=0;i<nb_ostreams;i++) {
1564 fclose(ost->logfile);
1565 ost->logfile = NULL;
1567 fifo_free(&ost->fifo); /* works even if fifo is not
1568 initialized but set to zero */
1569 av_free(ost->pict_tmp.data[0]);
1570 if (ost->video_resample)
1571 img_resample_close(ost->img_resample_ctx);
1572 if (ost->audio_resample)
1573 audio_resample_close(ost->resample);
1586 int file_read(const char *filename)
1589 unsigned char buffer[1024];
1592 if (url_open(&h, filename, O_RDONLY) < 0) {
1593 printf("could not open '%s'\n", filename);
1597 len = url_read(h, buffer, sizeof(buffer));
1600 for(i=0;i<len;i++) putchar(buffer[i]);
1607 static void opt_image_format(const char *arg)
1611 for(f = first_image_format; f != NULL; f = f->next) {
1612 if (!strcmp(arg, f->name))
1616 fprintf(stderr, "Unknown image format: '%s'\n", arg);
1622 static void opt_format(const char *arg)
1624 /* compatibility stuff for pgmyuv */
1625 if (!strcmp(arg, "pgmyuv")) {
1626 opt_image_format(arg);
1630 file_iformat = av_find_input_format(arg);
1631 file_oformat = guess_format(arg, NULL, NULL);
1632 if (!file_iformat && !file_oformat) {
1633 fprintf(stderr, "Unknown input or output format: %s\n", arg);
1638 static void opt_video_bitrate(const char *arg)
1640 video_bit_rate = atoi(arg) * 1000;
1643 static void opt_video_bitrate_tolerance(const char *arg)
1645 video_bit_rate_tolerance = atoi(arg) * 1000;
1648 static void opt_video_bitrate_max(const char *arg)
1650 video_rc_max_rate = atoi(arg) * 1000;
1653 static void opt_video_bitrate_min(const char *arg)
1655 video_rc_min_rate = atoi(arg) * 1000;
1658 static void opt_video_buffer_size(const char *arg)
1660 video_rc_buffer_size = atoi(arg) * 8*1024;
1663 static void opt_video_rc_eq(char *arg)
1668 static void opt_video_rc_override_string(char *arg)
1670 video_rc_override_string = arg;
1674 static void opt_workaround_bugs(const char *arg)
1676 workaround_bugs = atoi(arg);
1679 static void opt_dct_algo(const char *arg)
1681 dct_algo = atoi(arg);
1684 static void opt_idct_algo(const char *arg)
1686 idct_algo = atoi(arg);
1690 static void opt_error_resilience(const char *arg)
1692 error_resilience = atoi(arg);
1695 static void opt_error_concealment(const char *arg)
1697 error_concealment = atoi(arg);
1700 static void opt_debug(const char *arg)
1705 static void opt_vismv(const char *arg)
1707 debug_mv = atoi(arg);
1710 static void opt_verbose(const char *arg)
1712 verbose = atoi(arg);
1715 static void opt_frame_rate(const char *arg)
1717 if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
1718 fprintf(stderr, "Incorrect frame rate\n");
1723 static void opt_frame_crop_top(const char *arg)
1725 frame_topBand = atoi(arg);
1726 if (frame_topBand < 0) {
1727 fprintf(stderr, "Incorrect top crop size\n");
1730 if ((frame_topBand % 2) != 0) {
1731 fprintf(stderr, "Top crop size must be a multiple of 2\n");
1734 if ((frame_topBand) >= frame_height){
1735 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
1738 frame_height -= frame_topBand;
1741 static void opt_frame_crop_bottom(const char *arg)
1743 frame_bottomBand = atoi(arg);
1744 if (frame_bottomBand < 0) {
1745 fprintf(stderr, "Incorrect bottom crop size\n");
1748 if ((frame_bottomBand % 2) != 0) {
1749 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
1752 if ((frame_bottomBand) >= frame_height){
1753 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
1756 frame_height -= frame_bottomBand;
1759 static void opt_frame_crop_left(const char *arg)
1761 frame_leftBand = atoi(arg);
1762 if (frame_leftBand < 0) {
1763 fprintf(stderr, "Incorrect left crop size\n");
1766 if ((frame_leftBand % 2) != 0) {
1767 fprintf(stderr, "Left crop size must be a multiple of 2\n");
1770 if ((frame_leftBand) >= frame_width){
1771 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
1774 frame_width -= frame_leftBand;
1777 static void opt_frame_crop_right(const char *arg)
1779 frame_rightBand = atoi(arg);
1780 if (frame_rightBand < 0) {
1781 fprintf(stderr, "Incorrect right crop size\n");
1784 if ((frame_rightBand % 2) != 0) {
1785 fprintf(stderr, "Right crop size must be a multiple of 2\n");
1788 if ((frame_rightBand) >= frame_width){
1789 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
1792 frame_width -= frame_rightBand;
1795 static void opt_frame_size(const char *arg)
1797 if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
1798 fprintf(stderr, "Incorrect frame size\n");
1801 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
1802 fprintf(stderr, "Frame size must be a multiple of 2\n");
1807 static void opt_frame_pix_fmt(const char *arg)
1809 frame_pix_fmt = avcodec_get_pix_fmt(arg);
1812 static void opt_frame_aspect_ratio(const char *arg)
1818 p = strchr(arg, ':');
1820 x = strtol(arg, (char **)&arg, 10);
1822 y = strtol(arg+1, (char **)&arg, 10);
1824 ar = (double)x / (double)y;
1826 ar = strtod(arg, (char **)&arg);
1829 fprintf(stderr, "Incorrect aspect ratio specification.\n");
1832 frame_aspect_ratio = ar;
1835 static void opt_gop_size(const char *arg)
1837 gop_size = atoi(arg);
1840 static void opt_b_frames(const char *arg)
1842 b_frames = atoi(arg);
1843 if (b_frames > FF_MAX_B_FRAMES) {
1844 fprintf(stderr, "\nCannot have more than %d B frames, increase FF_MAX_B_FRAMES.\n", FF_MAX_B_FRAMES);
1846 } else if (b_frames < 1) {
1847 fprintf(stderr, "\nNumber of B frames must be higher than 0\n");
1852 static void opt_mb_decision(const char *arg)
1854 mb_decision = atoi(arg);
1857 static void opt_mb_cmp(const char *arg)
1862 static void opt_ildct_cmp(const char *arg)
1864 ildct_cmp = atoi(arg);
1867 static void opt_sub_cmp(const char *arg)
1869 sub_cmp = atoi(arg);
1872 static void opt_cmp(const char *arg)
1877 static void opt_pre_cmp(const char *arg)
1879 pre_cmp = atoi(arg);
1882 static void opt_pre_me(const char *arg)
1887 static void opt_lumi_mask(const char *arg)
1889 lumi_mask = atof(arg);
1892 static void opt_dark_mask(const char *arg)
1894 dark_mask = atof(arg);
1897 static void opt_scplx_mask(const char *arg)
1899 scplx_mask = atof(arg);
1902 static void opt_tcplx_mask(const char *arg)
1904 tcplx_mask = atof(arg);
1907 static void opt_p_mask(const char *arg)
1912 static void opt_qscale(const char *arg)
1914 video_qscale = atof(arg);
1915 if (video_qscale < 0.01 ||
1916 video_qscale > 255) {
1917 fprintf(stderr, "qscale must be >= 0.01 and <= 255\n");
1922 static void opt_qmin(const char *arg)
1924 video_qmin = atoi(arg);
1925 if (video_qmin < 0 ||
1927 fprintf(stderr, "qmin must be >= 1 and <= 31\n");
1932 static void opt_qmax(const char *arg)
1934 video_qmax = atoi(arg);
1935 if (video_qmax < 0 ||
1937 fprintf(stderr, "qmax must be >= 1 and <= 31\n");
1942 static void opt_mb_qmin(const char *arg)
1944 video_mb_qmin = atoi(arg);
1945 if (video_mb_qmin < 0 ||
1946 video_mb_qmin > 31) {
1947 fprintf(stderr, "qmin must be >= 1 and <= 31\n");
1952 static void opt_mb_qmax(const char *arg)
1954 video_mb_qmax = atoi(arg);
1955 if (video_mb_qmax < 0 ||
1956 video_mb_qmax > 31) {
1957 fprintf(stderr, "qmax must be >= 1 and <= 31\n");
1962 static void opt_qdiff(const char *arg)
1964 video_qdiff = atoi(arg);
1965 if (video_qdiff < 0 ||
1967 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
1972 static void opt_qblur(const char *arg)
1974 video_qblur = atof(arg);
1977 static void opt_qcomp(const char *arg)
1979 video_qcomp = atof(arg);
1982 static void opt_rc_initial_cplx(const char *arg)
1984 video_rc_initial_cplx = atof(arg);
1986 static void opt_b_qfactor(const char *arg)
1988 video_b_qfactor = atof(arg);
1990 static void opt_i_qfactor(const char *arg)
1992 video_i_qfactor = atof(arg);
1994 static void opt_b_qoffset(const char *arg)
1996 video_b_qoffset = atof(arg);
1998 static void opt_i_qoffset(const char *arg)
2000 video_i_qoffset = atof(arg);
2003 static void opt_ibias(const char *arg)
2005 video_intra_quant_bias = atoi(arg);
2007 static void opt_pbias(const char *arg)
2009 video_inter_quant_bias = atoi(arg);
2012 static void opt_packet_size(const char *arg)
2014 packet_size= atoi(arg);
2017 static void opt_error_rate(const char *arg)
2019 error_rate= atoi(arg);
2022 static void opt_strict(const char *arg)
2027 static void opt_top_field_first(const char *arg)
2029 top_field_first= atoi(arg);
2032 static void opt_noise_reduction(const char *arg)
2034 noise_reduction= atoi(arg);
2037 static void opt_qns(const char *arg)
2042 static void opt_sc_threshold(const char *arg)
2044 sc_threshold= atoi(arg);
2047 static void opt_thread_count(const char *arg)
2049 thread_count= atoi(arg);
2050 #if !defined(HAVE_PTHREADS) && !defined(HAVE_W32THREADS)
2051 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2055 static void opt_audio_bitrate(const char *arg)
2057 audio_bit_rate = atoi(arg) * 1000;
2060 static void opt_audio_rate(const char *arg)
2062 audio_sample_rate = atoi(arg);
2065 static void opt_audio_channels(const char *arg)
2067 audio_channels = atoi(arg);
2070 static void opt_video_device(const char *arg)
2072 video_device = av_strdup(arg);
2075 static void opt_video_channel(const char *arg)
2077 video_channel = strtol(arg, NULL, 0);
2080 static void opt_video_standard(const char *arg)
2082 video_standard = av_strdup(arg);
2085 static void opt_audio_device(const char *arg)
2087 audio_device = av_strdup(arg);
2090 static void opt_dv1394(const char *arg)
2092 video_grab_format = "dv1394";
2093 audio_grab_format = NULL;
2096 static void opt_audio_codec(const char *arg)
2100 if (!strcmp(arg, "copy")) {
2101 audio_stream_copy = 1;
2105 if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_AUDIO)
2110 fprintf(stderr, "Unknown audio codec '%s'\n", arg);
2113 audio_codec_id = p->id;
2118 static void add_frame_hooker(const char *arg)
2123 char *args = av_strdup(arg);
2127 argv[0] = strtok(args, " ");
2128 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2131 i = frame_hook_add(argc, argv);
2134 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2139 const char *motion_str[] = {
2149 static void opt_motion_estimation(const char *arg)
2155 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2158 if (!strcmp(*p, arg))
2162 me_method = (p - motion_str) + 1;
2165 static void opt_video_codec(const char *arg)
2169 if (!strcmp(arg, "copy")) {
2170 video_stream_copy = 1;
2174 if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_VIDEO)
2179 fprintf(stderr, "Unknown video codec '%s'\n", arg);
2182 video_codec_id = p->id;
2187 static void opt_map(const char *arg)
2193 m = &stream_maps[nb_stream_maps++];
2195 m->file_index = strtol(arg, (char **)&p, 0);
2199 m->stream_index = strtol(p, (char **)&p, 0);
2202 static void opt_recording_time(const char *arg)
2204 recording_time = parse_date(arg, 1);
2207 static void opt_start_time(const char *arg)
2209 start_time = parse_date(arg, 1);
2212 static void opt_input_file(const char *filename)
2214 AVFormatContext *ic;
2215 AVFormatParameters params, *ap = ¶ms;
2216 int err, i, ret, rfps, rfps_base;
2218 if (!strcmp(filename, "-"))
2221 using_stdin |= !strcmp(filename, "pipe:" ) ||
2222 !strcmp( filename, "/dev/stdin" );
2224 /* get default parameters from command line */
2225 memset(ap, 0, sizeof(*ap));
2226 ap->sample_rate = audio_sample_rate;
2227 ap->channels = audio_channels;
2228 ap->frame_rate = frame_rate;
2229 ap->frame_rate_base = frame_rate_base;
2230 ap->width = frame_width;
2231 ap->height = frame_height;
2232 ap->image_format = image_format;
2233 ap->pix_fmt = frame_pix_fmt;
2235 /* open the input file with generic libav function */
2236 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2238 print_error(filename, err);
2242 /* If not enough info to get the stream parameters, we decode the
2243 first frames to get it. (used in mpeg case for example) */
2244 ret = av_find_stream_info(ic);
2246 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2250 /* if seeking requested, we execute it */
2251 if (start_time != 0) {
2254 timestamp = start_time;
2255 /* add the stream start time */
2256 if (ic->start_time != AV_NOPTS_VALUE)
2257 timestamp += ic->start_time;
2258 ret = av_seek_frame(ic, -1, timestamp);
2260 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2261 filename, (double)timestamp / AV_TIME_BASE);
2263 /* reset seek info */
2267 /* update the current parameters so that they match the one of the input stream */
2268 for(i=0;i<ic->nb_streams;i++) {
2269 AVCodecContext *enc = &ic->streams[i]->codec;
2270 #if defined(HAVE_PTHREADS) || defined(HAVE_W32THREADS)
2272 avcodec_thread_init(enc, thread_count);
2274 enc->thread_count= thread_count;
2275 switch(enc->codec_type) {
2276 case CODEC_TYPE_AUDIO:
2277 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2278 audio_channels = enc->channels;
2279 audio_sample_rate = enc->sample_rate;
2281 case CODEC_TYPE_VIDEO:
2282 frame_height = enc->height;
2283 frame_width = enc->width;
2284 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2285 frame_pix_fmt = enc->pix_fmt;
2286 rfps = ic->streams[i]->r_frame_rate;
2287 rfps_base = ic->streams[i]->r_frame_rate_base;
2288 enc->workaround_bugs = workaround_bugs;
2289 enc->error_resilience = error_resilience;
2290 enc->error_concealment = error_concealment;
2291 enc->idct_algo = idct_algo;
2293 enc->debug_mv = debug_mv;
2295 enc->flags|= CODEC_FLAG_BITEXACT;
2297 assert(enc->frame_rate_base == rfps_base); // should be true for now
2298 if (enc->frame_rate != rfps) {
2299 fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f->%2.2f\n",
2300 i, (float)enc->frame_rate / enc->frame_rate_base,
2301 (float)rfps / rfps_base);
2303 /* update the current frame rate to match the stream frame rate */
2305 frame_rate_base = rfps_base;
2307 enc->rate_emu = rate_emu;
2309 case CODEC_TYPE_DATA:
2316 input_files[nb_input_files] = ic;
2317 /* dump the file content */
2318 dump_format(ic, nb_input_files, filename, 0);
2320 file_iformat = NULL;
2321 file_oformat = NULL;
2322 image_format = NULL;
2327 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2329 int has_video, has_audio, i, j;
2330 AVFormatContext *ic;
2334 for(j=0;j<nb_input_files;j++) {
2335 ic = input_files[j];
2336 for(i=0;i<ic->nb_streams;i++) {
2337 AVCodecContext *enc = &ic->streams[i]->codec;
2338 switch(enc->codec_type) {
2339 case CODEC_TYPE_AUDIO:
2342 case CODEC_TYPE_VIDEO:
2350 *has_video_ptr = has_video;
2351 *has_audio_ptr = has_audio;
2354 static void opt_output_file(const char *filename)
2357 AVFormatContext *oc;
2358 int use_video, use_audio, nb_streams, input_has_video, input_has_audio;
2360 AVFormatParameters params, *ap = ¶ms;
2362 if (!strcmp(filename, "-"))
2365 oc = av_alloc_format_context();
2367 if (!file_oformat) {
2368 file_oformat = guess_format(NULL, filename, NULL);
2369 if (!file_oformat) {
2370 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
2376 oc->oformat = file_oformat;
2378 if (!strcmp(file_oformat->name, "ffm") &&
2379 strstart(filename, "http:", NULL)) {
2380 /* special case for files sent to ffserver: we get the stream
2381 parameters from ffserver */
2382 if (read_ffserver_streams(oc, filename) < 0) {
2383 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
2387 use_video = file_oformat->video_codec != CODEC_ID_NONE;
2388 use_audio = file_oformat->audio_codec != CODEC_ID_NONE;
2390 /* disable if no corresponding type found and at least one
2392 if (nb_input_files > 0) {
2393 check_audio_video_inputs(&input_has_video, &input_has_audio);
2394 if (!input_has_video)
2396 if (!input_has_audio)
2400 /* manual disable */
2401 if (audio_disable) {
2404 if (video_disable) {
2410 AVCodecContext *video_enc;
2412 st = av_mallocz(sizeof(AVStream));
2414 fprintf(stderr, "Could not alloc stream\n");
2417 avcodec_get_context_defaults(&st->codec);
2418 #if defined(HAVE_PTHREADS) || defined(HAVE_W32THREADS)
2420 avcodec_thread_init(&st->codec, thread_count);
2423 video_enc = &st->codec;
2425 if(!strcmp(file_oformat->name, "mp4") || !strcmp(file_oformat->name, "mov") || !strcmp(file_oformat->name, "3gp"))
2426 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2427 if (video_stream_copy) {
2428 st->stream_copy = 1;
2429 video_enc->codec_type = CODEC_TYPE_VIDEO;
2434 codec_id = file_oformat->video_codec;
2435 if (video_codec_id != CODEC_ID_NONE)
2436 codec_id = video_codec_id;
2438 video_enc->codec_id = codec_id;
2440 video_enc->bit_rate = video_bit_rate;
2441 video_enc->bit_rate_tolerance = video_bit_rate_tolerance;
2442 video_enc->frame_rate = frame_rate;
2443 video_enc->frame_rate_base = frame_rate_base;
2445 video_enc->width = frame_width;
2446 video_enc->height = frame_height;
2447 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
2448 video_enc->pix_fmt = frame_pix_fmt;
2451 video_enc->gop_size = gop_size;
2453 video_enc->gop_size = 0;
2454 if (video_qscale || same_quality) {
2455 video_enc->flags |= CODEC_FLAG_QSCALE;
2456 st->quality = FF_QP2LAMBDA * video_qscale;
2460 video_enc->intra_matrix = intra_matrix;
2462 video_enc->inter_matrix = inter_matrix;
2465 video_enc->flags |= CODEC_FLAG_BITEXACT;
2467 video_enc->mb_decision = mb_decision;
2468 video_enc->mb_cmp = mb_cmp;
2469 video_enc->ildct_cmp = ildct_cmp;
2470 video_enc->me_sub_cmp = sub_cmp;
2471 video_enc->me_cmp = cmp;
2472 video_enc->me_pre_cmp = pre_cmp;
2473 video_enc->pre_me = pre_me;
2474 video_enc->lumi_masking = lumi_mask;
2475 video_enc->dark_masking = dark_mask;
2476 video_enc->spatial_cplx_masking = scplx_mask;
2477 video_enc->temporal_cplx_masking = tcplx_mask;
2478 video_enc->p_masking = p_mask;
2479 video_enc->quantizer_noise_shaping= qns;
2482 video_enc->flags |= CODEC_FLAG_H263P_UMV;
2485 video_enc->flags |= CODEC_FLAG_H263P_AIC;
2488 video_enc->flags |= CODEC_FLAG_H263P_AIV;
2491 video_enc->flags |= CODEC_FLAG_4MV;
2494 video_enc->flags |= CODEC_FLAG_OBMC;
2498 video_enc->flags |= CODEC_FLAG_PART;
2501 video_enc->flags |= CODEC_FLAG_ALT_SCAN;
2504 video_enc->flags |= CODEC_FLAG_TRELLIS_QUANT;
2506 if (use_scan_offset) {
2507 video_enc->flags |= CODEC_FLAG_SVCD_SCAN_OFFSET;
2510 video_enc->flags |= CODEC_FLAG_CLOSED_GOP;
2513 video_enc->max_b_frames = b_frames;
2514 video_enc->b_frame_strategy = 0;
2515 video_enc->b_quant_factor = 2.0;
2517 if (do_interlace_dct) {
2518 video_enc->flags |= CODEC_FLAG_INTERLACED_DCT;
2520 if (do_interlace_me) {
2521 video_enc->flags |= CODEC_FLAG_INTERLACED_ME;
2523 video_enc->qmin = video_qmin;
2524 video_enc->qmax = video_qmax;
2525 video_enc->mb_qmin = video_mb_qmin;
2526 video_enc->mb_qmax = video_mb_qmax;
2527 video_enc->max_qdiff = video_qdiff;
2528 video_enc->qblur = video_qblur;
2529 video_enc->qcompress = video_qcomp;
2530 video_enc->rc_eq = video_rc_eq;
2531 video_enc->debug = debug;
2532 video_enc->debug_mv = debug_mv;
2533 video_enc->thread_count = thread_count;
2534 p= video_rc_override_string;
2537 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2539 fprintf(stderr, "error parsing rc_override\n");
2542 video_enc->rc_override=
2543 av_realloc(video_enc->rc_override,
2544 sizeof(RcOverride)*(i+1));
2545 video_enc->rc_override[i].start_frame= start;
2546 video_enc->rc_override[i].end_frame = end;
2548 video_enc->rc_override[i].qscale= q;
2549 video_enc->rc_override[i].quality_factor= 1.0;
2552 video_enc->rc_override[i].qscale= 0;
2553 video_enc->rc_override[i].quality_factor= -q/100.0;
2558 video_enc->rc_override_count=i;
2560 video_enc->rc_max_rate = video_rc_max_rate;
2561 video_enc->rc_min_rate = video_rc_min_rate;
2562 video_enc->rc_buffer_size = video_rc_buffer_size;
2563 video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
2564 video_enc->rc_initial_cplx= video_rc_initial_cplx;
2565 video_enc->i_quant_factor = video_i_qfactor;
2566 video_enc->b_quant_factor = video_b_qfactor;
2567 video_enc->i_quant_offset = video_i_qoffset;
2568 video_enc->b_quant_offset = video_b_qoffset;
2569 video_enc->intra_quant_bias = video_intra_quant_bias;
2570 video_enc->inter_quant_bias = video_inter_quant_bias;
2571 video_enc->dct_algo = dct_algo;
2572 video_enc->idct_algo = idct_algo;
2573 video_enc->strict_std_compliance = strict;
2574 video_enc->error_rate = error_rate;
2575 video_enc->noise_reduction= noise_reduction;
2576 video_enc->scenechange_threshold= sc_threshold;
2578 video_enc->rtp_mode= 1;
2579 video_enc->rtp_payload_size= packet_size;
2583 video_enc->flags|= CODEC_FLAG_PSNR;
2585 video_enc->me_method = me_method;
2590 video_enc->flags |= CODEC_FLAG_PASS1;
2592 video_enc->flags |= CODEC_FLAG_PASS2;
2596 oc->streams[nb_streams] = st;
2601 AVCodecContext *audio_enc;
2603 st = av_mallocz(sizeof(AVStream));
2605 fprintf(stderr, "Could not alloc stream\n");
2608 avcodec_get_context_defaults(&st->codec);
2609 #if defined(HAVE_PTHREADS) || defined(HAVE_W32THREADS)
2611 avcodec_thread_init(&st->codec, thread_count);
2614 audio_enc = &st->codec;
2615 audio_enc->codec_type = CODEC_TYPE_AUDIO;
2617 if(!strcmp(file_oformat->name, "mp4") || !strcmp(file_oformat->name, "mov") || !strcmp(file_oformat->name, "3gp"))
2618 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2619 if (audio_stream_copy) {
2620 st->stream_copy = 1;
2622 codec_id = file_oformat->audio_codec;
2623 if (audio_codec_id != CODEC_ID_NONE)
2624 codec_id = audio_codec_id;
2625 audio_enc->codec_id = codec_id;
2627 audio_enc->bit_rate = audio_bit_rate;
2628 audio_enc->sample_rate = audio_sample_rate;
2629 audio_enc->strict_std_compliance = strict;
2630 audio_enc->thread_count = thread_count;
2631 /* For audio codecs other than AC3 we limit */
2632 /* the number of coded channels to stereo */
2633 if (audio_channels > 2 && codec_id != CODEC_ID_AC3) {
2634 audio_enc->channels = 2;
2636 audio_enc->channels = audio_channels;
2638 oc->streams[nb_streams] = st;
2642 oc->nb_streams = nb_streams;
2645 fprintf(stderr, "No audio or video streams available\n");
2650 pstrcpy(oc->title, sizeof(oc->title), str_title);
2652 pstrcpy(oc->author, sizeof(oc->author), str_author);
2654 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
2656 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
2659 output_files[nb_output_files++] = oc;
2661 strcpy(oc->filename, filename);
2663 /* check filename in case of an image number is expected */
2664 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
2665 if (filename_number_test(oc->filename) < 0) {
2666 print_error(oc->filename, AVERROR_NUMEXPECTED);
2671 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
2672 /* test if it already exists to avoid loosing precious files */
2673 if (!file_overwrite &&
2674 (strchr(filename, ':') == NULL ||
2675 strstart(filename, "file:", NULL))) {
2676 if (url_exist(filename)) {
2679 if ( !using_stdin ) {
2680 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
2683 if (toupper(c) != 'Y') {
2684 fprintf(stderr, "Not overwriting - exiting\n");
2689 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
2696 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
2697 fprintf(stderr, "Could not open '%s'\n", filename);
2702 memset(ap, 0, sizeof(*ap));
2703 ap->image_format = image_format;
2704 if (av_set_parameters(oc, ap) < 0) {
2705 fprintf(stderr, "%s: Invalid encoding parameters\n",
2710 /* reset some options */
2711 file_oformat = NULL;
2712 file_iformat = NULL;
2713 image_format = NULL;
2716 audio_codec_id = CODEC_ID_NONE;
2717 video_codec_id = CODEC_ID_NONE;
2718 audio_stream_copy = 0;
2719 video_stream_copy = 0;
2722 /* prepare dummy protocols for grab */
2723 static void prepare_grab(void)
2725 int has_video, has_audio, i, j;
2726 AVFormatContext *oc;
2727 AVFormatContext *ic;
2728 AVFormatParameters vp1, *vp = &vp1;
2729 AVFormatParameters ap1, *ap = &ap1;
2731 /* see if audio/video inputs are needed */
2734 memset(ap, 0, sizeof(*ap));
2735 memset(vp, 0, sizeof(*vp));
2736 for(j=0;j<nb_output_files;j++) {
2737 oc = output_files[j];
2738 for(i=0;i<oc->nb_streams;i++) {
2739 AVCodecContext *enc = &oc->streams[i]->codec;
2740 switch(enc->codec_type) {
2741 case CODEC_TYPE_AUDIO:
2742 if (enc->sample_rate > ap->sample_rate)
2743 ap->sample_rate = enc->sample_rate;
2744 if (enc->channels > ap->channels)
2745 ap->channels = enc->channels;
2748 case CODEC_TYPE_VIDEO:
2749 if (enc->width > vp->width)
2750 vp->width = enc->width;
2751 if (enc->height > vp->height)
2752 vp->height = enc->height;
2754 assert(enc->frame_rate_base == DEFAULT_FRAME_RATE_BASE);
2755 if (enc->frame_rate > vp->frame_rate){
2756 vp->frame_rate = enc->frame_rate;
2757 vp->frame_rate_base = enc->frame_rate_base;
2767 if (has_video == 0 && has_audio == 0) {
2768 fprintf(stderr, "Output file must have at least one audio or video stream\n");
2773 AVInputFormat *fmt1;
2774 fmt1 = av_find_input_format(video_grab_format);
2775 vp->device = video_device;
2776 vp->channel = video_channel;
2777 vp->standard = video_standard;
2778 if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
2779 fprintf(stderr, "Could not find video grab device\n");
2782 /* If not enough info to get the stream parameters, we decode the
2783 first frames to get it. */
2784 if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
2785 fprintf(stderr, "Could not find video grab parameters\n");
2788 /* by now video grab has one stream */
2789 ic->streams[0]->r_frame_rate = vp->frame_rate;
2790 ic->streams[0]->r_frame_rate_base = vp->frame_rate_base;
2791 input_files[nb_input_files] = ic;
2792 dump_format(ic, nb_input_files, "", 0);
2795 if (has_audio && audio_grab_format) {
2796 AVInputFormat *fmt1;
2797 fmt1 = av_find_input_format(audio_grab_format);
2798 ap->device = audio_device;
2799 if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
2800 fprintf(stderr, "Could not find audio grab device\n");
2803 input_files[nb_input_files] = ic;
2804 dump_format(ic, nb_input_files, "", 0);
2809 /* same option as mencoder */
2810 static void opt_pass(const char *pass_str)
2813 pass = atoi(pass_str);
2814 if (pass != 1 && pass != 2) {
2815 fprintf(stderr, "pass number can be only 1 or 2\n");
2821 #if defined(CONFIG_WIN32) || defined(CONFIG_OS2)
2822 static int64_t getutime(void)
2824 return av_gettime();
2827 static int64_t getutime(void)
2829 struct rusage rusage;
2831 getrusage(RUSAGE_SELF, &rusage);
2832 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
2836 extern int ffm_nopts;
2838 static void opt_bitexact(void)
2841 /* disable generate of real time pts in ffm (need to be supressed anyway) */
2845 static void show_formats(void)
2847 AVInputFormat *ifmt;
2848 AVOutputFormat *ofmt;
2849 AVImageFormat *image_fmt;
2852 const char **pp, *last_name;
2854 printf("File formats:\n");
2859 const char *name=NULL;
2861 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
2862 if((name == NULL || strcmp(ofmt->name, name)<0) &&
2863 strcmp(ofmt->name, last_name)>0){
2868 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
2869 if((name == NULL || strcmp(ifmt->name, name)<0) &&
2870 strcmp(ifmt->name, last_name)>0){
2874 if(name && strcmp(ifmt->name, name)==0)
2889 printf("Image formats:\n");
2890 for(image_fmt = first_image_format; image_fmt != NULL;
2891 image_fmt = image_fmt->next) {
2894 image_fmt->img_read ? "D":" ",
2895 image_fmt->img_write ? "E":" ",
2900 printf("Codecs:\n");
2908 for(p = first_avcodec; p != NULL; p = p->next) {
2909 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
2910 strcmp(p->name, last_name)>0){
2912 decode= encode= cap=0;
2914 if(p2 && strcmp(p->name, p2->name)==0){
2915 if(p->decode) decode=1;
2916 if(p->encode) encode=1;
2917 cap |= p->capabilities;
2922 last_name= p2->name;
2926 decode ? "D": (/*p2->decoder ? "d":*/" "),
2928 p2->type == CODEC_TYPE_AUDIO ? "A":"V",
2929 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
2930 cap & CODEC_CAP_DR1 ? "D":" ",
2931 cap & CODEC_CAP_TRUNCATED ? "T":" ",
2933 /* if(p2->decoder && decode==0)
2934 printf(" use %s for decoding", p2->decoder->name);*/
2939 printf("Supported file protocols:\n");
2940 for(up = first_protocol; up != NULL; up = up->next)
2941 printf(" %s:", up->name);
2944 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
2945 printf("Motion estimation methods:\n");
2949 if ((pp - motion_str + 1) == ME_ZERO)
2950 printf("(fastest)");
2951 else if ((pp - motion_str + 1) == ME_FULL)
2952 printf("(slowest)");
2953 else if ((pp - motion_str + 1) == ME_EPZS)
2954 printf("(default)");
2959 "Note, the names of encoders and decoders dont always match, so there are\n"
2960 "several cases where the above table shows encoder only or decoder only entries\n"
2961 "even though both encoding and decoding are supported for example, the h263\n"
2962 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
2967 void parse_matrix_coeffs(uint16_t *dest, const char *str)
2970 const char *p = str;
2977 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
2984 void opt_inter_matrix(const char *arg)
2986 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
2987 parse_matrix_coeffs(inter_matrix, arg);
2990 void opt_intra_matrix(const char *arg)
2992 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
2993 parse_matrix_coeffs(intra_matrix, arg);
2996 static void opt_target(const char *arg)
3000 if(!strncmp(arg, "pal-", 4)) {
3003 } else if(!strncmp(arg, "ntsc-", 5)) {
3008 /* Calculate FR via float to avoid int overflow */
3009 fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3012 } else if((fr == 29970) || (fr == 23976)) {
3015 /* Try to determine PAL/NTSC by peeking in the input files */
3016 if(nb_input_files) {
3018 for(j = 0; j < nb_input_files; j++) {
3019 for(i = 0; i < input_files[j]->nb_streams; i++) {
3020 AVCodecContext *c = &input_files[j]->streams[i]->codec;
3021 if(c->codec_type != CODEC_TYPE_VIDEO)
3023 fr = c->frame_rate * 1000 / c->frame_rate_base;
3027 } else if((fr == 29970) || (fr == 23976)) {
3037 if(verbose && norm >= 0)
3038 printf("Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3042 fprintf(stderr, "Could not determine norm (PAL/NTSC) for target.\n");
3043 fprintf(stderr, "Please prefix target with \"pal-\" or \"ntsc-\",\n");
3044 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3048 if(!strcmp(arg, "vcd")) {
3050 opt_video_codec("mpeg1video");
3051 opt_audio_codec("mp2");
3054 opt_frame_size(norm ? "352x240" : "352x288");
3056 video_bit_rate = 1150000;
3057 video_rc_max_rate = 1150000;
3058 video_rc_min_rate = 1150000;
3059 video_rc_buffer_size = 40*1024*8;
3061 audio_bit_rate = 224000;
3062 audio_sample_rate = 44100;
3064 } else if(!strcmp(arg, "svcd")) {
3066 opt_video_codec("mpeg2video");
3067 opt_audio_codec("mp2");
3070 opt_frame_size(norm ? "480x480" : "480x576");
3071 opt_gop_size(norm ? "18" : "15");
3073 video_bit_rate = 2040000;
3074 video_rc_max_rate = 2516000;
3075 video_rc_min_rate = 0; //1145000;
3076 video_rc_buffer_size = 224*1024*8;
3077 use_scan_offset = 1;
3079 audio_bit_rate = 224000;
3080 audio_sample_rate = 44100;
3082 } else if(!strcmp(arg, "dvd")) {
3084 opt_video_codec("mpeg2video");
3085 opt_audio_codec("ac3");
3088 opt_frame_size(norm ? "720x480" : "720x576");
3089 opt_gop_size(norm ? "18" : "15");
3091 video_bit_rate = 6000000;
3092 video_rc_max_rate = 9000000;
3093 video_rc_min_rate = 0; //1500000;
3094 video_rc_buffer_size = 224*1024*8;
3096 audio_bit_rate = 448000;
3097 audio_sample_rate = 48000;
3100 fprintf(stderr, "Unknown target: %s\n", arg);
3105 const OptionDef options[] = {
3107 { "L", 0, {(void*)show_license}, "show license" },
3108 { "h", 0, {(void*)show_help}, "show help" },
3109 { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3110 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3111 { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
3112 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3113 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3114 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream" },
3115 { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3116 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3117 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3118 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3119 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3120 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3121 { "debug", HAS_ARG | OPT_EXPERT, {(void*)opt_debug}, "print specific debug info", "" },
3122 { "vismv", HAS_ARG | OPT_EXPERT, {(void*)opt_vismv}, "visualize motion vectors", "" },
3123 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3124 "add timings for benchmarking" },
3125 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3126 "dump each input packet" },
3127 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3128 "when dumping packets, also dump the payload" },
3129 { "bitexact", OPT_EXPERT, {(void*)opt_bitexact}, "only use bit exact algorithms (for codec testing)" },
3130 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3131 { "loop", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3132 { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3133 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\" or \"dvd\")", "type" },
3134 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3137 { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate}, "set video bitrate (in kbit/s)", "bitrate" },
3138 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3139 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3140 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3141 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3142 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3143 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3144 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3145 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3146 { "g", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_gop_size}, "set the group of picture size", "gop_size" },
3147 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3148 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3149 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
3150 { "qmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
3151 { "qmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
3152 { "mbqmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_qmin}, "min macroblock quantiser scale (VBR)", "q" },
3153 { "mbqmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_qmax}, "max macroblock quantiser scale (VBR)", "q" },
3154 { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
3155 { "qblur", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qblur}, "video quantiser scale blur (VBR)", "blur" },
3156 { "qcomp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qcomp}, "video quantiser scale compression (VBR)", "compression" },
3157 { "rc_init_cplx", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_rc_initial_cplx}, "initial complexity for 1-pass encoding", "complexity" },
3158 { "b_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qfactor}, "qp factor between p and b frames", "factor" },
3159 { "i_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qfactor}, "qp factor between p and i frames", "factor" },
3160 { "b_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qoffset}, "qp offset between p and b frames", "offset" },
3161 { "i_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qoffset}, "qp offset between p and i frames", "offset" },
3162 { "ibias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ibias}, "intra quant bias", "bias" },
3163 { "pbias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pbias}, "inter quant bias", "bias" },
3164 // { "b_strategy", HAS_ARG | OPT_EXPERT, {(void*)opt_b_strategy}, "dynamic b frame selection strategy", "strategy" },
3165 { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3166 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3167 { "bt", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_tolerance}, "set video bitrate tolerance (in kbit/s)", "tolerance" },
3168 { "maxrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_max}, "set max video bitrate tolerance (in kbit/s)", "bitrate" },
3169 { "minrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_min}, "set min video bitrate tolerance (in kbit/s)", "bitrate" },
3170 { "bufsize", HAS_ARG | OPT_VIDEO, {(void*)opt_video_buffer_size}, "set ratecontrol buffere size (in kByte)", "size" },
3171 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3172 { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
3174 { "dct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dct_algo}, "set dct algo", "algo" },
3175 { "idct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_idct_algo}, "set idct algo", "algo" },
3176 { "er", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_resilience}, "set error resilience", "n" },
3177 { "ec", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_concealment}, "set error concealment", "bit_mask" },
3178 { "bf", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_frames}, "use 'frames' B frames", "frames" },
3179 { "hq", OPT_BOOL, {(void*)&mb_decision}, "activate high quality settings" },
3180 { "mbd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_decision}, "macroblock decision", "mode" },
3181 { "mbcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_cmp}, "macroblock compare function", "cmp function" },
3182 { "ildctcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ildct_cmp}, "ildct compare function", "cmp function" },
3183 { "subcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sub_cmp}, "subpel compare function", "cmp function" },
3184 { "cmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_cmp}, "fullpel compare function", "cmp function" },
3185 { "precmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_cmp}, "pre motion estimation compare function", "cmp function" },
3186 { "preme", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_me}, "pre motion estimation", "" },
3187 { "lumi_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lumi_mask}, "luminance masking", "" },
3188 { "dark_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dark_mask}, "darkness masking", "" },
3189 { "scplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_scplx_mask}, "spatial complexity masking", "" },
3190 { "tcplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_tcplx_mask}, "teporal complexity masking", "" },
3191 { "p_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_p_mask}, "inter masking", "" },
3192 { "4mv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_4mv}, "use four motion vector by macroblock (MPEG4)" },
3193 { "obmc", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_obmc}, "use overlapped block motion compensation (h263+)" },
3194 { "part", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_part}, "use data partitioning (MPEG4)" },
3195 { "bug", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_workaround_bugs}, "workaround not auto detected encoder bugs", "param" },
3196 { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
3197 { "error", HAS_ARG | OPT_EXPERT, {(void*)opt_error_rate}, "error rate", "rate" },
3198 { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standarts", "strictness" },
3199 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3200 "use same video quality as source (implies VBR)" },
3201 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3202 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3203 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3204 "deinterlace pictures" },
3205 { "ildct", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_dct},
3206 "force interlaced dct support in encoder (MPEG2/MPEG4)" },
3207 { "ilme", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_me},
3208 "force interlacied me support in encoder MPEG2" },
3209 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3210 { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
3211 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3212 { "aic", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aic}, "enable Advanced intra coding (h263+)" },
3213 { "aiv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aiv}, "enable Alternative inter vlc (h263+)" },
3214 { "umv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_umv}, "enable Unlimited Motion Vector (h263+)" },
3215 { "alt", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_alt_scan}, "enable alternate scantable (mpeg2)" },
3216 { "trell", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_trell}, "enable trellis quantization" },
3217 { "cgop", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&closed_gop}, "closed gop" },
3218 { "scan_offset", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_scan_offset}, "enable SVCD Scan Offset placeholder" },
3219 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3220 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3221 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3222 { "nr", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_noise_reduction}, "noise reduction", "" },
3223 { "qns", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qns}, "quantization noise shaping", "" },
3224 { "sc_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sc_threshold}, "scene change threshold", "threshold" },
3227 { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
3228 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3229 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3230 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3231 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3234 { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
3235 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3236 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3237 { "dv1394", OPT_EXPERT | OPT_GRAB, {(void*)opt_dv1394}, "set DV1394 grab", "" },
3238 { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
3242 static void show_banner(void)
3244 printf("ffmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2003 Fabrice Bellard\n");
3247 static void show_license(void)
3251 "This library is free software; you can redistribute it and/or\n"
3252 "modify it under the terms of the GNU Lesser General Public\n"
3253 "License as published by the Free Software Foundation; either\n"
3254 "version 2 of the License, or (at your option) any later version.\n"
3256 "This library is distributed in the hope that it will be useful,\n"
3257 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3258 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
3259 "Lesser General Public License for more details.\n"
3261 "You should have received a copy of the GNU Lesser General Public\n"
3262 "License along with this library; if not, write to the Free Software\n"
3263 "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\n"
3268 static void show_help(void)
3271 printf("usage: ffmpeg [[options] -i input_file]... {[options] outfile}...\n"
3272 "Hyper fast Audio and Video encoder\n");
3274 show_help_options(options, "Main options:\n",
3275 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3276 show_help_options(options, "\nVideo options:\n",
3277 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3279 show_help_options(options, "\nAdvanced Video options:\n",
3280 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3281 OPT_VIDEO | OPT_EXPERT);
3282 show_help_options(options, "\nAudio options:\n",
3283 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3285 show_help_options(options, "\nAdvanced Audio options:\n",
3286 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3287 OPT_AUDIO | OPT_EXPERT);
3288 show_help_options(options, "\nAudio/Video grab options:\n",
3291 show_help_options(options, "\nAdvanced options:\n",
3292 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3297 void parse_arg_file(const char *filename)
3299 opt_output_file(filename);
3302 int main(int argc, char **argv)
3313 parse_options(argc, argv, options);
3315 /* file converter / grab */
3316 if (nb_output_files <= 0) {
3317 fprintf(stderr, "Must supply at least one output file\n");
3321 if (nb_input_files == 0) {
3326 av_encode(output_files, nb_output_files, input_files, nb_input_files,
3327 stream_maps, nb_stream_maps);
3328 ti = getutime() - ti;
3330 printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3334 for(i=0;i<nb_output_files;i++) {
3335 /* maybe av_close_output_file ??? */
3336 AVFormatContext *s = output_files[i];
3338 if (!(s->oformat->flags & AVFMT_NOFILE))
3340 for(j=0;j<s->nb_streams;j++)
3341 av_free(s->streams[j]);
3344 for(i=0;i<nb_input_files;i++)
3345 av_close_input_file(input_files[i]);
3350 av_free(intra_matrix);
3352 av_free(inter_matrix);
3354 #ifdef POWERPC_PERFORMANCE_REPORT
3355 extern void powerpc_display_perf_report(void);
3356 powerpc_display_perf_report();
3357 #endif /* POWERPC_PERFORMANCE_REPORT */
3359 #ifndef CONFIG_WIN32
3360 if (received_sigterm) {
3362 "Received signal %d: terminating.\n",
3363 (int) received_sigterm);
3367 exit(0); /* not all OS-es handle main() return value */