3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 /* needed for usleep() */
23 #define _XOPEN_SOURCE 600
34 #include "libavformat/avformat.h"
35 #include "libavdevice/avdevice.h"
36 #include "libswscale/swscale.h"
37 #include "libavformat/framehook.h"
38 #include "libavcodec/opt.h"
39 #include "libavcodec/audioconvert.h"
40 #include "libavutil/fifo.h"
41 #include "libavutil/avstring.h"
42 #include "libavformat/os_support.h"
44 #ifdef HAVE_SYS_RESOURCE_H
45 #include <sys/types.h>
46 #include <sys/resource.h>
47 #elif defined(HAVE_GETPROCESSTIMES)
51 #ifdef HAVE_SYS_SELECT_H
52 #include <sys/select.h>
57 #include <sys/ioctl.h>
60 #elif defined(HAVE_CONIO_H)
63 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
73 const char program_name[] = "FFmpeg";
74 const int program_birth_year = 2000;
76 /* select an input stream for an output stream */
77 typedef struct AVStreamMap {
81 int sync_stream_index;
84 /** select an input file for an output file */
85 typedef struct AVMetaDataMap {
90 static const OptionDef options[];
94 static AVFormatContext *input_files[MAX_FILES];
95 static int64_t input_files_ts_offset[MAX_FILES];
96 static double input_files_ts_scale[MAX_FILES][MAX_STREAMS];
97 static AVCodec *input_codecs[MAX_FILES*MAX_STREAMS];
98 static int nb_input_files = 0;
99 static int nb_icodecs;
101 static AVFormatContext *output_files[MAX_FILES];
102 static AVCodec *output_codecs[MAX_FILES*MAX_STREAMS];
103 static int nb_output_files = 0;
104 static int nb_ocodecs;
106 static AVStreamMap stream_maps[MAX_FILES*MAX_STREAMS];
107 static int nb_stream_maps;
109 static AVMetaDataMap meta_data_maps[MAX_FILES];
110 static int nb_meta_data_maps;
112 static AVInputFormat *file_iformat;
113 static AVOutputFormat *file_oformat;
114 static int frame_width = 0;
115 static int frame_height = 0;
116 static float frame_aspect_ratio = 0;
117 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
118 static enum SampleFormat audio_sample_fmt = SAMPLE_FMT_NONE;
119 static int frame_padtop = 0;
120 static int frame_padbottom = 0;
121 static int frame_padleft = 0;
122 static int frame_padright = 0;
123 static int padcolor[3] = {16,128,128}; /* default to black */
124 static int frame_topBand = 0;
125 static int frame_bottomBand = 0;
126 static int frame_leftBand = 0;
127 static int frame_rightBand = 0;
128 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
129 static AVRational frame_rate;
130 static float video_qscale = 0;
131 static uint16_t *intra_matrix = NULL;
132 static uint16_t *inter_matrix = NULL;
133 #if 0 //experimental, (can be removed)
134 static float video_rc_qsquish=1.0;
135 static float video_rc_qmod_amp=0;
136 static int video_rc_qmod_freq=0;
138 static const char *video_rc_override_string=NULL;
139 static int video_disable = 0;
140 static int video_discard = 0;
141 static char *video_codec_name = NULL;
142 static int video_codec_tag = 0;
143 static int same_quality = 0;
144 static int do_deinterlace = 0;
145 static int top_field_first = -1;
146 static int me_threshold = 0;
147 static int intra_dc_precision = 8;
148 static int loop_input = 0;
149 static int loop_output = AVFMT_NOOUTPUTLOOP;
150 static int qp_hist = 0;
152 static int intra_only = 0;
153 static int audio_sample_rate = 44100;
154 #define QSCALE_NONE -99999
155 static float audio_qscale = QSCALE_NONE;
156 static int audio_disable = 0;
157 static int audio_channels = 1;
158 static char *audio_codec_name = NULL;
159 static int audio_codec_tag = 0;
160 static char *audio_language = NULL;
162 static int subtitle_disable = 0;
163 static char *subtitle_codec_name = NULL;
164 static char *subtitle_language = NULL;
166 static float mux_preload= 0.5;
167 static float mux_max_delay= 0.7;
169 static int64_t recording_time = INT64_MAX;
170 static int64_t start_time = 0;
171 static int64_t rec_timestamp = 0;
172 static int64_t input_ts_offset = 0;
173 static int file_overwrite = 0;
174 static char *str_title = NULL;
175 static char *str_author = NULL;
176 static char *str_copyright = NULL;
177 static char *str_comment = NULL;
178 static char *str_genre = NULL;
179 static char *str_album = NULL;
180 static int do_benchmark = 0;
181 static int do_hex_dump = 0;
182 static int do_pkt_dump = 0;
183 static int do_psnr = 0;
184 static int do_pass = 0;
185 static char *pass_logfilename = NULL;
186 static int audio_stream_copy = 0;
187 static int video_stream_copy = 0;
188 static int subtitle_stream_copy = 0;
189 static int video_sync_method= -1;
190 static int audio_sync_method= 0;
191 static float audio_drift_threshold= 0.1;
192 static int copy_ts= 0;
193 static int opt_shortest = 0; //
194 static int video_global_header = 0;
195 static char *vstats_filename;
196 static FILE *vstats_file;
197 static int opt_programid = 0;
199 static int rate_emu = 0;
201 static int video_channel = 0;
202 static char *video_standard;
204 static int audio_volume = 256;
206 static int exit_on_error = 0;
207 static int using_stdin = 0;
208 static int using_vhook = 0;
209 static int verbose = 1;
210 static int thread_count= 1;
211 static int q_pressed = 0;
212 static int64_t video_size = 0;
213 static int64_t audio_size = 0;
214 static int64_t extra_size = 0;
215 static int nb_frames_dup = 0;
216 static int nb_frames_drop = 0;
217 static int input_sync;
218 static uint64_t limit_filesize = 0; //
219 static int force_fps = 0;
221 static int pgmyuv_compatibility_hack=0;
222 static float dts_delta_threshold = 10;
224 static unsigned int sws_flags = SWS_BICUBIC;
226 static int64_t timer_start;
228 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
229 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
230 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
231 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
233 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
235 struct AVInputStream;
237 typedef struct AVOutputStream {
238 int file_index; /* file index */
239 int index; /* stream index in the output file */
240 int source_index; /* AVInputStream index */
241 AVStream *st; /* stream in the output file */
242 int encoding_needed; /* true if encoding needed for this stream */
244 /* input pts and corresponding output pts
246 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
247 struct AVInputStream *sync_ist; /* input stream to sync against */
248 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
251 AVFrame pict_tmp; /* temporary image for resampling */
252 struct SwsContext *img_resample_ctx; /* for image resampling */
256 int topBand; /* cropping area sizes */
260 int padtop; /* padding area sizes */
267 ReSampleContext *resample; /* for audio resampling */
269 AVAudioConvert *reformat_ctx;
270 AVFifoBuffer fifo; /* for compression: one audio fifo per codec */
274 typedef struct AVInputStream {
278 int discard; /* true if stream data should be discarded */
279 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
280 int64_t sample_index; /* current sample */
282 int64_t start; /* time when read started */
283 int64_t next_pts; /* synthetic pts for cases where pkt.pts
285 int64_t pts; /* current pts */
286 int is_start; /* is 1 at the start and after a discontinuity */
289 typedef struct AVInputFile {
290 int eof_reached; /* true if eof reached */
291 int ist_index; /* index of first stream in ist_table */
292 int buffer_size; /* current total buffer size */
293 int nb_streams; /* nb streams we are aware of */
296 #ifdef HAVE_TERMIOS_H
298 /* init terminal so that we can grab keys */
299 static struct termios oldtty;
302 static void term_exit(void)
304 #ifdef HAVE_TERMIOS_H
305 tcsetattr (0, TCSANOW, &oldtty);
309 static volatile sig_atomic_t received_sigterm = 0;
312 sigterm_handler(int sig)
314 received_sigterm = sig;
318 static void term_init(void)
320 #ifdef HAVE_TERMIOS_H
326 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
327 |INLCR|IGNCR|ICRNL|IXON);
328 tty.c_oflag |= OPOST;
329 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
330 tty.c_cflag &= ~(CSIZE|PARENB);
335 tcsetattr (0, TCSANOW, &tty);
336 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
339 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
340 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
342 register a function to be called at normal program termination
345 #ifdef CONFIG_BEOS_NETSERVER
346 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
350 /* read a key without blocking */
351 static int read_key(void)
353 #if defined(HAVE_TERMIOS_H)
356 #ifndef CONFIG_BEOS_NETSERVER
364 n = select(1, &rfds, NULL, NULL, &tv);
373 #elif defined(HAVE_CONIO_H)
380 static int decode_interrupt_cb(void)
382 return q_pressed || (q_pressed = read_key() == 'q');
385 static int av_exit(int ret)
390 for(i=0;i<nb_output_files;i++) {
391 /* maybe av_close_output_file ??? */
392 AVFormatContext *s = output_files[i];
394 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
396 for(j=0;j<s->nb_streams;j++) {
397 av_free(s->streams[j]->codec);
398 av_free(s->streams[j]);
402 for(i=0;i<nb_input_files;i++)
403 av_close_input_file(input_files[i]);
405 av_free(intra_matrix);
406 av_free(inter_matrix);
410 av_free(vstats_filename);
414 av_free(video_codec_name);
415 av_free(audio_codec_name);
416 av_free(subtitle_codec_name);
418 av_free(video_standard);
420 #ifdef CONFIG_POWERPC_PERF
421 extern void powerpc_display_perf_report(void);
422 powerpc_display_perf_report();
423 #endif /* CONFIG_POWERPC_PERF */
425 if (received_sigterm) {
427 "Received signal %d: terminating.\n",
428 (int) received_sigterm);
432 exit(ret); /* not all OS-es handle main() return value */
436 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
442 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
445 /* copy stream format */
446 s->nb_streams = ic->nb_streams;
447 for(i=0;i<ic->nb_streams;i++) {
450 // FIXME: a more elegant solution is needed
451 st = av_mallocz(sizeof(AVStream));
452 memcpy(st, ic->streams[i], sizeof(AVStream));
453 st->codec = avcodec_alloc_context();
454 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
457 if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
459 else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
462 if(!st->codec->thread_count)
463 st->codec->thread_count = 1;
464 if(st->codec->thread_count>1)
465 avcodec_thread_init(st->codec, st->codec->thread_count);
467 if(st->codec->flags & CODEC_FLAG_BITEXACT)
472 s->timestamp = av_gettime();
474 av_close_input_file(ic);
479 get_sync_ipts(const AVOutputStream *ost)
481 const AVInputStream *ist = ost->sync_ist;
482 return (double)(ist->pts - start_time)/AV_TIME_BASE;
485 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
489 AVPacket new_pkt= *pkt;
490 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
491 &new_pkt.data, &new_pkt.size,
492 pkt->data, pkt->size,
493 pkt->flags & PKT_FLAG_KEY);
496 new_pkt.destruct= av_destruct_packet;
498 fprintf(stderr, "%s failed for stream %d, codec %s",
499 bsfc->filter->name, pkt->stream_index,
500 avctx->codec ? avctx->codec->name : "copy");
510 ret= av_interleaved_write_frame(s, pkt);
512 print_error("av_interleaved_write_frame()", ret);
517 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
519 static void do_audio_out(AVFormatContext *s,
522 unsigned char *buf, int size)
525 static uint8_t *audio_buf = NULL;
526 static uint8_t *audio_out = NULL;
527 static uint8_t *audio_out2 = NULL;
528 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
530 int size_out, frame_bytes, ret;
531 AVCodecContext *enc= ost->st->codec;
532 AVCodecContext *dec= ist->st->codec;
533 int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
534 int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
536 /* SC: dynamic allocation of buffers */
538 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
540 audio_out = av_malloc(audio_out_size);
541 if (!audio_buf || !audio_out)
542 return; /* Should signal an error ! */
544 if (enc->channels != dec->channels)
545 ost->audio_resample = 1;
547 if (ost->audio_resample && !ost->resample) {
548 if (dec->sample_fmt != SAMPLE_FMT_S16) {
549 fprintf(stderr, "Audio resampler only works with 16 bits per sample, patch welcome.\n");
552 ost->resample = audio_resample_init(enc->channels, dec->channels,
553 enc->sample_rate, dec->sample_rate);
554 if (!ost->resample) {
555 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
556 dec->channels, dec->sample_rate,
557 enc->channels, enc->sample_rate);
562 #define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
563 if (dec->sample_fmt!=enc->sample_fmt &&
564 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
566 audio_out2 = av_malloc(audio_out_size);
569 if (ost->reformat_ctx)
570 av_audio_convert_free(ost->reformat_ctx);
571 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
572 dec->sample_fmt, 1, NULL, 0);
573 if (!ost->reformat_ctx) {
574 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
575 avcodec_get_sample_fmt_name(dec->sample_fmt),
576 avcodec_get_sample_fmt_name(enc->sample_fmt));
579 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
582 if(audio_sync_method){
583 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
584 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
585 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
586 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
588 //FIXME resample delay
589 if(fabs(delta) > 50){
590 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
592 byte_delta= FFMAX(byte_delta, -size);
596 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
601 static uint8_t *input_tmp= NULL;
602 input_tmp= av_realloc(input_tmp, byte_delta + size);
604 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
607 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
609 memset(input_tmp, 0, byte_delta);
610 memcpy(input_tmp + byte_delta, buf, size);
614 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
616 }else if(audio_sync_method>1){
617 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
618 assert(ost->audio_resample);
620 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
621 // fprintf(stderr, "drift:%f len:%d opts:%"PRId64" ipts:%"PRId64" fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2));
622 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
626 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
627 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
629 if (ost->audio_resample) {
631 size_out = audio_resample(ost->resample,
632 (short *)buftmp, (short *)buf,
633 size / (ist->st->codec->channels * isize));
634 size_out = size_out * enc->channels * osize;
640 if (dec->sample_fmt!=enc->sample_fmt) {
641 const void *ibuf[6]= {buftmp};
642 void *obuf[6]= {audio_out2};
643 int istride[6]= {isize};
644 int ostride[6]= {osize};
645 int len= size_out/istride[0];
646 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
647 printf("av_audio_convert() failed\n");
653 size_out = len*osize;
656 /* now encode as many frames as possible */
657 if (enc->frame_size > 1) {
658 /* output resampled raw samples */
659 if (av_fifo_realloc2(&ost->fifo, av_fifo_size(&ost->fifo) + size_out) < 0) {
660 fprintf(stderr, "av_fifo_realloc2() failed\n");
663 av_fifo_generic_write(&ost->fifo, buftmp, size_out, NULL);
665 frame_bytes = enc->frame_size * osize * enc->channels;
667 while (av_fifo_size(&ost->fifo) >= frame_bytes) {
669 av_init_packet(&pkt);
671 av_fifo_read(&ost->fifo, audio_buf, frame_bytes);
673 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
675 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
678 pkt.stream_index= ost->index;
681 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
682 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
683 pkt.flags |= PKT_FLAG_KEY;
684 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
686 ost->sync_opts += enc->frame_size;
690 int coded_bps = av_get_bits_per_sample(enc->codec->id)/8;
691 av_init_packet(&pkt);
693 ost->sync_opts += size_out / (osize * enc->channels);
695 /* output a pcm frame */
696 /* determine the size of the coded buffer */
699 size_out *= coded_bps;
701 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
702 ret = avcodec_encode_audio(enc, audio_out, size_out,
705 pkt.stream_index= ost->index;
708 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
709 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
710 pkt.flags |= PKT_FLAG_KEY;
711 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
715 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
719 AVPicture picture_tmp;
722 dec = ist->st->codec;
724 /* deinterlace : must be done before any resize */
725 if (do_deinterlace || using_vhook) {
728 /* create temporary picture */
729 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
730 buf = av_malloc(size);
734 picture2 = &picture_tmp;
735 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
738 if(avpicture_deinterlace(picture2, picture,
739 dec->pix_fmt, dec->width, dec->height) < 0) {
740 /* if error, do not deinterlace */
741 fprintf(stderr, "Deinterlacing failed\n");
747 av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
754 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,
755 1000000 * ist->pts / AV_TIME_BASE);
757 if (picture != picture2)
758 *picture = *picture2;
762 /* we begin to correct av delay at this threshold */
763 #define AV_DELAY_MAX 0.100
765 static void do_subtitle_out(AVFormatContext *s,
771 static uint8_t *subtitle_out = NULL;
772 int subtitle_out_max_size = 65536;
773 int subtitle_out_size, nb, i;
777 if (pts == AV_NOPTS_VALUE) {
778 fprintf(stderr, "Subtitle packets must have a pts\n");
784 enc = ost->st->codec;
787 subtitle_out = av_malloc(subtitle_out_max_size);
790 /* Note: DVB subtitle need one packet to draw them and one other
791 packet to clear them */
792 /* XXX: signal it in the codec context ? */
793 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
798 for(i = 0; i < nb; i++) {
799 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
800 subtitle_out_max_size, sub);
802 av_init_packet(&pkt);
803 pkt.stream_index = ost->index;
804 pkt.data = subtitle_out;
805 pkt.size = subtitle_out_size;
806 pkt.pts = av_rescale_q(pts, ist->st->time_base, ost->st->time_base);
807 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
808 /* XXX: the pts correction is handled here. Maybe handling
809 it in the codec would be better */
811 pkt.pts += 90 * sub->start_display_time;
813 pkt.pts += 90 * sub->end_display_time;
815 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
819 static int bit_buffer_size= 1024*256;
820 static uint8_t *bit_buffer= NULL;
822 static void do_video_out(AVFormatContext *s,
828 int nb_frames, i, ret;
829 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
830 AVFrame picture_crop_temp, picture_pad_temp;
831 AVCodecContext *enc, *dec;
833 avcodec_get_frame_defaults(&picture_crop_temp);
834 avcodec_get_frame_defaults(&picture_pad_temp);
836 enc = ost->st->codec;
837 dec = ist->st->codec;
839 /* by default, we output a single frame */
844 if(video_sync_method>0 || (video_sync_method && av_q2d(enc->time_base) > 0.001)){
846 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
847 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
850 else if (video_sync_method == 2)
851 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
852 else if (vdelta > 1.1)
853 nb_frames = lrintf(vdelta);
854 //fprintf(stderr, "vdelta:%f, ost->sync_opts:%"PRId64", ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, ost->sync_ipts, nb_frames);
858 fprintf(stderr, "*** drop!\n");
859 }else if (nb_frames > 1) {
860 nb_frames_dup += nb_frames;
862 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
865 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
867 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
871 if (ost->video_crop) {
872 if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
873 av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
878 formatted_picture = &picture_crop_temp;
880 formatted_picture = in_picture;
883 final_picture = formatted_picture;
884 padding_src = formatted_picture;
885 resampling_dst = &ost->pict_tmp;
886 if (ost->video_pad) {
887 final_picture = &ost->pict_tmp;
888 if (ost->video_resample) {
889 if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
890 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
895 resampling_dst = &picture_pad_temp;
899 if (ost->video_resample) {
901 final_picture = &ost->pict_tmp;
902 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
903 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
906 if (ost->video_pad) {
907 av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
908 enc->height, enc->width, enc->pix_fmt,
909 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
912 /* duplicates frame if needed */
913 for(i=0;i<nb_frames;i++) {
915 av_init_packet(&pkt);
916 pkt.stream_index= ost->index;
918 if (s->oformat->flags & AVFMT_RAWPICTURE) {
919 /* raw pictures are written as AVPicture structure to
920 avoid any copies. We support temorarily the older
922 AVFrame* old_frame = enc->coded_frame;
923 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
924 pkt.data= (uint8_t *)final_picture;
925 pkt.size= sizeof(AVPicture);
926 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
927 pkt.flags |= PKT_FLAG_KEY;
929 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
930 enc->coded_frame = old_frame;
934 big_picture= *final_picture;
935 /* better than nothing: use input picture interlaced
937 big_picture.interlaced_frame = in_picture->interlaced_frame;
938 if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
939 if(top_field_first == -1)
940 big_picture.top_field_first = in_picture->top_field_first;
942 big_picture.top_field_first = top_field_first;
945 /* handles sameq here. This is not correct because it may
946 not be a global option */
948 big_picture.quality = ist->st->quality;
950 big_picture.quality = ost->st->quality;
952 big_picture.pict_type = 0;
953 // big_picture.pts = AV_NOPTS_VALUE;
954 big_picture.pts= ost->sync_opts;
955 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
956 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
957 ret = avcodec_encode_video(enc,
958 bit_buffer, bit_buffer_size,
961 fprintf(stderr, "Video encoding failed\n");
964 //enc->frame_number = enc->real_pict_num;
966 pkt.data= bit_buffer;
968 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
969 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
970 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
971 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
972 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
974 if(enc->coded_frame->key_frame)
975 pkt.flags |= PKT_FLAG_KEY;
976 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
979 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
980 // enc->frame_number-1, enc->real_pict_num, ret,
982 /* if two pass, output log */
983 if (ost->logfile && enc->stats_out) {
984 fprintf(ost->logfile, "%s", enc->stats_out);
993 static double psnr(double d){
994 return -10.0*log(d)/log(10.0);
997 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1000 AVCodecContext *enc;
1002 double ti1, bitrate, avg_bitrate;
1004 /* this is executed just the first time do_video_stats is called */
1006 vstats_file = fopen(vstats_filename, "w");
1013 enc = ost->st->codec;
1014 if (enc->codec_type == CODEC_TYPE_VIDEO) {
1015 frame_number = ost->frame_number;
1016 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1017 if (enc->flags&CODEC_FLAG_PSNR)
1018 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1020 fprintf(vstats_file,"f_size= %6d ", frame_size);
1021 /* compute pts value */
1022 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1026 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1027 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1028 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1029 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1030 fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1034 static void print_report(AVFormatContext **output_files,
1035 AVOutputStream **ost_table, int nb_ostreams,
1039 AVOutputStream *ost;
1040 AVFormatContext *oc, *os;
1042 AVCodecContext *enc;
1043 int frame_number, vid, i;
1044 double bitrate, ti1, pts;
1045 static int64_t last_time = -1;
1046 static int qp_histogram[52];
1048 if (!is_last_report) {
1050 /* display the report every 0.5 seconds */
1051 cur_time = av_gettime();
1052 if (last_time == -1) {
1053 last_time = cur_time;
1056 if ((cur_time - last_time) < 500000)
1058 last_time = cur_time;
1062 oc = output_files[0];
1064 total_size = url_fsize(oc->pb);
1065 if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1066 total_size= url_ftell(oc->pb);
1071 for(i=0;i<nb_ostreams;i++) {
1073 os = output_files[ost->file_index];
1074 enc = ost->st->codec;
1075 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1076 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1077 !ost->st->stream_copy ?
1078 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1080 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1081 float t = (av_gettime()-timer_start) / 1000000.0;
1083 frame_number = ost->frame_number;
1084 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1085 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1086 !ost->st->stream_copy ?
1087 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1089 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1092 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1093 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1096 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1098 if (enc->flags&CODEC_FLAG_PSNR){
1100 double error, error_sum=0;
1101 double scale, scale_sum=0;
1102 char type[3]= {'Y','U','V'};
1103 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1106 error= enc->error[j];
1107 scale= enc->width*enc->height*255.0*255.0*frame_number;
1109 error= enc->coded_frame->error[j];
1110 scale= enc->width*enc->height*255.0*255.0;
1115 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1117 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1121 /* compute min output value */
1122 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1123 if ((pts < ti1) && (pts > 0))
1129 if (verbose || is_last_report) {
1130 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1132 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1133 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1134 (double)total_size / 1024, ti1, bitrate);
1137 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1138 nb_frames_dup, nb_frames_drop);
1141 fprintf(stderr, "%s \r", buf);
1146 if (is_last_report && verbose >= 0){
1147 int64_t raw= audio_size + video_size + extra_size;
1148 fprintf(stderr, "\n");
1149 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1153 100.0*(total_size - raw)/raw
1158 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1159 static int output_packet(AVInputStream *ist, int ist_index,
1160 AVOutputStream **ost_table, int nb_ostreams,
1161 const AVPacket *pkt)
1163 AVFormatContext *os;
1164 AVOutputStream *ost;
1168 int data_size, got_picture;
1170 void *buffer_to_free;
1171 static unsigned int samples_size= 0;
1172 static short *samples= NULL;
1173 AVSubtitle subtitle, *subtitle_to_free;
1176 if(ist->next_pts == AV_NOPTS_VALUE)
1177 ist->next_pts= ist->pts;
1186 if(pkt->dts != AV_NOPTS_VALUE)
1187 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1192 //while we have more to decode or while the decoder did output something on EOF
1193 while (len > 0 || (!pkt && ist->next_pts != ist->pts)) {
1195 ist->pts= ist->next_pts;
1197 if(len && len != pkt->size && verbose>0)
1198 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1200 /* decode the packet if needed */
1201 data_buf = NULL; /* fail safe */
1203 subtitle_to_free = NULL;
1204 if (ist->decoding_needed) {
1205 switch(ist->st->codec->codec_type) {
1206 case CODEC_TYPE_AUDIO:{
1207 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1208 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1210 samples= av_malloc(samples_size);
1212 data_size= samples_size;
1213 /* XXX: could avoid copy if PCM 16 bits with same
1214 endianness as CPU */
1215 ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1221 /* Some bug in mpeg audio decoder gives */
1222 /* data_size < 0, it seems they are overflows */
1223 if (data_size <= 0) {
1224 /* no audio frame */
1227 data_buf = (uint8_t *)samples;
1228 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1229 (ist->st->codec->sample_rate * ist->st->codec->channels);
1231 case CODEC_TYPE_VIDEO:
1232 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1233 /* XXX: allocate picture correctly */
1234 avcodec_get_frame_defaults(&picture);
1236 ret = avcodec_decode_video(ist->st->codec,
1237 &picture, &got_picture, ptr, len);
1238 ist->st->quality= picture.quality;
1242 /* no picture yet */
1243 goto discard_packet;
1245 if (ist->st->codec->time_base.num != 0) {
1246 ist->next_pts += ((int64_t)AV_TIME_BASE *
1247 ist->st->codec->time_base.num) /
1248 ist->st->codec->time_base.den;
1252 case CODEC_TYPE_SUBTITLE:
1253 ret = avcodec_decode_subtitle(ist->st->codec,
1254 &subtitle, &got_subtitle, ptr, len);
1257 if (!got_subtitle) {
1258 goto discard_packet;
1260 subtitle_to_free = &subtitle;
1267 switch(ist->st->codec->codec_type) {
1268 case CODEC_TYPE_AUDIO:
1269 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1270 ist->st->codec->sample_rate;
1272 case CODEC_TYPE_VIDEO:
1273 if (ist->st->codec->time_base.num != 0) {
1274 ist->next_pts += ((int64_t)AV_TIME_BASE *
1275 ist->st->codec->time_base.num) /
1276 ist->st->codec->time_base.den;
1286 buffer_to_free = NULL;
1287 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1288 pre_process_video_frame(ist, (AVPicture *)&picture,
1292 // preprocess audio (volume)
1293 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1294 if (audio_volume != 256) {
1297 for(i=0;i<(data_size / sizeof(short));i++) {
1298 int v = ((*volp) * audio_volume + 128) >> 8;
1299 if (v < -32768) v = -32768;
1300 if (v > 32767) v = 32767;
1306 /* frame rate emulation */
1307 if (ist->st->codec->rate_emu) {
1308 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1309 int64_t now = av_gettime() - ist->start;
1314 /* if output time reached then transcode raw format,
1315 encode packets and output them */
1316 if (start_time == 0 || ist->pts >= start_time)
1317 for(i=0;i<nb_ostreams;i++) {
1321 if (ost->source_index == ist_index) {
1322 os = output_files[ost->file_index];
1325 printf("%d: got pts=%0.3f %0.3f\n", i,
1326 (double)pkt->pts / AV_TIME_BASE,
1327 ((double)ist->pts / AV_TIME_BASE) -
1328 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1330 /* set the input output pts pairs */
1331 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1333 if (ost->encoding_needed) {
1334 switch(ost->st->codec->codec_type) {
1335 case CODEC_TYPE_AUDIO:
1336 do_audio_out(os, ost, ist, data_buf, data_size);
1338 case CODEC_TYPE_VIDEO:
1339 do_video_out(os, ost, ist, &picture, &frame_size);
1340 if (vstats_filename && frame_size)
1341 do_video_stats(os, ost, frame_size);
1343 case CODEC_TYPE_SUBTITLE:
1344 do_subtitle_out(os, ost, ist, &subtitle,
1351 AVFrame avframe; //FIXME/XXX remove this
1353 av_init_packet(&opkt);
1355 if (!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY))
1358 /* no reencoding needed : output the packet directly */
1359 /* force the input stream PTS */
1361 avcodec_get_frame_defaults(&avframe);
1362 ost->st->codec->coded_frame= &avframe;
1363 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1365 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1366 audio_size += data_size;
1367 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1368 video_size += data_size;
1372 opkt.stream_index= ost->index;
1373 if(pkt->pts != AV_NOPTS_VALUE)
1374 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1376 opkt.pts= AV_NOPTS_VALUE;
1378 if (pkt->dts == AV_NOPTS_VALUE)
1379 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1381 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1383 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1384 opkt.flags= pkt->flags;
1386 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1387 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1388 opkt.destruct= av_destruct_packet;
1390 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1391 ost->st->codec->frame_number++;
1392 ost->frame_number++;
1393 av_free_packet(&opkt);
1397 av_free(buffer_to_free);
1398 /* XXX: allocate the subtitles in the codec ? */
1399 if (subtitle_to_free) {
1400 if (subtitle_to_free->rects != NULL) {
1401 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1402 av_free(subtitle_to_free->rects[i].bitmap);
1403 av_free(subtitle_to_free->rects[i].rgba_palette);
1405 av_freep(&subtitle_to_free->rects);
1407 subtitle_to_free->num_rects = 0;
1408 subtitle_to_free = NULL;
1415 for(i=0;i<nb_ostreams;i++) {
1417 if (ost->source_index == ist_index) {
1418 AVCodecContext *enc= ost->st->codec;
1419 os = output_files[ost->file_index];
1421 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1423 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1426 if (ost->encoding_needed) {
1430 av_init_packet(&pkt);
1431 pkt.stream_index= ost->index;
1433 switch(ost->st->codec->codec_type) {
1434 case CODEC_TYPE_AUDIO:
1435 fifo_bytes = av_fifo_size(&ost->fifo);
1437 /* encode any samples remaining in fifo */
1438 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1439 int fs_tmp = enc->frame_size;
1440 enc->frame_size = fifo_bytes / (2 * enc->channels);
1441 av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes);
1442 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1443 enc->frame_size = fs_tmp;
1446 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1449 pkt.flags |= PKT_FLAG_KEY;
1451 case CODEC_TYPE_VIDEO:
1452 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1454 if(enc->coded_frame && enc->coded_frame->key_frame)
1455 pkt.flags |= PKT_FLAG_KEY;
1456 if (ost->logfile && enc->stats_out) {
1457 fprintf(ost->logfile, "%s", enc->stats_out);
1466 pkt.data= bit_buffer;
1468 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1469 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1470 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1482 static void print_sdp(AVFormatContext **avc, int n)
1486 avf_sdp_create(avc, n, sdp, sizeof(sdp));
1487 printf("SDP:\n%s\n", sdp);
1491 static int stream_index_from_inputs(AVFormatContext **input_files,
1493 AVInputFile *file_table,
1494 AVInputStream **ist_table,
1495 enum CodecType type,
1499 for(z=0; z<nb_input_files; z++) {
1500 AVFormatContext *ic = input_files[z];
1501 for(p=0; p<ic->nb_programs; p++) {
1502 AVProgram *program = ic->programs[p];
1503 if(program->id != programid)
1505 for(q=0; q<program->nb_stream_indexes; q++) {
1506 int sidx = program->stream_index[q];
1507 int ris = file_table[z].ist_index + sidx;
1508 if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1518 * The following code is the main loop of the file converter
1520 static int av_encode(AVFormatContext **output_files,
1521 int nb_output_files,
1522 AVFormatContext **input_files,
1524 AVStreamMap *stream_maps, int nb_stream_maps)
1526 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1527 AVFormatContext *is, *os;
1528 AVCodecContext *codec, *icodec;
1529 AVOutputStream *ost, **ost_table = NULL;
1530 AVInputStream *ist, **ist_table = NULL;
1531 AVInputFile *file_table;
1535 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1539 /* input stream init */
1541 for(i=0;i<nb_input_files;i++) {
1542 is = input_files[i];
1543 file_table[i].ist_index = j;
1544 file_table[i].nb_streams = is->nb_streams;
1545 j += is->nb_streams;
1549 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1553 for(i=0;i<nb_istreams;i++) {
1554 ist = av_mallocz(sizeof(AVInputStream));
1560 for(i=0;i<nb_input_files;i++) {
1561 is = input_files[i];
1562 for(k=0;k<is->nb_streams;k++) {
1563 ist = ist_table[j++];
1564 ist->st = is->streams[k];
1565 ist->file_index = i;
1567 ist->discard = 1; /* the stream is discarded by default
1570 if (ist->st->codec->rate_emu) {
1571 ist->start = av_gettime();
1576 /* output stream init */
1578 for(i=0;i<nb_output_files;i++) {
1579 os = output_files[i];
1580 if (!os->nb_streams) {
1581 dump_format(output_files[i], i, output_files[i]->filename, 1);
1582 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1585 nb_ostreams += os->nb_streams;
1587 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1588 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1592 /* Sanity check the mapping args -- do the input files & streams exist? */
1593 for(i=0;i<nb_stream_maps;i++) {
1594 int fi = stream_maps[i].file_index;
1595 int si = stream_maps[i].stream_index;
1597 if (fi < 0 || fi > nb_input_files - 1 ||
1598 si < 0 || si > file_table[fi].nb_streams - 1) {
1599 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1602 fi = stream_maps[i].sync_file_index;
1603 si = stream_maps[i].sync_stream_index;
1604 if (fi < 0 || fi > nb_input_files - 1 ||
1605 si < 0 || si > file_table[fi].nb_streams - 1) {
1606 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1611 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1614 for(i=0;i<nb_ostreams;i++) {
1615 ost = av_mallocz(sizeof(AVOutputStream));
1622 for(k=0;k<nb_output_files;k++) {
1623 os = output_files[k];
1624 for(i=0;i<os->nb_streams;i++,n++) {
1627 ost->file_index = k;
1629 ost->st = os->streams[i];
1630 if (nb_stream_maps > 0) {
1631 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1632 stream_maps[n].stream_index;
1634 /* Sanity check that the stream types match */
1635 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1636 int i= ost->file_index;
1637 dump_format(output_files[i], i, output_files[i]->filename, 1);
1638 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1639 stream_maps[n].file_index, stream_maps[n].stream_index,
1640 ost->file_index, ost->index);
1647 j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1649 ost->source_index = j;
1653 /* get corresponding input stream index : we select the first one with the right type */
1655 for(j=0;j<nb_istreams;j++) {
1658 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1659 ost->source_index = j;
1667 if(! opt_programid) {
1668 /* try again and reuse existing stream */
1669 for(j=0;j<nb_istreams;j++) {
1671 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1672 ost->source_index = j;
1678 int i= ost->file_index;
1679 dump_format(output_files[i], i, output_files[i]->filename, 1);
1680 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1681 ost->file_index, ost->index);
1686 ist = ist_table[ost->source_index];
1688 ost->sync_ist = (nb_stream_maps > 0) ?
1689 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
1690 stream_maps[n].sync_stream_index] : ist;
1694 /* for each output stream, we compute the right encoding parameters */
1695 for(i=0;i<nb_ostreams;i++) {
1697 os = output_files[ost->file_index];
1698 ist = ist_table[ost->source_index];
1700 codec = ost->st->codec;
1701 icodec = ist->st->codec;
1703 if (!ost->st->language[0])
1704 av_strlcpy(ost->st->language, ist->st->language,
1705 sizeof(ost->st->language));
1707 ost->st->disposition = ist->st->disposition;
1709 if (ost->st->stream_copy) {
1710 /* if stream_copy is selected, no need to decode or encode */
1711 codec->codec_id = icodec->codec_id;
1712 codec->codec_type = icodec->codec_type;
1714 if(!codec->codec_tag){
1715 if( !os->oformat->codec_tag
1716 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1717 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1718 codec->codec_tag = icodec->codec_tag;
1721 codec->bit_rate = icodec->bit_rate;
1722 codec->extradata= icodec->extradata;
1723 codec->extradata_size= icodec->extradata_size;
1724 if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1725 codec->time_base = icodec->time_base;
1727 codec->time_base = ist->st->time_base;
1728 switch(codec->codec_type) {
1729 case CODEC_TYPE_AUDIO:
1730 if(audio_volume != 256) {
1731 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1734 codec->sample_rate = icodec->sample_rate;
1735 codec->channels = icodec->channels;
1736 codec->frame_size = icodec->frame_size;
1737 codec->block_align= icodec->block_align;
1738 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1739 codec->block_align= 0;
1740 if(codec->codec_id == CODEC_ID_AC3)
1741 codec->block_align= 0;
1743 case CODEC_TYPE_VIDEO:
1745 fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1748 codec->pix_fmt = icodec->pix_fmt;
1749 codec->width = icodec->width;
1750 codec->height = icodec->height;
1751 codec->has_b_frames = icodec->has_b_frames;
1753 case CODEC_TYPE_SUBTITLE:
1759 switch(codec->codec_type) {
1760 case CODEC_TYPE_AUDIO:
1761 if (av_fifo_init(&ost->fifo, 1024))
1763 ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
1764 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1765 icodec->request_channels = codec->channels;
1766 ist->decoding_needed = 1;
1767 ost->encoding_needed = 1;
1769 case CODEC_TYPE_VIDEO:
1770 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1771 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1772 ost->video_resample = ((codec->width != icodec->width -
1773 (frame_leftBand + frame_rightBand) +
1774 (frame_padleft + frame_padright)) ||
1775 (codec->height != icodec->height -
1776 (frame_topBand + frame_bottomBand) +
1777 (frame_padtop + frame_padbottom)) ||
1778 (codec->pix_fmt != icodec->pix_fmt));
1779 if (ost->video_crop) {
1780 ost->topBand = frame_topBand;
1781 ost->leftBand = frame_leftBand;
1783 if (ost->video_pad) {
1784 ost->padtop = frame_padtop;
1785 ost->padleft = frame_padleft;
1786 ost->padbottom = frame_padbottom;
1787 ost->padright = frame_padright;
1788 if (!ost->video_resample) {
1789 avcodec_get_frame_defaults(&ost->pict_tmp);
1790 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1791 codec->width, codec->height))
1795 if (ost->video_resample) {
1796 avcodec_get_frame_defaults(&ost->pict_tmp);
1797 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1798 codec->width, codec->height)) {
1799 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1802 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1803 ost->img_resample_ctx = sws_getContext(
1804 icodec->width - (frame_leftBand + frame_rightBand),
1805 icodec->height - (frame_topBand + frame_bottomBand),
1807 codec->width - (frame_padleft + frame_padright),
1808 codec->height - (frame_padtop + frame_padbottom),
1810 sws_flags, NULL, NULL, NULL);
1811 if (ost->img_resample_ctx == NULL) {
1812 fprintf(stderr, "Cannot get resampling context\n");
1815 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1817 ost->encoding_needed = 1;
1818 ist->decoding_needed = 1;
1820 case CODEC_TYPE_SUBTITLE:
1821 ost->encoding_needed = 1;
1822 ist->decoding_needed = 1;
1829 if (ost->encoding_needed &&
1830 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1831 char logfilename[1024];
1836 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1838 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1839 if (codec->flags & CODEC_FLAG_PASS1) {
1840 f = fopen(logfilename, "w");
1842 perror(logfilename);
1847 /* read the log file */
1848 f = fopen(logfilename, "r");
1850 perror(logfilename);
1853 fseek(f, 0, SEEK_END);
1855 fseek(f, 0, SEEK_SET);
1856 logbuffer = av_malloc(size + 1);
1858 fprintf(stderr, "Could not allocate log buffer\n");
1861 size = fread(logbuffer, 1, size, f);
1863 logbuffer[size] = '\0';
1864 codec->stats_in = logbuffer;
1868 if(codec->codec_type == CODEC_TYPE_VIDEO){
1869 int size= codec->width * codec->height;
1870 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1875 bit_buffer = av_malloc(bit_buffer_size);
1879 /* dump the file output parameters - cannot be done before in case
1881 for(i=0;i<nb_output_files;i++) {
1882 dump_format(output_files[i], i, output_files[i]->filename, 1);
1885 /* dump the stream mapping */
1887 fprintf(stderr, "Stream mapping:\n");
1888 for(i=0;i<nb_ostreams;i++) {
1890 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1891 ist_table[ost->source_index]->file_index,
1892 ist_table[ost->source_index]->index,
1895 if (ost->sync_ist != ist_table[ost->source_index])
1896 fprintf(stderr, " [sync #%d.%d]",
1897 ost->sync_ist->file_index,
1898 ost->sync_ist->index);
1899 fprintf(stderr, "\n");
1903 /* open each encoder */
1904 for(i=0;i<nb_ostreams;i++) {
1906 if (ost->encoding_needed) {
1907 AVCodec *codec = output_codecs[i];
1909 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1911 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1912 ost->file_index, ost->index);
1915 if (avcodec_open(ost->st->codec, codec) < 0) {
1916 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1917 ost->file_index, ost->index);
1920 extra_size += ost->st->codec->extradata_size;
1924 /* open each decoder */
1925 for(i=0;i<nb_istreams;i++) {
1927 if (ist->decoding_needed) {
1928 AVCodec *codec = input_codecs[i];
1930 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1932 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1933 ist->st->codec->codec_id, ist->file_index, ist->index);
1936 if (avcodec_open(ist->st->codec, codec) < 0) {
1937 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1938 ist->file_index, ist->index);
1941 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1942 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1947 for(i=0;i<nb_istreams;i++) {
1949 is = input_files[ist->file_index];
1951 ist->next_pts = AV_NOPTS_VALUE;
1955 /* set meta data information from input file if required */
1956 for (i=0;i<nb_meta_data_maps;i++) {
1957 AVFormatContext *out_file;
1958 AVFormatContext *in_file;
1960 int out_file_index = meta_data_maps[i].out_file;
1961 int in_file_index = meta_data_maps[i].in_file;
1962 if (out_file_index < 0 || out_file_index >= nb_output_files) {
1963 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1964 ret = AVERROR(EINVAL);
1967 if (in_file_index < 0 || in_file_index >= nb_input_files) {
1968 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1969 ret = AVERROR(EINVAL);
1973 out_file = output_files[out_file_index];
1974 in_file = input_files[in_file_index];
1976 strcpy(out_file->title, in_file->title);
1977 strcpy(out_file->author, in_file->author);
1978 strcpy(out_file->copyright, in_file->copyright);
1979 strcpy(out_file->comment, in_file->comment);
1980 strcpy(out_file->album, in_file->album);
1981 out_file->year = in_file->year;
1982 out_file->track = in_file->track;
1983 strcpy(out_file->genre, in_file->genre);
1986 /* open files and write file headers */
1987 for(i=0;i<nb_output_files;i++) {
1988 os = output_files[i];
1989 if (av_write_header(os) < 0) {
1990 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1991 ret = AVERROR(EINVAL);
1994 if (strcmp(output_files[i]->oformat->name, "rtp")) {
1999 print_sdp(output_files, nb_output_files);
2002 if (!using_stdin && verbose >= 0) {
2003 fprintf(stderr, "Press [q] to stop encoding\n");
2004 url_set_interrupt_cb(decode_interrupt_cb);
2009 timer_start = av_gettime();
2011 for(; received_sigterm == 0;) {
2012 int file_index, ist_index;
2020 /* if 'q' pressed, exits */
2024 /* read_key() returns 0 on EOF */
2030 /* select the stream that we must read now by looking at the
2031 smallest output pts */
2033 for(i=0;i<nb_ostreams;i++) {
2036 os = output_files[ost->file_index];
2037 ist = ist_table[ost->source_index];
2038 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2039 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2041 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2042 ipts = (double)ist->pts;
2043 if (!file_table[ist->file_index].eof_reached){
2044 if(ipts < ipts_min) {
2046 if(input_sync ) file_index = ist->file_index;
2048 if(opts < opts_min) {
2050 if(!input_sync) file_index = ist->file_index;
2053 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2058 /* if none, if is finished */
2059 if (file_index < 0) {
2063 /* finish if recording time exhausted */
2064 if (opts_min >= (recording_time / 1000000.0))
2067 /* finish if limit size exhausted */
2068 if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2071 /* read a frame from it and output it in the fifo */
2072 is = input_files[file_index];
2073 if (av_read_frame(is, &pkt) < 0) {
2074 file_table[file_index].eof_reached = 1;
2082 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2084 /* the following test is needed in case new streams appear
2085 dynamically in stream : we ignore them */
2086 if (pkt.stream_index >= file_table[file_index].nb_streams)
2087 goto discard_packet;
2088 ist_index = file_table[file_index].ist_index + pkt.stream_index;
2089 ist = ist_table[ist_index];
2091 goto discard_packet;
2093 if (pkt.dts != AV_NOPTS_VALUE)
2094 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2095 if (pkt.pts != AV_NOPTS_VALUE)
2096 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2098 if(input_files_ts_scale[file_index][pkt.stream_index]){
2099 if(pkt.pts != AV_NOPTS_VALUE)
2100 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2101 if(pkt.dts != AV_NOPTS_VALUE)
2102 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2105 // fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec->codec_type);
2106 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2107 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2108 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2109 int64_t delta= pkt_dts - ist->next_pts;
2110 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2111 input_files_ts_offset[ist->file_index]-= delta;
2113 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2114 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2115 if(pkt.pts != AV_NOPTS_VALUE)
2116 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2120 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2121 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2124 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2125 ist->file_index, ist->index);
2128 av_free_packet(&pkt);
2133 av_free_packet(&pkt);
2135 /* dump report by using the output first video and audio streams */
2136 print_report(output_files, ost_table, nb_ostreams, 0);
2139 /* at the end of stream, we must flush the decoder buffers */
2140 for(i=0;i<nb_istreams;i++) {
2142 if (ist->decoding_needed) {
2143 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2149 /* write the trailer if needed and close file */
2150 for(i=0;i<nb_output_files;i++) {
2151 os = output_files[i];
2152 av_write_trailer(os);
2155 /* dump report by using the first video and audio streams */
2156 print_report(output_files, ost_table, nb_ostreams, 1);
2158 /* close each encoder */
2159 for(i=0;i<nb_ostreams;i++) {
2161 if (ost->encoding_needed) {
2162 av_freep(&ost->st->codec->stats_in);
2163 avcodec_close(ost->st->codec);
2167 /* close each decoder */
2168 for(i=0;i<nb_istreams;i++) {
2170 if (ist->decoding_needed) {
2171 avcodec_close(ist->st->codec);
2179 av_freep(&bit_buffer);
2180 av_free(file_table);
2183 for(i=0;i<nb_istreams;i++) {
2190 for(i=0;i<nb_ostreams;i++) {
2194 fclose(ost->logfile);
2195 ost->logfile = NULL;
2197 av_fifo_free(&ost->fifo); /* works even if fifo is not
2198 initialized but set to zero */
2199 av_free(ost->pict_tmp.data[0]);
2200 if (ost->video_resample)
2201 sws_freeContext(ost->img_resample_ctx);
2203 audio_resample_close(ost->resample);
2204 if (ost->reformat_ctx)
2205 av_audio_convert_free(ost->reformat_ctx);
2213 ret = AVERROR(ENOMEM);
2218 int file_read(const char *filename)
2221 unsigned char buffer[1024];
2224 if (url_open(&h, filename, O_RDONLY) < 0) {
2225 printf("could not open '%s'\n", filename);
2229 len = url_read(h, buffer, sizeof(buffer));
2232 for(i=0;i<len;i++) putchar(buffer[i]);
2239 static void opt_format(const char *arg)
2241 /* compatibility stuff for pgmyuv */
2242 if (!strcmp(arg, "pgmyuv")) {
2243 pgmyuv_compatibility_hack=1;
2244 // opt_image_format(arg);
2246 fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2249 file_iformat = av_find_input_format(arg);
2250 file_oformat = guess_format(arg, NULL, NULL);
2251 if (!file_iformat && !file_oformat) {
2252 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2257 static void opt_video_rc_override_string(const char *arg)
2259 video_rc_override_string = arg;
2262 static int opt_me_threshold(const char *opt, const char *arg)
2264 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2268 static int opt_verbose(const char *opt, const char *arg)
2270 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2271 av_log_set_level(verbose);
2275 static int opt_frame_rate(const char *opt, const char *arg)
2277 if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2278 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2284 static int opt_bitrate(const char *opt, const char *arg)
2286 int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2288 opt_default(opt, arg);
2290 if (av_get_int(avctx_opts[codec_type], "b", NULL) < 1000)
2291 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2296 static void opt_frame_crop_top(const char *arg)
2298 frame_topBand = atoi(arg);
2299 if (frame_topBand < 0) {
2300 fprintf(stderr, "Incorrect top crop size\n");
2303 if ((frame_topBand % 2) != 0) {
2304 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2307 if ((frame_topBand) >= frame_height){
2308 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2311 frame_height -= frame_topBand;
2314 static void opt_frame_crop_bottom(const char *arg)
2316 frame_bottomBand = atoi(arg);
2317 if (frame_bottomBand < 0) {
2318 fprintf(stderr, "Incorrect bottom crop size\n");
2321 if ((frame_bottomBand % 2) != 0) {
2322 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2325 if ((frame_bottomBand) >= frame_height){
2326 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2329 frame_height -= frame_bottomBand;
2332 static void opt_frame_crop_left(const char *arg)
2334 frame_leftBand = atoi(arg);
2335 if (frame_leftBand < 0) {
2336 fprintf(stderr, "Incorrect left crop size\n");
2339 if ((frame_leftBand % 2) != 0) {
2340 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2343 if ((frame_leftBand) >= frame_width){
2344 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2347 frame_width -= frame_leftBand;
2350 static void opt_frame_crop_right(const char *arg)
2352 frame_rightBand = atoi(arg);
2353 if (frame_rightBand < 0) {
2354 fprintf(stderr, "Incorrect right crop size\n");
2357 if ((frame_rightBand % 2) != 0) {
2358 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2361 if ((frame_rightBand) >= frame_width){
2362 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2365 frame_width -= frame_rightBand;
2368 static void opt_frame_size(const char *arg)
2370 if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2371 fprintf(stderr, "Incorrect frame size\n");
2374 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2375 fprintf(stderr, "Frame size must be a multiple of 2\n");
2381 #define SCALEBITS 10
2382 #define ONE_HALF (1 << (SCALEBITS - 1))
2383 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2385 #define RGB_TO_Y(r, g, b) \
2386 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2387 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2389 #define RGB_TO_U(r1, g1, b1, shift)\
2390 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2391 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2393 #define RGB_TO_V(r1, g1, b1, shift)\
2394 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2395 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2397 static void opt_pad_color(const char *arg) {
2398 /* Input is expected to be six hex digits similar to
2399 how colors are expressed in html tags (but without the #) */
2400 int rgb = strtol(arg, NULL, 16);
2404 g = ((rgb >> 8) & 255);
2407 padcolor[0] = RGB_TO_Y(r,g,b);
2408 padcolor[1] = RGB_TO_U(r,g,b,0);
2409 padcolor[2] = RGB_TO_V(r,g,b,0);
2412 static void opt_frame_pad_top(const char *arg)
2414 frame_padtop = atoi(arg);
2415 if (frame_padtop < 0) {
2416 fprintf(stderr, "Incorrect top pad size\n");
2419 if ((frame_padtop % 2) != 0) {
2420 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2425 static void opt_frame_pad_bottom(const char *arg)
2427 frame_padbottom = atoi(arg);
2428 if (frame_padbottom < 0) {
2429 fprintf(stderr, "Incorrect bottom pad size\n");
2432 if ((frame_padbottom % 2) != 0) {
2433 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2439 static void opt_frame_pad_left(const char *arg)
2441 frame_padleft = atoi(arg);
2442 if (frame_padleft < 0) {
2443 fprintf(stderr, "Incorrect left pad size\n");
2446 if ((frame_padleft % 2) != 0) {
2447 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2453 static void opt_frame_pad_right(const char *arg)
2455 frame_padright = atoi(arg);
2456 if (frame_padright < 0) {
2457 fprintf(stderr, "Incorrect right pad size\n");
2460 if ((frame_padright % 2) != 0) {
2461 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2466 static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2470 for (i=-1; i < nb_fmts; i++) {
2471 get_fmt_string (fmt_str, sizeof(fmt_str), i);
2472 fprintf(stdout, "%s\n", fmt_str);
2476 static void opt_frame_pix_fmt(const char *arg)
2478 if (strcmp(arg, "list"))
2479 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2481 list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2486 static void opt_frame_aspect_ratio(const char *arg)
2493 p = strchr(arg, ':');
2495 x = strtol(arg, &end, 10);
2497 y = strtol(end+1, &end, 10);
2499 ar = (double)x / (double)y;
2501 ar = strtod(arg, NULL);
2504 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2507 frame_aspect_ratio = ar;
2510 static void opt_qscale(const char *arg)
2512 video_qscale = atof(arg);
2513 if (video_qscale <= 0 ||
2514 video_qscale > 255) {
2515 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2520 static void opt_top_field_first(const char *arg)
2522 top_field_first= atoi(arg);
2525 static int opt_thread_count(const char *opt, const char *arg)
2527 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2528 #if !defined(HAVE_THREADS)
2530 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2535 static void opt_audio_sample_fmt(const char *arg)
2537 if (strcmp(arg, "list"))
2538 audio_sample_fmt = avcodec_get_sample_fmt(arg);
2540 list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2545 static int opt_audio_rate(const char *opt, const char *arg)
2547 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2551 static int opt_audio_channels(const char *opt, const char *arg)
2553 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2557 static void opt_video_channel(const char *arg)
2559 video_channel = strtol(arg, NULL, 0);
2562 static void opt_video_standard(const char *arg)
2564 video_standard = av_strdup(arg);
2567 static void opt_codec(int *pstream_copy, char **pcodec_name,
2568 int codec_type, const char *arg)
2570 av_freep(pcodec_name);
2571 if (!strcmp(arg, "copy")) {
2574 *pcodec_name = av_strdup(arg);
2578 static void opt_audio_codec(const char *arg)
2580 opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2583 static void opt_audio_tag(const char *arg)
2586 audio_codec_tag= strtol(arg, &tail, 0);
2589 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2592 static void opt_video_tag(const char *arg)
2595 video_codec_tag= strtol(arg, &tail, 0);
2598 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2602 static void add_frame_hooker(const char *arg)
2607 char *args = av_strdup(arg);
2611 argv[0] = strtok(args, " ");
2612 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2615 i = frame_hook_add(argc, argv);
2618 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2624 static void opt_video_codec(const char *arg)
2626 opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2629 static void opt_subtitle_codec(const char *arg)
2631 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2634 static void opt_map(const char *arg)
2639 m = &stream_maps[nb_stream_maps++];
2641 m->file_index = strtol(arg, &p, 0);
2645 m->stream_index = strtol(p, &p, 0);
2648 m->sync_file_index = strtol(p, &p, 0);
2651 m->sync_stream_index = strtol(p, &p, 0);
2653 m->sync_file_index = m->file_index;
2654 m->sync_stream_index = m->stream_index;
2658 static void opt_map_meta_data(const char *arg)
2663 m = &meta_data_maps[nb_meta_data_maps++];
2665 m->out_file = strtol(arg, &p, 0);
2669 m->in_file = strtol(p, &p, 0);
2672 static void opt_input_ts_scale(const char *arg)
2674 unsigned int stream;
2678 stream = strtol(arg, &p, 0);
2681 scale= strtod(p, &p);
2683 if(stream >= MAX_STREAMS)
2686 input_files_ts_scale[nb_input_files][stream]= scale;
2689 static int opt_recording_time(const char *opt, const char *arg)
2691 recording_time = parse_time_or_die(opt, arg, 1);
2695 static int opt_start_time(const char *opt, const char *arg)
2697 start_time = parse_time_or_die(opt, arg, 1);
2701 static int opt_rec_timestamp(const char *opt, const char *arg)
2703 rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2707 static int opt_input_ts_offset(const char *opt, const char *arg)
2709 input_ts_offset = parse_time_or_die(opt, arg, 1);
2713 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2715 const char *codec_string = encoder ? "encoder" : "decoder";
2719 return CODEC_ID_NONE;
2721 avcodec_find_encoder_by_name(name) :
2722 avcodec_find_decoder_by_name(name);
2724 av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2727 if(codec->type != type) {
2728 av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2734 static void opt_input_file(const char *filename)
2736 AVFormatContext *ic;
2737 AVFormatParameters params, *ap = ¶ms;
2738 int err, i, ret, rfps, rfps_base;
2741 if (!strcmp(filename, "-"))
2744 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2745 !strcmp(filename, "/dev/stdin");
2747 /* get default parameters from command line */
2748 ic = av_alloc_format_context();
2750 memset(ap, 0, sizeof(*ap));
2751 ap->prealloced_context = 1;
2752 ap->sample_rate = audio_sample_rate;
2753 ap->channels = audio_channels;
2754 ap->time_base.den = frame_rate.num;
2755 ap->time_base.num = frame_rate.den;
2756 ap->width = frame_width + frame_padleft + frame_padright;
2757 ap->height = frame_height + frame_padtop + frame_padbottom;
2758 ap->pix_fmt = frame_pix_fmt;
2759 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2760 ap->channel = video_channel;
2761 ap->standard = video_standard;
2762 ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2763 ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2764 if(pgmyuv_compatibility_hack)
2765 ap->video_codec_id= CODEC_ID_PGMYUV;
2767 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2769 ic->video_codec_id = find_codec_or_die(video_codec_name , CODEC_TYPE_VIDEO , 0);
2770 ic->audio_codec_id = find_codec_or_die(audio_codec_name , CODEC_TYPE_AUDIO , 0);
2771 ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2773 /* open the input file with generic libav function */
2774 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2776 print_error(filename, err);
2781 for(i=0; i<ic->nb_programs; i++)
2782 if(ic->programs[i]->id != opt_programid)
2783 ic->programs[i]->discard = AVDISCARD_ALL;
2786 ic->loop_input = loop_input;
2788 /* If not enough info to get the stream parameters, we decode the
2789 first frames to get it. (used in mpeg case for example) */
2790 ret = av_find_stream_info(ic);
2791 if (ret < 0 && verbose >= 0) {
2792 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2796 timestamp = start_time;
2797 /* add the stream start time */
2798 if (ic->start_time != AV_NOPTS_VALUE)
2799 timestamp += ic->start_time;
2801 /* if seeking requested, we execute it */
2802 if (start_time != 0) {
2803 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2805 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2806 filename, (double)timestamp / AV_TIME_BASE);
2808 /* reset seek info */
2812 /* update the current parameters so that they match the one of the input stream */
2813 for(i=0;i<ic->nb_streams;i++) {
2814 AVCodecContext *enc = ic->streams[i]->codec;
2816 avcodec_thread_init(enc, thread_count);
2817 enc->thread_count= thread_count;
2818 switch(enc->codec_type) {
2819 case CODEC_TYPE_AUDIO:
2820 set_context_opts(enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2821 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2822 audio_channels = enc->channels;
2823 audio_sample_rate = enc->sample_rate;
2824 audio_sample_fmt = enc->sample_fmt;
2825 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
2827 ic->streams[i]->discard= AVDISCARD_ALL;
2829 case CODEC_TYPE_VIDEO:
2830 set_context_opts(enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2831 frame_height = enc->height;
2832 frame_width = enc->width;
2833 if(ic->streams[i]->sample_aspect_ratio.num)
2834 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
2836 frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
2837 frame_aspect_ratio *= (float) enc->width / enc->height;
2838 frame_pix_fmt = enc->pix_fmt;
2839 rfps = ic->streams[i]->r_frame_rate.num;
2840 rfps_base = ic->streams[i]->r_frame_rate.den;
2841 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2843 enc->debug |= FF_DEBUG_MV;
2845 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2848 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2849 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2851 (float)rfps / rfps_base, rfps, rfps_base);
2853 /* update the current frame rate to match the stream frame rate */
2854 frame_rate.num = rfps;
2855 frame_rate.den = rfps_base;
2857 enc->rate_emu = rate_emu;
2858 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2860 ic->streams[i]->discard= AVDISCARD_ALL;
2861 else if(video_discard)
2862 ic->streams[i]->discard= video_discard;
2864 case CODEC_TYPE_DATA:
2866 case CODEC_TYPE_SUBTITLE:
2867 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
2868 if(subtitle_disable)
2869 ic->streams[i]->discard = AVDISCARD_ALL;
2871 case CODEC_TYPE_ATTACHMENT:
2872 case CODEC_TYPE_UNKNOWN:
2880 input_files[nb_input_files] = ic;
2881 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2882 /* dump the file content */
2884 dump_format(ic, nb_input_files, filename, 0);
2887 file_iformat = NULL;
2888 file_oformat = NULL;
2893 av_freep(&video_codec_name);
2894 av_freep(&audio_codec_name);
2895 av_freep(&subtitle_codec_name);
2898 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2899 int *has_subtitle_ptr)
2901 int has_video, has_audio, has_subtitle, i, j;
2902 AVFormatContext *ic;
2907 for(j=0;j<nb_input_files;j++) {
2908 ic = input_files[j];
2909 for(i=0;i<ic->nb_streams;i++) {
2910 AVCodecContext *enc = ic->streams[i]->codec;
2911 switch(enc->codec_type) {
2912 case CODEC_TYPE_AUDIO:
2915 case CODEC_TYPE_VIDEO:
2918 case CODEC_TYPE_SUBTITLE:
2921 case CODEC_TYPE_DATA:
2922 case CODEC_TYPE_ATTACHMENT:
2923 case CODEC_TYPE_UNKNOWN:
2930 *has_video_ptr = has_video;
2931 *has_audio_ptr = has_audio;
2932 *has_subtitle_ptr = has_subtitle;
2935 static void new_video_stream(AVFormatContext *oc)
2938 AVCodecContext *video_enc;
2941 st = av_new_stream(oc, oc->nb_streams);
2943 fprintf(stderr, "Could not alloc stream\n");
2946 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2947 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2948 video_bitstream_filters= NULL;
2951 avcodec_thread_init(st->codec, thread_count);
2953 video_enc = st->codec;
2956 video_enc->codec_tag= video_codec_tag;
2958 if( (video_global_header&1)
2959 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2960 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2961 avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2963 if(video_global_header&2){
2964 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2965 avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2968 if (video_stream_copy) {
2969 st->stream_copy = 1;
2970 video_enc->codec_type = CODEC_TYPE_VIDEO;
2971 video_enc->sample_aspect_ratio =
2972 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
2977 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
2979 if (video_codec_name) {
2980 codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
2981 codec = avcodec_find_encoder_by_name(video_codec_name);
2982 output_codecs[nb_ocodecs] = codec;
2984 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2985 codec = avcodec_find_encoder(codec_id);
2988 video_enc->codec_id = codec_id;
2990 set_context_opts(video_enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
2992 if (codec && codec->supported_framerates && !force_fps)
2993 fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
2994 video_enc->time_base.den = fps.num;
2995 video_enc->time_base.num = fps.den;
2997 video_enc->width = frame_width + frame_padright + frame_padleft;
2998 video_enc->height = frame_height + frame_padtop + frame_padbottom;
2999 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3000 video_enc->pix_fmt = frame_pix_fmt;
3001 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3003 if(codec && codec->pix_fmts){
3004 const enum PixelFormat *p= codec->pix_fmts;
3006 if(*p == video_enc->pix_fmt)
3010 video_enc->pix_fmt = codec->pix_fmts[0];
3014 video_enc->gop_size = 0;
3015 if (video_qscale || same_quality) {
3016 video_enc->flags |= CODEC_FLAG_QSCALE;
3017 video_enc->global_quality=
3018 st->quality = FF_QP2LAMBDA * video_qscale;
3022 video_enc->intra_matrix = intra_matrix;
3024 video_enc->inter_matrix = inter_matrix;
3026 video_enc->thread_count = thread_count;
3027 p= video_rc_override_string;
3030 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3032 fprintf(stderr, "error parsing rc_override\n");
3035 video_enc->rc_override=
3036 av_realloc(video_enc->rc_override,
3037 sizeof(RcOverride)*(i+1));
3038 video_enc->rc_override[i].start_frame= start;
3039 video_enc->rc_override[i].end_frame = end;
3041 video_enc->rc_override[i].qscale= q;
3042 video_enc->rc_override[i].quality_factor= 1.0;
3045 video_enc->rc_override[i].qscale= 0;
3046 video_enc->rc_override[i].quality_factor= -q/100.0;
3051 video_enc->rc_override_count=i;
3052 if (!video_enc->rc_initial_buffer_occupancy)
3053 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3054 video_enc->me_threshold= me_threshold;
3055 video_enc->intra_dc_precision= intra_dc_precision - 8;
3058 video_enc->flags|= CODEC_FLAG_PSNR;
3063 video_enc->flags |= CODEC_FLAG_PASS1;
3065 video_enc->flags |= CODEC_FLAG_PASS2;
3071 /* reset some key parameters */
3073 av_freep(&video_codec_name);
3074 video_stream_copy = 0;
3077 static void new_audio_stream(AVFormatContext *oc)
3080 AVCodecContext *audio_enc;
3083 st = av_new_stream(oc, oc->nb_streams);
3085 fprintf(stderr, "Could not alloc stream\n");
3088 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3090 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3091 audio_bitstream_filters= NULL;
3094 avcodec_thread_init(st->codec, thread_count);
3096 audio_enc = st->codec;
3097 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3100 audio_enc->codec_tag= audio_codec_tag;
3102 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3103 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3104 avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3106 if (audio_stream_copy) {
3107 st->stream_copy = 1;
3108 audio_enc->channels = audio_channels;
3112 set_context_opts(audio_enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3114 if (audio_codec_name) {
3115 codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3116 codec = avcodec_find_encoder_by_name(audio_codec_name);
3117 output_codecs[nb_ocodecs] = codec;
3119 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3120 codec = avcodec_find_encoder(codec_id);
3122 audio_enc->codec_id = codec_id;
3124 if (audio_qscale > QSCALE_NONE) {
3125 audio_enc->flags |= CODEC_FLAG_QSCALE;
3126 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3128 audio_enc->thread_count = thread_count;
3129 audio_enc->channels = audio_channels;
3130 audio_enc->sample_fmt = audio_sample_fmt;
3132 if(codec && codec->sample_fmts){
3133 const enum SampleFormat *p= codec->sample_fmts;
3135 if(*p == audio_enc->sample_fmt)
3139 audio_enc->sample_fmt = codec->sample_fmts[0];
3143 audio_enc->sample_rate = audio_sample_rate;
3144 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3145 if (audio_language) {
3146 av_strlcpy(st->language, audio_language, sizeof(st->language));
3147 av_free(audio_language);
3148 audio_language = NULL;
3151 /* reset some key parameters */
3153 av_freep(&audio_codec_name);
3154 audio_stream_copy = 0;
3157 static void new_subtitle_stream(AVFormatContext *oc)
3160 AVCodecContext *subtitle_enc;
3162 st = av_new_stream(oc, oc->nb_streams);
3164 fprintf(stderr, "Could not alloc stream\n");
3167 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3169 bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3170 subtitle_bitstream_filters= NULL;
3172 subtitle_enc = st->codec;
3173 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3174 if (subtitle_stream_copy) {
3175 st->stream_copy = 1;
3177 set_context_opts(avctx_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3178 subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3179 output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3183 if (subtitle_language) {
3184 av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3185 av_free(subtitle_language);
3186 subtitle_language = NULL;
3189 subtitle_disable = 0;
3190 av_freep(&subtitle_codec_name);
3191 subtitle_stream_copy = 0;
3194 static void opt_new_audio_stream(void)
3196 AVFormatContext *oc;
3197 if (nb_output_files <= 0) {
3198 fprintf(stderr, "At least one output file must be specified\n");
3201 oc = output_files[nb_output_files - 1];
3202 new_audio_stream(oc);
3205 static void opt_new_video_stream(void)
3207 AVFormatContext *oc;
3208 if (nb_output_files <= 0) {
3209 fprintf(stderr, "At least one output file must be specified\n");
3212 oc = output_files[nb_output_files - 1];
3213 new_video_stream(oc);
3216 static void opt_new_subtitle_stream(void)
3218 AVFormatContext *oc;
3219 if (nb_output_files <= 0) {
3220 fprintf(stderr, "At least one output file must be specified\n");
3223 oc = output_files[nb_output_files - 1];
3224 new_subtitle_stream(oc);
3227 static void opt_output_file(const char *filename)
3229 AVFormatContext *oc;
3230 int use_video, use_audio, use_subtitle;
3231 int input_has_video, input_has_audio, input_has_subtitle;
3232 AVFormatParameters params, *ap = ¶ms;
3234 if (!strcmp(filename, "-"))
3237 oc = av_alloc_format_context();
3239 if (!file_oformat) {
3240 file_oformat = guess_format(NULL, filename, NULL);
3241 if (!file_oformat) {
3242 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3248 oc->oformat = file_oformat;
3249 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3251 if (!strcmp(file_oformat->name, "ffm") &&
3252 av_strstart(filename, "http:", NULL)) {
3253 /* special case for files sent to ffserver: we get the stream
3254 parameters from ffserver */
3255 int err = read_ffserver_streams(oc, filename);
3257 print_error(filename, err);
3261 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3262 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3263 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3265 /* disable if no corresponding type found and at least one
3267 if (nb_input_files > 0) {
3268 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3269 &input_has_subtitle);
3270 if (!input_has_video)
3272 if (!input_has_audio)
3274 if (!input_has_subtitle)
3278 /* manual disable */
3279 if (audio_disable) {
3282 if (video_disable) {
3285 if (subtitle_disable) {
3290 new_video_stream(oc);
3294 new_audio_stream(oc);
3298 new_subtitle_stream(oc);
3301 oc->timestamp = rec_timestamp;
3304 av_strlcpy(oc->title, str_title, sizeof(oc->title));
3306 av_strlcpy(oc->author, str_author, sizeof(oc->author));
3308 av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3310 av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3312 av_strlcpy(oc->album, str_album, sizeof(oc->album));
3314 av_strlcpy(oc->genre, str_genre, sizeof(oc->genre));
3317 output_files[nb_output_files++] = oc;
3319 /* check filename in case of an image number is expected */
3320 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3321 if (!av_filename_number_test(oc->filename)) {
3322 print_error(oc->filename, AVERROR_NUMEXPECTED);
3327 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3328 /* test if it already exists to avoid loosing precious files */
3329 if (!file_overwrite &&
3330 (strchr(filename, ':') == NULL ||
3331 filename[1] == ':' ||
3332 av_strstart(filename, "file:", NULL))) {
3333 if (url_exist(filename)) {
3337 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3340 if (toupper(c) != 'Y') {
3341 fprintf(stderr, "Not overwriting - exiting\n");
3346 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3353 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3354 fprintf(stderr, "Could not open '%s'\n", filename);
3359 memset(ap, 0, sizeof(*ap));
3360 if (av_set_parameters(oc, ap) < 0) {
3361 fprintf(stderr, "%s: Invalid encoding parameters\n",
3366 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3367 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3368 oc->loop_output = loop_output;
3370 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3372 /* reset some options */
3373 file_oformat = NULL;
3374 file_iformat = NULL;
3377 /* same option as mencoder */
3378 static void opt_pass(const char *pass_str)
3381 pass = atoi(pass_str);
3382 if (pass != 1 && pass != 2) {
3383 fprintf(stderr, "pass number can be only 1 or 2\n");
3389 static int64_t getutime(void)
3391 #ifdef HAVE_GETRUSAGE
3392 struct rusage rusage;
3394 getrusage(RUSAGE_SELF, &rusage);
3395 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3396 #elif defined(HAVE_GETPROCESSTIMES)
3398 FILETIME c, e, k, u;
3399 proc = GetCurrentProcess();
3400 GetProcessTimes(proc, &c, &e, &k, &u);
3401 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3403 return av_gettime();
3407 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3410 const char *p = str;
3417 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3424 static void opt_inter_matrix(const char *arg)
3426 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3427 parse_matrix_coeffs(inter_matrix, arg);
3430 static void opt_intra_matrix(const char *arg)
3432 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3433 parse_matrix_coeffs(intra_matrix, arg);
3437 * Trivial log callback.
3438 * Only suitable for show_help and similar since it lacks prefix handling.
3440 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3442 vfprintf(stdout, fmt, vl);
3445 static void show_help(void)
3447 av_log_set_callback(log_callback_help);
3448 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3449 "Hyper fast Audio and Video encoder\n");
3451 show_help_options(options, "Main options:\n",
3452 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3453 show_help_options(options, "\nAdvanced options:\n",
3454 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3456 show_help_options(options, "\nVideo options:\n",
3457 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3459 show_help_options(options, "\nAdvanced Video options:\n",
3460 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3461 OPT_VIDEO | OPT_EXPERT);
3462 show_help_options(options, "\nAudio options:\n",
3463 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3465 show_help_options(options, "\nAdvanced Audio options:\n",
3466 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3467 OPT_AUDIO | OPT_EXPERT);
3468 show_help_options(options, "\nSubtitle options:\n",
3469 OPT_SUBTITLE | OPT_GRAB,
3471 show_help_options(options, "\nAudio/Video grab options:\n",
3475 av_opt_show(avctx_opts[0], NULL);
3477 av_opt_show(avformat_opts, NULL);
3479 av_opt_show(sws_opts, NULL);
3482 static void opt_target(const char *arg)
3485 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3487 if(!strncmp(arg, "pal-", 4)) {
3490 } else if(!strncmp(arg, "ntsc-", 5)) {
3493 } else if(!strncmp(arg, "film-", 5)) {
3498 /* Calculate FR via float to avoid int overflow */
3499 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3502 } else if((fr == 29970) || (fr == 23976)) {
3505 /* Try to determine PAL/NTSC by peeking in the input files */
3506 if(nb_input_files) {
3508 for(j = 0; j < nb_input_files; j++) {
3509 for(i = 0; i < input_files[j]->nb_streams; i++) {
3510 AVCodecContext *c = input_files[j]->streams[i]->codec;
3511 if(c->codec_type != CODEC_TYPE_VIDEO)
3513 fr = c->time_base.den * 1000 / c->time_base.num;
3517 } else if((fr == 29970) || (fr == 23976)) {
3527 if(verbose && norm >= 0)
3528 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3532 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3533 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3534 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3538 if(!strcmp(arg, "vcd")) {
3540 opt_video_codec("mpeg1video");
3541 opt_audio_codec("mp2");
3544 opt_frame_size(norm ? "352x240" : "352x288");
3545 opt_frame_rate(NULL, frame_rates[norm]);
3546 opt_default("gop", norm ? "18" : "15");
3548 opt_default("b", "1150000");
3549 opt_default("maxrate", "1150000");
3550 opt_default("minrate", "1150000");
3551 opt_default("bufsize", "327680"); // 40*1024*8;
3553 opt_default("ab", "224000");
3554 audio_sample_rate = 44100;
3557 opt_default("packetsize", "2324");
3558 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3560 /* We have to offset the PTS, so that it is consistent with the SCR.
3561 SCR starts at 36000, but the first two packs contain only padding
3562 and the first pack from the other stream, respectively, may also have
3563 been written before.
3564 So the real data starts at SCR 36000+3*1200. */
3565 mux_preload= (36000+3*1200) / 90000.0; //0.44
3566 } else if(!strcmp(arg, "svcd")) {
3568 opt_video_codec("mpeg2video");
3569 opt_audio_codec("mp2");
3572 opt_frame_size(norm ? "480x480" : "480x576");
3573 opt_frame_rate(NULL, frame_rates[norm]);
3574 opt_default("gop", norm ? "18" : "15");
3576 opt_default("b", "2040000");
3577 opt_default("maxrate", "2516000");
3578 opt_default("minrate", "0"); //1145000;
3579 opt_default("bufsize", "1835008"); //224*1024*8;
3580 opt_default("flags", "+scan_offset");
3583 opt_default("ab", "224000");
3584 audio_sample_rate = 44100;
3586 opt_default("packetsize", "2324");
3588 } else if(!strcmp(arg, "dvd")) {
3590 opt_video_codec("mpeg2video");
3591 opt_audio_codec("ac3");
3594 opt_frame_size(norm ? "720x480" : "720x576");
3595 opt_frame_rate(NULL, frame_rates[norm]);
3596 opt_default("gop", norm ? "18" : "15");
3598 opt_default("b", "6000000");
3599 opt_default("maxrate", "9000000");
3600 opt_default("minrate", "0"); //1500000;
3601 opt_default("bufsize", "1835008"); //224*1024*8;
3603 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3604 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3606 opt_default("ab", "448000");
3607 audio_sample_rate = 48000;
3609 } else if(!strncmp(arg, "dv", 2)) {
3613 opt_frame_size(norm ? "720x480" : "720x576");
3614 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3615 (norm ? "yuv411p" : "yuv420p"));
3616 opt_frame_rate(NULL, frame_rates[norm]);
3618 audio_sample_rate = 48000;
3622 fprintf(stderr, "Unknown target: %s\n", arg);
3627 static void opt_vstats_file (const char *arg)
3629 av_free (vstats_filename);
3630 vstats_filename=av_strdup (arg);
3633 static void opt_vstats (void)
3636 time_t today2 = time(NULL);
3637 struct tm *today = localtime(&today2);
3639 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3641 opt_vstats_file(filename);
3644 static int opt_bsf(const char *opt, const char *arg)
3646 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3647 AVBitStreamFilterContext **bsfp;
3650 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3654 bsfp= *opt == 'v' ? &video_bitstream_filters :
3655 *opt == 'a' ? &audio_bitstream_filters :
3656 &subtitle_bitstream_filters;
3658 bsfp= &(*bsfp)->next;
3665 static int opt_preset(const char *opt, const char *arg)
3668 char filename[1000], tmp[1000], tmp2[1000], line[1000];
3670 const char *base[3]= { getenv("HOME"),
3675 for(i=!base[0]; i<3 && !f; i++){
3676 snprintf(filename, sizeof(filename), "%s/%sffmpeg/%s.ffpreset", base[i], i ? "" : ".", arg);
3677 f= fopen(filename, "r");
3679 char *codec_name= *opt == 'v' ? video_codec_name :
3680 *opt == 'a' ? audio_codec_name :
3681 subtitle_codec_name;
3682 snprintf(filename, sizeof(filename), "%s/%sffmpeg/%s-%s.ffpreset", base[i], i ? "" : ".", codec_name, arg);
3683 f= fopen(filename, "r");
3686 if(!f && ((arg[0]=='.' && arg[1]=='/') || arg[0]=='/' ||
3688 snprintf(filename, sizeof(filename), arg);
3689 f= fopen(filename, "r");
3693 fprintf(stderr, "File for preset '%s' not found\n", arg);
3698 int e= fscanf(f, "%999[^\n]\n", line) - 1;
3699 if(line[0] == '#' && !e)
3701 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3703 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3706 if(!strcmp(tmp, "acodec")){
3707 opt_audio_codec(tmp2);
3708 }else if(!strcmp(tmp, "vcodec")){
3709 opt_video_codec(tmp2);
3710 }else if(!strcmp(tmp, "scodec")){
3711 opt_subtitle_codec(tmp2);
3712 }else if(opt_default(tmp, tmp2) < 0){
3713 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3723 static const OptionDef options[] = {
3725 { "L", OPT_EXIT, {(void*)show_license}, "show license" },
3726 { "h", OPT_EXIT, {(void*)show_help}, "show help" },
3727 { "version", OPT_EXIT, {(void*)show_version}, "show version" },
3728 { "formats", OPT_EXIT, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3729 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3730 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3731 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3732 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3733 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3734 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3735 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3736 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3737 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3738 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
3739 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3740 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3741 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3742 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3743 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3744 { "genre", HAS_ARG | OPT_STRING, {(void*)&str_genre}, "set the genre", "string" },
3745 { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3746 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3747 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3748 "add timings for benchmarking" },
3749 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3750 "dump each input packet" },
3751 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3752 "when dumping packets, also dump the payload" },
3753 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3754 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3755 { "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)", "" },
3756 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set the logging verbosity level", "number" },
3757 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3758 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3759 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3760 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3761 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3762 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3763 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3764 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3765 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3766 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3767 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
3770 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3771 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3772 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3773 { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3774 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3775 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3776 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format, 'list' as argument shows all the pixel formats supported", "format" },
3777 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3778 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3779 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3780 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3781 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3782 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3783 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3784 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3785 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3786 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3787 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3788 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3789 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3790 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3791 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3792 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
3793 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3794 "use same video quality as source (implies VBR)" },
3795 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3796 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3797 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3798 "deinterlace pictures" },
3799 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3800 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3801 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3803 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3805 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3806 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3807 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3808 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3809 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3810 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3811 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3812 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
3815 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3816 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3817 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3818 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3819 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3820 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3821 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3822 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3823 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3824 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3825 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3826 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_sample_fmt}, "set sample format, 'list' as argument shows all the sample formats supported", "format" },
3828 /* subtitle options */
3829 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3830 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3831 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3832 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3835 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3836 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3837 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3840 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3841 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3843 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3844 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3845 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3847 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3848 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3849 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3851 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3855 int main(int argc, char **argv)
3860 avcodec_register_all();
3861 avdevice_register_all();
3864 if(isatty(STDIN_FILENO))
3865 url_set_interrupt_cb(decode_interrupt_cb);
3867 for(i=0; i<CODEC_TYPE_NB; i++){
3868 avctx_opts[i]= avcodec_alloc_context2(i);
3870 avformat_opts = av_alloc_format_context();
3871 sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3876 parse_options(argc, argv, options, opt_output_file);
3878 /* file converter / grab */
3879 if (nb_output_files <= 0) {
3880 fprintf(stderr, "At least one output file must be specified\n");
3884 if (nb_input_files == 0) {
3885 fprintf(stderr, "At least one input file must be specified\n");
3890 av_encode(output_files, nb_output_files, input_files, nb_input_files,
3891 stream_maps, nb_stream_maps);
3892 ti = getutime() - ti;
3894 printf("bench: utime=%0.3fs\n", ti / 1000000.0);