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 "libavcodec/opt.h"
38 #include "libavcodec/audioconvert.h"
39 #include "libavcodec/colorspace.h"
40 #include "libavutil/fifo.h"
41 #include "libavutil/avstring.h"
42 #include "libavformat/os_support.h"
44 #if HAVE_SYS_RESOURCE_H
45 #include <sys/types.h>
46 #include <sys/resource.h>
47 #elif HAVE_GETPROCESSTIMES
52 #include <sys/select.h>
57 #include <sys/ioctl.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 static int64_t channel_layout = 0;
155 #define QSCALE_NONE -99999
156 static float audio_qscale = QSCALE_NONE;
157 static int audio_disable = 0;
158 static int audio_channels = 1;
159 static char *audio_codec_name = NULL;
160 static int audio_codec_tag = 0;
161 static char *audio_language = NULL;
163 static int subtitle_disable = 0;
164 static char *subtitle_codec_name = NULL;
165 static char *subtitle_language = NULL;
166 static int subtitle_codec_tag = 0;
168 static float mux_preload= 0.5;
169 static float mux_max_delay= 0.7;
171 static int64_t recording_time = INT64_MAX;
172 static int64_t start_time = 0;
173 static int64_t rec_timestamp = 0;
174 static int64_t input_ts_offset = 0;
175 static int file_overwrite = 0;
176 static int metadata_count;
177 static AVMetadataTag *metadata;
178 static int do_benchmark = 0;
179 static int do_hex_dump = 0;
180 static int do_pkt_dump = 0;
181 static int do_psnr = 0;
182 static int do_pass = 0;
183 static char *pass_logfilename_prefix = NULL;
184 static int audio_stream_copy = 0;
185 static int video_stream_copy = 0;
186 static int subtitle_stream_copy = 0;
187 static int video_sync_method= -1;
188 static int audio_sync_method= 0;
189 static float audio_drift_threshold= 0.1;
190 static int copy_ts= 0;
191 static int opt_shortest = 0;
192 static int video_global_header = 0;
193 static char *vstats_filename;
194 static FILE *vstats_file;
195 static int opt_programid = 0;
196 static int copy_initial_nonkeyframes = 0;
198 static int rate_emu = 0;
200 static int video_channel = 0;
201 static char *video_standard;
203 static int audio_volume = 256;
205 static int exit_on_error = 0;
206 static int using_stdin = 0;
207 static int verbose = 1;
208 static int thread_count= 1;
209 static int q_pressed = 0;
210 static int64_t video_size = 0;
211 static int64_t audio_size = 0;
212 static int64_t extra_size = 0;
213 static int nb_frames_dup = 0;
214 static int nb_frames_drop = 0;
215 static int input_sync;
216 static uint64_t limit_filesize = 0;
217 static int force_fps = 0;
219 static int pgmyuv_compatibility_hack=0;
220 static float dts_delta_threshold = 10;
222 static unsigned int sws_flags = SWS_BICUBIC;
224 static int64_t timer_start;
226 static uint8_t *audio_buf;
227 static uint8_t *audio_out;
228 static uint8_t *audio_out2;
230 static short *samples;
232 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
233 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
234 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
235 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
237 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
239 struct AVInputStream;
241 typedef struct AVOutputStream {
242 int file_index; /* file index */
243 int index; /* stream index in the output file */
244 int source_index; /* AVInputStream index */
245 AVStream *st; /* stream in the output file */
246 int encoding_needed; /* true if encoding needed for this stream */
248 /* input pts and corresponding output pts
250 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
251 struct AVInputStream *sync_ist; /* input stream to sync against */
252 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
255 AVFrame pict_tmp; /* temporary image for resampling */
256 struct SwsContext *img_resample_ctx; /* for image resampling */
260 int topBand; /* cropping area sizes */
264 int padtop; /* padding area sizes */
271 ReSampleContext *resample; /* for audio resampling */
273 AVAudioConvert *reformat_ctx;
274 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
278 typedef struct AVInputStream {
282 int discard; /* true if stream data should be discarded */
283 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
284 int64_t sample_index; /* current sample */
286 int64_t start; /* time when read started */
287 int64_t next_pts; /* synthetic pts for cases where pkt.pts
289 int64_t pts; /* current pts */
290 int is_start; /* is 1 at the start and after a discontinuity */
293 typedef struct AVInputFile {
294 int eof_reached; /* true if eof reached */
295 int ist_index; /* index of first stream in ist_table */
296 int buffer_size; /* current total buffer size */
297 int nb_streams; /* nb streams we are aware of */
302 /* init terminal so that we can grab keys */
303 static struct termios oldtty;
306 static void term_exit(void)
309 tcsetattr (0, TCSANOW, &oldtty);
313 static volatile sig_atomic_t received_sigterm = 0;
316 sigterm_handler(int sig)
318 received_sigterm = sig;
322 static void term_init(void)
330 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
331 |INLCR|IGNCR|ICRNL|IXON);
332 tty.c_oflag |= OPOST;
333 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
334 tty.c_cflag &= ~(CSIZE|PARENB);
339 tcsetattr (0, TCSANOW, &tty);
340 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
343 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
344 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
346 register a function to be called at normal program termination
349 #if CONFIG_BEOS_NETSERVER
350 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
354 /* read a key without blocking */
355 static int read_key(void)
360 #if !CONFIG_BEOS_NETSERVER
368 n = select(1, &rfds, NULL, NULL, &tv);
384 static int decode_interrupt_cb(void)
386 return q_pressed || (q_pressed = read_key() == 'q');
389 static int av_exit(int ret)
394 for(i=0;i<nb_output_files;i++) {
395 /* maybe av_close_output_file ??? */
396 AVFormatContext *s = output_files[i];
398 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
400 for(j=0;j<s->nb_streams;j++) {
401 av_metadata_free(&s->streams[j]->metadata);
402 av_free(s->streams[j]->codec);
403 av_free(s->streams[j]);
405 for(j=0;j<s->nb_programs;j++) {
406 av_metadata_free(&s->programs[j]->metadata);
408 for(j=0;j<s->nb_chapters;j++) {
409 av_metadata_free(&s->chapters[j]->metadata);
411 av_metadata_free(&s->metadata);
414 for(i=0;i<nb_input_files;i++)
415 av_close_input_file(input_files[i]);
417 av_free(intra_matrix);
418 av_free(inter_matrix);
422 av_free(vstats_filename);
426 av_free(video_codec_name);
427 av_free(audio_codec_name);
428 av_free(subtitle_codec_name);
430 av_free(video_standard);
432 #if CONFIG_POWERPC_PERF
433 void powerpc_display_perf_report(void);
434 powerpc_display_perf_report();
435 #endif /* CONFIG_POWERPC_PERF */
437 for (i=0;i<CODEC_TYPE_NB;i++)
438 av_free(avcodec_opts[i]);
439 av_free(avformat_opts);
446 if (received_sigterm) {
448 "Received signal %d: terminating.\n",
449 (int) received_sigterm);
453 exit(ret); /* not all OS-es handle main() return value */
457 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
463 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
466 /* copy stream format */
467 s->nb_streams = ic->nb_streams;
468 for(i=0;i<ic->nb_streams;i++) {
471 // FIXME: a more elegant solution is needed
472 st = av_mallocz(sizeof(AVStream));
473 memcpy(st, ic->streams[i], sizeof(AVStream));
474 st->codec = avcodec_alloc_context();
475 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
478 if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
480 else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
483 if(!st->codec->thread_count)
484 st->codec->thread_count = 1;
485 if(st->codec->thread_count>1)
486 avcodec_thread_init(st->codec, st->codec->thread_count);
488 if(st->codec->flags & CODEC_FLAG_BITEXACT)
493 s->timestamp = av_gettime();
495 av_close_input_file(ic);
500 get_sync_ipts(const AVOutputStream *ost)
502 const AVInputStream *ist = ost->sync_ist;
503 return (double)(ist->pts - start_time)/AV_TIME_BASE;
506 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
510 AVPacket new_pkt= *pkt;
511 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
512 &new_pkt.data, &new_pkt.size,
513 pkt->data, pkt->size,
514 pkt->flags & PKT_FLAG_KEY);
517 new_pkt.destruct= av_destruct_packet;
519 fprintf(stderr, "%s failed for stream %d, codec %s",
520 bsfc->filter->name, pkt->stream_index,
521 avctx->codec ? avctx->codec->name : "copy");
531 ret= av_interleaved_write_frame(s, pkt);
533 print_error("av_interleaved_write_frame()", ret);
538 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
540 static void do_audio_out(AVFormatContext *s,
543 unsigned char *buf, int size)
546 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
548 int size_out, frame_bytes, ret;
549 AVCodecContext *enc= ost->st->codec;
550 AVCodecContext *dec= ist->st->codec;
551 int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
552 int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
554 /* SC: dynamic allocation of buffers */
556 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
558 audio_out = av_malloc(audio_out_size);
559 if (!audio_buf || !audio_out)
560 return; /* Should signal an error ! */
562 if (enc->channels != dec->channels)
563 ost->audio_resample = 1;
565 if (ost->audio_resample && !ost->resample) {
566 if (dec->sample_fmt != SAMPLE_FMT_S16)
567 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
568 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
569 enc->sample_rate, dec->sample_rate,
570 enc->sample_fmt, dec->sample_fmt,
572 if (!ost->resample) {
573 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
574 dec->channels, dec->sample_rate,
575 enc->channels, enc->sample_rate);
580 #define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
581 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
582 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
584 audio_out2 = av_malloc(audio_out_size);
587 if (ost->reformat_ctx)
588 av_audio_convert_free(ost->reformat_ctx);
589 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
590 dec->sample_fmt, 1, NULL, 0);
591 if (!ost->reformat_ctx) {
592 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
593 avcodec_get_sample_fmt_name(dec->sample_fmt),
594 avcodec_get_sample_fmt_name(enc->sample_fmt));
597 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
600 if(audio_sync_method){
601 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
602 - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2);
603 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
604 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
606 //FIXME resample delay
607 if(fabs(delta) > 50){
608 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
610 byte_delta= FFMAX(byte_delta, -size);
614 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
619 static uint8_t *input_tmp= NULL;
620 input_tmp= av_realloc(input_tmp, byte_delta + size);
622 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
625 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
627 memset(input_tmp, 0, byte_delta);
628 memcpy(input_tmp + byte_delta, buf, size);
632 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
634 }else if(audio_sync_method>1){
635 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
636 assert(ost->audio_resample);
638 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
639 // 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));
640 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
644 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
645 - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
647 if (ost->audio_resample) {
649 size_out = audio_resample(ost->resample,
650 (short *)buftmp, (short *)buf,
651 size / (ist->st->codec->channels * isize));
652 size_out = size_out * enc->channels * osize;
658 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
659 const void *ibuf[6]= {buftmp};
660 void *obuf[6]= {audio_out2};
661 int istride[6]= {isize};
662 int ostride[6]= {osize};
663 int len= size_out/istride[0];
664 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
665 printf("av_audio_convert() failed\n");
671 size_out = len*osize;
674 /* now encode as many frames as possible */
675 if (enc->frame_size > 1) {
676 /* output resampled raw samples */
677 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
678 fprintf(stderr, "av_fifo_realloc2() failed\n");
681 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
683 frame_bytes = enc->frame_size * osize * enc->channels;
685 while (av_fifo_size(ost->fifo) >= frame_bytes) {
687 av_init_packet(&pkt);
689 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
691 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
693 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
696 fprintf(stderr, "Audio encoding failed\n");
700 pkt.stream_index= ost->index;
703 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
704 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
705 pkt.flags |= PKT_FLAG_KEY;
706 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
708 ost->sync_opts += enc->frame_size;
712 int coded_bps = av_get_bits_per_sample(enc->codec->id)/8;
713 av_init_packet(&pkt);
715 ost->sync_opts += size_out / (osize * enc->channels);
717 /* output a pcm frame */
718 /* determine the size of the coded buffer */
721 size_out *= coded_bps;
723 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
724 ret = avcodec_encode_audio(enc, audio_out, size_out,
727 fprintf(stderr, "Audio encoding failed\n");
731 pkt.stream_index= ost->index;
734 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
735 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
736 pkt.flags |= PKT_FLAG_KEY;
737 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
741 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
745 AVPicture picture_tmp;
748 dec = ist->st->codec;
750 /* deinterlace : must be done before any resize */
751 if (do_deinterlace) {
754 /* create temporary picture */
755 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
756 buf = av_malloc(size);
760 picture2 = &picture_tmp;
761 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
763 if(avpicture_deinterlace(picture2, picture,
764 dec->pix_fmt, dec->width, dec->height) < 0) {
765 /* if error, do not deinterlace */
766 fprintf(stderr, "Deinterlacing failed\n");
775 if (picture != picture2)
776 *picture = *picture2;
780 /* we begin to correct av delay at this threshold */
781 #define AV_DELAY_MAX 0.100
783 static void do_subtitle_out(AVFormatContext *s,
789 static uint8_t *subtitle_out = NULL;
790 int subtitle_out_max_size = 65536;
791 int subtitle_out_size, nb, i;
795 if (pts == AV_NOPTS_VALUE) {
796 fprintf(stderr, "Subtitle packets must have a pts\n");
802 enc = ost->st->codec;
805 subtitle_out = av_malloc(subtitle_out_max_size);
808 /* Note: DVB subtitle need one packet to draw them and one other
809 packet to clear them */
810 /* XXX: signal it in the codec context ? */
811 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
816 for(i = 0; i < nb; i++) {
817 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
818 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
819 subtitle_out_max_size, sub);
821 av_init_packet(&pkt);
822 pkt.stream_index = ost->index;
823 pkt.data = subtitle_out;
824 pkt.size = subtitle_out_size;
825 pkt.pts = av_rescale_q(pts, ist->st->time_base, ost->st->time_base);
826 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
827 /* XXX: the pts correction is handled here. Maybe handling
828 it in the codec would be better */
830 pkt.pts += 90 * sub->start_display_time;
832 pkt.pts += 90 * sub->end_display_time;
834 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
838 static int bit_buffer_size= 1024*256;
839 static uint8_t *bit_buffer= NULL;
841 static void do_video_out(AVFormatContext *s,
847 int nb_frames, i, ret;
848 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
849 AVFrame picture_crop_temp, picture_pad_temp;
850 AVCodecContext *enc, *dec;
852 avcodec_get_frame_defaults(&picture_crop_temp);
853 avcodec_get_frame_defaults(&picture_pad_temp);
855 enc = ost->st->codec;
856 dec = ist->st->codec;
858 /* by default, we output a single frame */
863 if(video_sync_method>0 || (video_sync_method && av_q2d(enc->time_base) > 0.001)){
865 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
866 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
869 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
873 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
874 }else if (vdelta > 1.1)
875 nb_frames = lrintf(vdelta);
876 //fprintf(stderr, "vdelta:%f, ost->sync_opts:%"PRId64", ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, get_sync_ipts(ost), nb_frames);
880 fprintf(stderr, "*** drop!\n");
881 }else if (nb_frames > 1) {
882 nb_frames_dup += nb_frames;
884 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
887 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
889 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
893 if (ost->video_crop) {
894 if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
895 fprintf(stderr, "error cropping picture\n");
900 formatted_picture = &picture_crop_temp;
902 formatted_picture = in_picture;
905 final_picture = formatted_picture;
906 padding_src = formatted_picture;
907 resampling_dst = &ost->pict_tmp;
908 if (ost->video_pad) {
909 final_picture = &ost->pict_tmp;
910 if (ost->video_resample) {
911 if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
912 fprintf(stderr, "error padding picture\n");
917 resampling_dst = &picture_pad_temp;
921 if (ost->video_resample) {
923 final_picture = &ost->pict_tmp;
924 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
925 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
928 if (ost->video_pad) {
929 av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
930 enc->height, enc->width, enc->pix_fmt,
931 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
934 /* duplicates frame if needed */
935 for(i=0;i<nb_frames;i++) {
937 av_init_packet(&pkt);
938 pkt.stream_index= ost->index;
940 if (s->oformat->flags & AVFMT_RAWPICTURE) {
941 /* raw pictures are written as AVPicture structure to
942 avoid any copies. We support temorarily the older
944 AVFrame* old_frame = enc->coded_frame;
945 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
946 pkt.data= (uint8_t *)final_picture;
947 pkt.size= sizeof(AVPicture);
948 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
949 pkt.flags |= PKT_FLAG_KEY;
951 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
952 enc->coded_frame = old_frame;
956 big_picture= *final_picture;
957 /* better than nothing: use input picture interlaced
959 big_picture.interlaced_frame = in_picture->interlaced_frame;
960 if(avcodec_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
961 if(top_field_first == -1)
962 big_picture.top_field_first = in_picture->top_field_first;
964 big_picture.top_field_first = top_field_first;
967 /* handles sameq here. This is not correct because it may
968 not be a global option */
970 big_picture.quality = ist->st->quality;
972 big_picture.quality = ost->st->quality;
974 big_picture.pict_type = 0;
975 // big_picture.pts = AV_NOPTS_VALUE;
976 big_picture.pts= ost->sync_opts;
977 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
978 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
979 ret = avcodec_encode_video(enc,
980 bit_buffer, bit_buffer_size,
983 fprintf(stderr, "Video encoding failed\n");
988 pkt.data= bit_buffer;
990 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
991 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
992 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
993 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
994 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
996 if(enc->coded_frame->key_frame)
997 pkt.flags |= PKT_FLAG_KEY;
998 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1001 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1002 // enc->frame_number-1, ret, enc->pict_type);
1003 /* if two pass, output log */
1004 if (ost->logfile && enc->stats_out) {
1005 fprintf(ost->logfile, "%s", enc->stats_out);
1010 ost->frame_number++;
1014 static double psnr(double d){
1015 return -10.0*log(d)/log(10.0);
1018 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1021 AVCodecContext *enc;
1023 double ti1, bitrate, avg_bitrate;
1025 /* this is executed just the first time do_video_stats is called */
1027 vstats_file = fopen(vstats_filename, "w");
1034 enc = ost->st->codec;
1035 if (enc->codec_type == CODEC_TYPE_VIDEO) {
1036 frame_number = ost->frame_number;
1037 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1038 if (enc->flags&CODEC_FLAG_PSNR)
1039 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1041 fprintf(vstats_file,"f_size= %6d ", frame_size);
1042 /* compute pts value */
1043 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1047 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1048 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1049 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1050 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1051 fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1055 static void print_report(AVFormatContext **output_files,
1056 AVOutputStream **ost_table, int nb_ostreams,
1060 AVOutputStream *ost;
1061 AVFormatContext *oc;
1063 AVCodecContext *enc;
1064 int frame_number, vid, i;
1065 double bitrate, ti1, pts;
1066 static int64_t last_time = -1;
1067 static int qp_histogram[52];
1069 if (!is_last_report) {
1071 /* display the report every 0.5 seconds */
1072 cur_time = av_gettime();
1073 if (last_time == -1) {
1074 last_time = cur_time;
1077 if ((cur_time - last_time) < 500000)
1079 last_time = cur_time;
1083 oc = output_files[0];
1085 total_size = url_fsize(oc->pb);
1086 if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1087 total_size= url_ftell(oc->pb);
1092 for(i=0;i<nb_ostreams;i++) {
1094 enc = ost->st->codec;
1095 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1096 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1097 !ost->st->stream_copy ?
1098 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1100 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1101 float t = (av_gettime()-timer_start) / 1000000.0;
1103 frame_number = ost->frame_number;
1104 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1105 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1106 !ost->st->stream_copy ?
1107 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1109 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1112 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1113 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1116 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1118 if (enc->flags&CODEC_FLAG_PSNR){
1120 double error, error_sum=0;
1121 double scale, scale_sum=0;
1122 char type[3]= {'Y','U','V'};
1123 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1126 error= enc->error[j];
1127 scale= enc->width*enc->height*255.0*255.0*frame_number;
1129 error= enc->coded_frame->error[j];
1130 scale= enc->width*enc->height*255.0*255.0;
1135 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1137 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1141 /* compute min output value */
1142 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1143 if ((pts < ti1) && (pts > 0))
1149 if (verbose || is_last_report) {
1150 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1152 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1153 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1154 (double)total_size / 1024, ti1, bitrate);
1157 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1158 nb_frames_dup, nb_frames_drop);
1161 fprintf(stderr, "%s \r", buf);
1166 if (is_last_report && verbose >= 0){
1167 int64_t raw= audio_size + video_size + extra_size;
1168 fprintf(stderr, "\n");
1169 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1173 100.0*(total_size - raw)/raw
1178 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1179 static int output_packet(AVInputStream *ist, int ist_index,
1180 AVOutputStream **ost_table, int nb_ostreams,
1181 const AVPacket *pkt)
1183 AVFormatContext *os;
1184 AVOutputStream *ost;
1187 int data_size, got_picture;
1189 void *buffer_to_free;
1190 static unsigned int samples_size= 0;
1191 AVSubtitle subtitle, *subtitle_to_free;
1195 if(ist->next_pts == AV_NOPTS_VALUE)
1196 ist->next_pts= ist->pts;
1200 av_init_packet(&avpkt);
1208 if(pkt->dts != AV_NOPTS_VALUE)
1209 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1211 //while we have more to decode or while the decoder did output something on EOF
1212 while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1214 ist->pts= ist->next_pts;
1216 if(avpkt.size && avpkt.size != pkt->size && verbose>0)
1217 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1219 /* decode the packet if needed */
1220 data_buf = NULL; /* fail safe */
1222 subtitle_to_free = NULL;
1223 if (ist->decoding_needed) {
1224 switch(ist->st->codec->codec_type) {
1225 case CODEC_TYPE_AUDIO:{
1226 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1227 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1229 samples= av_malloc(samples_size);
1231 data_size= samples_size;
1232 /* XXX: could avoid copy if PCM 16 bits with same
1233 endianness as CPU */
1234 ret = avcodec_decode_audio3(ist->st->codec, samples, &data_size,
1240 /* Some bug in mpeg audio decoder gives */
1241 /* data_size < 0, it seems they are overflows */
1242 if (data_size <= 0) {
1243 /* no audio frame */
1246 data_buf = (uint8_t *)samples;
1247 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1248 (ist->st->codec->sample_rate * ist->st->codec->channels);
1250 case CODEC_TYPE_VIDEO:
1251 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1252 /* XXX: allocate picture correctly */
1253 avcodec_get_frame_defaults(&picture);
1255 ret = avcodec_decode_video2(ist->st->codec,
1256 &picture, &got_picture, &avpkt);
1257 ist->st->quality= picture.quality;
1261 /* no picture yet */
1262 goto discard_packet;
1264 if (ist->st->codec->time_base.num != 0) {
1265 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1266 ist->next_pts += ((int64_t)AV_TIME_BASE *
1267 ist->st->codec->time_base.num * ticks) /
1268 ist->st->codec->time_base.den;
1272 case CODEC_TYPE_SUBTITLE:
1273 ret = avcodec_decode_subtitle2(ist->st->codec,
1274 &subtitle, &got_subtitle, &avpkt);
1277 if (!got_subtitle) {
1278 goto discard_packet;
1280 subtitle_to_free = &subtitle;
1287 switch(ist->st->codec->codec_type) {
1288 case CODEC_TYPE_AUDIO:
1289 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1290 ist->st->codec->sample_rate;
1292 case CODEC_TYPE_VIDEO:
1293 if (ist->st->codec->time_base.num != 0) {
1294 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1295 ist->next_pts += ((int64_t)AV_TIME_BASE *
1296 ist->st->codec->time_base.num * ticks) /
1297 ist->st->codec->time_base.den;
1301 data_buf = avpkt.data;
1302 data_size = avpkt.size;
1307 buffer_to_free = NULL;
1308 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1309 pre_process_video_frame(ist, (AVPicture *)&picture,
1313 // preprocess audio (volume)
1314 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1315 if (audio_volume != 256) {
1318 for(i=0;i<(data_size / sizeof(short));i++) {
1319 int v = ((*volp) * audio_volume + 128) >> 8;
1320 if (v < -32768) v = -32768;
1321 if (v > 32767) v = 32767;
1327 /* frame rate emulation */
1329 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1330 int64_t now = av_gettime() - ist->start;
1335 /* if output time reached then transcode raw format,
1336 encode packets and output them */
1337 if (start_time == 0 || ist->pts >= start_time)
1338 for(i=0;i<nb_ostreams;i++) {
1342 if (ost->source_index == ist_index) {
1343 os = output_files[ost->file_index];
1346 printf("%d: got pts=%0.3f %0.3f\n", i,
1347 (double)pkt->pts / AV_TIME_BASE,
1348 ((double)ist->pts / AV_TIME_BASE) -
1349 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1351 /* set the input output pts pairs */
1352 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1354 if (ost->encoding_needed) {
1355 switch(ost->st->codec->codec_type) {
1356 case CODEC_TYPE_AUDIO:
1357 do_audio_out(os, ost, ist, data_buf, data_size);
1359 case CODEC_TYPE_VIDEO:
1360 do_video_out(os, ost, ist, &picture, &frame_size);
1361 if (vstats_filename && frame_size)
1362 do_video_stats(os, ost, frame_size);
1364 case CODEC_TYPE_SUBTITLE:
1365 do_subtitle_out(os, ost, ist, &subtitle,
1372 AVFrame avframe; //FIXME/XXX remove this
1374 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1376 av_init_packet(&opkt);
1378 if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1381 /* no reencoding needed : output the packet directly */
1382 /* force the input stream PTS */
1384 avcodec_get_frame_defaults(&avframe);
1385 ost->st->codec->coded_frame= &avframe;
1386 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1388 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1389 audio_size += data_size;
1390 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1391 video_size += data_size;
1395 opkt.stream_index= ost->index;
1396 if(pkt->pts != AV_NOPTS_VALUE)
1397 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1399 opkt.pts= AV_NOPTS_VALUE;
1401 if (pkt->dts == AV_NOPTS_VALUE)
1402 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1404 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1405 opkt.dts -= ost_tb_start_time;
1407 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1408 opkt.flags= pkt->flags;
1410 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1411 if(ost->st->codec->codec_id != CODEC_ID_H264) {
1412 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1413 opkt.destruct= av_destruct_packet;
1415 opkt.data = data_buf;
1416 opkt.size = data_size;
1419 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1420 ost->st->codec->frame_number++;
1421 ost->frame_number++;
1422 av_free_packet(&opkt);
1426 av_free(buffer_to_free);
1427 /* XXX: allocate the subtitles in the codec ? */
1428 if (subtitle_to_free) {
1429 if (subtitle_to_free->rects != NULL) {
1430 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1431 av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1432 av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1433 av_freep(&subtitle_to_free->rects[i]);
1435 av_freep(&subtitle_to_free->rects);
1437 subtitle_to_free->num_rects = 0;
1438 subtitle_to_free = NULL;
1445 for(i=0;i<nb_ostreams;i++) {
1447 if (ost->source_index == ist_index) {
1448 AVCodecContext *enc= ost->st->codec;
1449 os = output_files[ost->file_index];
1451 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1453 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1456 if (ost->encoding_needed) {
1460 av_init_packet(&pkt);
1461 pkt.stream_index= ost->index;
1463 switch(ost->st->codec->codec_type) {
1464 case CODEC_TYPE_AUDIO:
1465 fifo_bytes = av_fifo_size(ost->fifo);
1467 /* encode any samples remaining in fifo */
1468 if (fifo_bytes > 0) {
1469 int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
1470 int fs_tmp = enc->frame_size;
1472 av_fifo_generic_read(ost->fifo, samples, fifo_bytes, NULL);
1473 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1474 enc->frame_size = fifo_bytes / (osize * enc->channels);
1476 int frame_bytes = enc->frame_size*osize*enc->channels;
1477 if (samples_size < frame_bytes)
1479 memset((uint8_t*)samples+fifo_bytes, 0, frame_bytes - fifo_bytes);
1482 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1483 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1484 ost->st->time_base.num, enc->sample_rate);
1485 enc->frame_size = fs_tmp;
1488 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1491 fprintf(stderr, "Audio encoding failed\n");
1495 pkt.flags |= PKT_FLAG_KEY;
1497 case CODEC_TYPE_VIDEO:
1498 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1500 fprintf(stderr, "Video encoding failed\n");
1504 if(enc->coded_frame && enc->coded_frame->key_frame)
1505 pkt.flags |= PKT_FLAG_KEY;
1506 if (ost->logfile && enc->stats_out) {
1507 fprintf(ost->logfile, "%s", enc->stats_out);
1516 pkt.data= bit_buffer;
1518 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1519 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1520 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1532 static void print_sdp(AVFormatContext **avc, int n)
1536 avf_sdp_create(avc, n, sdp, sizeof(sdp));
1537 printf("SDP:\n%s\n", sdp);
1541 static int stream_index_from_inputs(AVFormatContext **input_files,
1543 AVInputFile *file_table,
1544 AVInputStream **ist_table,
1545 enum CodecType type,
1549 for(z=0; z<nb_input_files; z++) {
1550 AVFormatContext *ic = input_files[z];
1551 for(p=0; p<ic->nb_programs; p++) {
1552 AVProgram *program = ic->programs[p];
1553 if(program->id != programid)
1555 for(q=0; q<program->nb_stream_indexes; q++) {
1556 int sidx = program->stream_index[q];
1557 int ris = file_table[z].ist_index + sidx;
1558 if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1568 * The following code is the main loop of the file converter
1570 static int av_encode(AVFormatContext **output_files,
1571 int nb_output_files,
1572 AVFormatContext **input_files,
1574 AVStreamMap *stream_maps, int nb_stream_maps)
1576 int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1577 AVFormatContext *is, *os;
1578 AVCodecContext *codec, *icodec;
1579 AVOutputStream *ost, **ost_table = NULL;
1580 AVInputStream *ist, **ist_table = NULL;
1581 AVInputFile *file_table;
1585 uint8_t no_packet[MAX_FILES]={0};
1586 int no_packet_count=0;
1588 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1592 /* input stream init */
1594 for(i=0;i<nb_input_files;i++) {
1595 is = input_files[i];
1596 file_table[i].ist_index = j;
1597 file_table[i].nb_streams = is->nb_streams;
1598 j += is->nb_streams;
1602 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1606 for(i=0;i<nb_istreams;i++) {
1607 ist = av_mallocz(sizeof(AVInputStream));
1613 for(i=0;i<nb_input_files;i++) {
1614 is = input_files[i];
1615 for(k=0;k<is->nb_streams;k++) {
1616 ist = ist_table[j++];
1617 ist->st = is->streams[k];
1618 ist->file_index = i;
1620 ist->discard = 1; /* the stream is discarded by default
1624 ist->start = av_gettime();
1629 /* output stream init */
1631 for(i=0;i<nb_output_files;i++) {
1632 os = output_files[i];
1633 if (!os->nb_streams) {
1634 dump_format(output_files[i], i, output_files[i]->filename, 1);
1635 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1638 nb_ostreams += os->nb_streams;
1640 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1641 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1645 /* Sanity check the mapping args -- do the input files & streams exist? */
1646 for(i=0;i<nb_stream_maps;i++) {
1647 int fi = stream_maps[i].file_index;
1648 int si = stream_maps[i].stream_index;
1650 if (fi < 0 || fi > nb_input_files - 1 ||
1651 si < 0 || si > file_table[fi].nb_streams - 1) {
1652 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1655 fi = stream_maps[i].sync_file_index;
1656 si = stream_maps[i].sync_stream_index;
1657 if (fi < 0 || fi > nb_input_files - 1 ||
1658 si < 0 || si > file_table[fi].nb_streams - 1) {
1659 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1664 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1667 for(i=0;i<nb_ostreams;i++) {
1668 ost = av_mallocz(sizeof(AVOutputStream));
1675 for(k=0;k<nb_output_files;k++) {
1676 os = output_files[k];
1677 for(i=0;i<os->nb_streams;i++,n++) {
1680 ost->file_index = k;
1682 ost->st = os->streams[i];
1683 if (nb_stream_maps > 0) {
1684 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1685 stream_maps[n].stream_index;
1687 /* Sanity check that the stream types match */
1688 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1689 int i= ost->file_index;
1690 dump_format(output_files[i], i, output_files[i]->filename, 1);
1691 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1692 stream_maps[n].file_index, stream_maps[n].stream_index,
1693 ost->file_index, ost->index);
1700 j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1702 ost->source_index = j;
1706 /* get corresponding input stream index : we select the first one with the right type */
1708 for(j=0;j<nb_istreams;j++) {
1711 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1712 ost->source_index = j;
1720 if(! opt_programid) {
1721 /* try again and reuse existing stream */
1722 for(j=0;j<nb_istreams;j++) {
1724 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1725 ost->source_index = j;
1731 int i= ost->file_index;
1732 dump_format(output_files[i], i, output_files[i]->filename, 1);
1733 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1734 ost->file_index, ost->index);
1739 ist = ist_table[ost->source_index];
1741 ost->sync_ist = (nb_stream_maps > 0) ?
1742 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
1743 stream_maps[n].sync_stream_index] : ist;
1747 /* for each output stream, we compute the right encoding parameters */
1748 for(i=0;i<nb_ostreams;i++) {
1749 AVMetadataTag *lang;
1751 os = output_files[ost->file_index];
1752 ist = ist_table[ost->source_index];
1754 codec = ost->st->codec;
1755 icodec = ist->st->codec;
1757 if ((lang=av_metadata_get(ist->st->metadata, "language", NULL, 0))
1758 && !av_metadata_get(ost->st->metadata, "language", NULL, 0))
1759 av_metadata_set(&ost->st->metadata, "language", lang->value);
1761 ost->st->disposition = ist->st->disposition;
1762 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1763 codec->chroma_sample_location = icodec->chroma_sample_location;
1765 if (ost->st->stream_copy) {
1766 /* if stream_copy is selected, no need to decode or encode */
1767 codec->codec_id = icodec->codec_id;
1768 codec->codec_type = icodec->codec_type;
1770 if(!codec->codec_tag){
1771 if( !os->oformat->codec_tag
1772 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1773 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1774 codec->codec_tag = icodec->codec_tag;
1777 codec->bit_rate = icodec->bit_rate;
1778 codec->extradata= icodec->extradata;
1779 codec->extradata_size= icodec->extradata_size;
1780 if(av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000){
1781 codec->time_base = icodec->time_base;
1782 codec->time_base.num *= icodec->ticks_per_frame;
1784 codec->time_base = ist->st->time_base;
1785 switch(codec->codec_type) {
1786 case CODEC_TYPE_AUDIO:
1787 if(audio_volume != 256) {
1788 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1791 codec->channel_layout = icodec->channel_layout;
1792 codec->sample_rate = icodec->sample_rate;
1793 codec->channels = icodec->channels;
1794 codec->frame_size = icodec->frame_size;
1795 codec->block_align= icodec->block_align;
1796 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1797 codec->block_align= 0;
1798 if(codec->codec_id == CODEC_ID_AC3)
1799 codec->block_align= 0;
1801 case CODEC_TYPE_VIDEO:
1802 codec->pix_fmt = icodec->pix_fmt;
1803 codec->width = icodec->width;
1804 codec->height = icodec->height;
1805 codec->has_b_frames = icodec->has_b_frames;
1807 case CODEC_TYPE_SUBTITLE:
1808 codec->width = icodec->width;
1809 codec->height = icodec->height;
1815 switch(codec->codec_type) {
1816 case CODEC_TYPE_AUDIO:
1817 ost->fifo= av_fifo_alloc(1024);
1820 ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
1821 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1822 icodec->request_channels = codec->channels;
1823 ist->decoding_needed = 1;
1824 ost->encoding_needed = 1;
1826 case CODEC_TYPE_VIDEO:
1827 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
1828 fprintf(stderr, "Video pixel format is unknown, stream cannot be decoded\n");
1831 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1832 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1833 ost->video_resample = ((codec->width != icodec->width -
1834 (frame_leftBand + frame_rightBand) +
1835 (frame_padleft + frame_padright)) ||
1836 (codec->height != icodec->height -
1837 (frame_topBand + frame_bottomBand) +
1838 (frame_padtop + frame_padbottom)) ||
1839 (codec->pix_fmt != icodec->pix_fmt));
1840 if (ost->video_crop) {
1841 ost->topBand = frame_topBand;
1842 ost->leftBand = frame_leftBand;
1844 if (ost->video_pad) {
1845 ost->padtop = frame_padtop;
1846 ost->padleft = frame_padleft;
1847 ost->padbottom = frame_padbottom;
1848 ost->padright = frame_padright;
1849 if (!ost->video_resample) {
1850 avcodec_get_frame_defaults(&ost->pict_tmp);
1851 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1852 codec->width, codec->height))
1856 if (ost->video_resample) {
1857 avcodec_get_frame_defaults(&ost->pict_tmp);
1858 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1859 codec->width, codec->height)) {
1860 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1863 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1864 ost->img_resample_ctx = sws_getContext(
1865 icodec->width - (frame_leftBand + frame_rightBand),
1866 icodec->height - (frame_topBand + frame_bottomBand),
1868 codec->width - (frame_padleft + frame_padright),
1869 codec->height - (frame_padtop + frame_padbottom),
1871 sws_flags, NULL, NULL, NULL);
1872 if (ost->img_resample_ctx == NULL) {
1873 fprintf(stderr, "Cannot get resampling context\n");
1876 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1877 codec->bits_per_raw_sample= 0;
1879 ost->encoding_needed = 1;
1880 ist->decoding_needed = 1;
1882 case CODEC_TYPE_SUBTITLE:
1883 ost->encoding_needed = 1;
1884 ist->decoding_needed = 1;
1891 if (ost->encoding_needed &&
1892 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1893 char logfilename[1024];
1898 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1899 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
1901 if (codec->flags & CODEC_FLAG_PASS1) {
1902 f = fopen(logfilename, "w");
1904 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
1909 /* read the log file */
1910 f = fopen(logfilename, "r");
1912 fprintf(stderr, "Cannot read log file '%s' for pass-2 encoding: %s\n", logfilename, strerror(errno));
1915 fseek(f, 0, SEEK_END);
1917 fseek(f, 0, SEEK_SET);
1918 logbuffer = av_malloc(size + 1);
1920 fprintf(stderr, "Could not allocate log buffer\n");
1923 size = fread(logbuffer, 1, size, f);
1925 logbuffer[size] = '\0';
1926 codec->stats_in = logbuffer;
1930 if(codec->codec_type == CODEC_TYPE_VIDEO){
1931 int size= codec->width * codec->height;
1932 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
1937 bit_buffer = av_malloc(bit_buffer_size);
1939 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
1941 ret = AVERROR(ENOMEM);
1945 /* open each encoder */
1946 for(i=0;i<nb_ostreams;i++) {
1948 if (ost->encoding_needed) {
1949 AVCodec *codec = output_codecs[i];
1951 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1953 snprintf(error, sizeof(error), "Unsupported codec for output stream #%d.%d",
1954 ost->file_index, ost->index);
1955 ret = AVERROR(EINVAL);
1958 if (avcodec_open(ost->st->codec, codec) < 0) {
1959 snprintf(error, sizeof(error), "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
1960 ost->file_index, ost->index);
1961 ret = AVERROR(EINVAL);
1964 extra_size += ost->st->codec->extradata_size;
1968 /* open each decoder */
1969 for(i=0;i<nb_istreams;i++) {
1971 if (ist->decoding_needed) {
1972 AVCodec *codec = input_codecs[i];
1974 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1976 snprintf(error, sizeof(error), "Unsupported codec (id=%d) for input stream #%d.%d",
1977 ist->st->codec->codec_id, ist->file_index, ist->index);
1978 ret = AVERROR(EINVAL);
1981 if (avcodec_open(ist->st->codec, codec) < 0) {
1982 snprintf(error, sizeof(error), "Error while opening codec for input stream #%d.%d",
1983 ist->file_index, ist->index);
1984 ret = AVERROR(EINVAL);
1987 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1988 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1993 for(i=0;i<nb_istreams;i++) {
1996 ist->next_pts = AV_NOPTS_VALUE;
2000 /* set meta data information from input file if required */
2001 for (i=0;i<nb_meta_data_maps;i++) {
2002 AVFormatContext *out_file;
2003 AVFormatContext *in_file;
2004 AVMetadataTag *mtag;
2006 int out_file_index = meta_data_maps[i].out_file;
2007 int in_file_index = meta_data_maps[i].in_file;
2008 if (out_file_index < 0 || out_file_index >= nb_output_files) {
2009 snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
2010 out_file_index, out_file_index, in_file_index);
2011 ret = AVERROR(EINVAL);
2014 if (in_file_index < 0 || in_file_index >= nb_input_files) {
2015 snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
2016 in_file_index, out_file_index, in_file_index);
2017 ret = AVERROR(EINVAL);
2021 out_file = output_files[out_file_index];
2022 in_file = input_files[in_file_index];
2026 while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2027 av_metadata_set(&out_file->metadata, mtag->key, mtag->value);
2028 av_metadata_conv(out_file, out_file->oformat->metadata_conv,
2029 in_file->iformat->metadata_conv);
2032 /* open files and write file headers */
2033 for(i=0;i<nb_output_files;i++) {
2034 os = output_files[i];
2035 if (av_write_header(os) < 0) {
2036 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2037 ret = AVERROR(EINVAL);
2040 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2046 /* dump the file output parameters - cannot be done before in case
2048 for(i=0;i<nb_output_files;i++) {
2049 dump_format(output_files[i], i, output_files[i]->filename, 1);
2052 /* dump the stream mapping */
2054 fprintf(stderr, "Stream mapping:\n");
2055 for(i=0;i<nb_ostreams;i++) {
2057 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2058 ist_table[ost->source_index]->file_index,
2059 ist_table[ost->source_index]->index,
2062 if (ost->sync_ist != ist_table[ost->source_index])
2063 fprintf(stderr, " [sync #%d.%d]",
2064 ost->sync_ist->file_index,
2065 ost->sync_ist->index);
2066 fprintf(stderr, "\n");
2071 fprintf(stderr, "%s\n", error);
2076 print_sdp(output_files, nb_output_files);
2079 if (!using_stdin && verbose >= 0) {
2080 fprintf(stderr, "Press [q] to stop encoding\n");
2081 url_set_interrupt_cb(decode_interrupt_cb);
2085 timer_start = av_gettime();
2087 for(; received_sigterm == 0;) {
2088 int file_index, ist_index;
2096 /* if 'q' pressed, exits */
2100 /* read_key() returns 0 on EOF */
2106 /* select the stream that we must read now by looking at the
2107 smallest output pts */
2109 for(i=0;i<nb_ostreams;i++) {
2112 os = output_files[ost->file_index];
2113 ist = ist_table[ost->source_index];
2114 if(no_packet[ist->file_index])
2116 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2117 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2119 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2120 ipts = (double)ist->pts;
2121 if (!file_table[ist->file_index].eof_reached){
2122 if(ipts < ipts_min) {
2124 if(input_sync ) file_index = ist->file_index;
2126 if(opts < opts_min) {
2128 if(!input_sync) file_index = ist->file_index;
2131 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2136 /* if none, if is finished */
2137 if (file_index < 0) {
2138 if(no_packet_count){
2140 memset(no_packet, 0, sizeof(no_packet));
2147 /* finish if recording time exhausted */
2148 if (opts_min >= (recording_time / 1000000.0))
2151 /* finish if limit size exhausted */
2152 if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2155 /* read a frame from it and output it in the fifo */
2156 is = input_files[file_index];
2157 ret= av_read_frame(is, &pkt);
2158 if(ret == AVERROR(EAGAIN)){
2159 no_packet[file_index]=1;
2164 file_table[file_index].eof_reached = 1;
2172 memset(no_packet, 0, sizeof(no_packet));
2175 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2177 /* the following test is needed in case new streams appear
2178 dynamically in stream : we ignore them */
2179 if (pkt.stream_index >= file_table[file_index].nb_streams)
2180 goto discard_packet;
2181 ist_index = file_table[file_index].ist_index + pkt.stream_index;
2182 ist = ist_table[ist_index];
2184 goto discard_packet;
2186 if (pkt.dts != AV_NOPTS_VALUE)
2187 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2188 if (pkt.pts != AV_NOPTS_VALUE)
2189 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2191 if(input_files_ts_scale[file_index][pkt.stream_index]){
2192 if(pkt.pts != AV_NOPTS_VALUE)
2193 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2194 if(pkt.dts != AV_NOPTS_VALUE)
2195 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2198 // 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);
2199 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2200 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2201 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2202 int64_t delta= pkt_dts - ist->next_pts;
2203 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2204 input_files_ts_offset[ist->file_index]-= delta;
2206 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2207 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2208 if(pkt.pts != AV_NOPTS_VALUE)
2209 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2213 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2214 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2217 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2218 ist->file_index, ist->index);
2221 av_free_packet(&pkt);
2226 av_free_packet(&pkt);
2228 /* dump report by using the output first video and audio streams */
2229 print_report(output_files, ost_table, nb_ostreams, 0);
2232 /* at the end of stream, we must flush the decoder buffers */
2233 for(i=0;i<nb_istreams;i++) {
2235 if (ist->decoding_needed) {
2236 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2242 /* write the trailer if needed and close file */
2243 for(i=0;i<nb_output_files;i++) {
2244 os = output_files[i];
2245 av_write_trailer(os);
2248 /* dump report by using the first video and audio streams */
2249 print_report(output_files, ost_table, nb_ostreams, 1);
2251 /* close each encoder */
2252 for(i=0;i<nb_ostreams;i++) {
2254 if (ost->encoding_needed) {
2255 av_freep(&ost->st->codec->stats_in);
2256 avcodec_close(ost->st->codec);
2260 /* close each decoder */
2261 for(i=0;i<nb_istreams;i++) {
2263 if (ist->decoding_needed) {
2264 avcodec_close(ist->st->codec);
2272 av_freep(&bit_buffer);
2273 av_free(file_table);
2276 for(i=0;i<nb_istreams;i++) {
2283 for(i=0;i<nb_ostreams;i++) {
2287 fclose(ost->logfile);
2288 ost->logfile = NULL;
2290 av_fifo_free(ost->fifo); /* works even if fifo is not
2291 initialized but set to zero */
2292 av_free(ost->pict_tmp.data[0]);
2293 if (ost->video_resample)
2294 sws_freeContext(ost->img_resample_ctx);
2296 audio_resample_close(ost->resample);
2297 if (ost->reformat_ctx)
2298 av_audio_convert_free(ost->reformat_ctx);
2308 int file_read(const char *filename)
2311 unsigned char buffer[1024];
2314 if (url_open(&h, filename, O_RDONLY) < 0) {
2315 printf("could not open '%s'\n", filename);
2319 len = url_read(h, buffer, sizeof(buffer));
2322 for(i=0;i<len;i++) putchar(buffer[i]);
2329 static void opt_format(const char *arg)
2331 /* compatibility stuff for pgmyuv */
2332 if (!strcmp(arg, "pgmyuv")) {
2333 pgmyuv_compatibility_hack=1;
2334 // opt_image_format(arg);
2336 fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2339 file_iformat = av_find_input_format(arg);
2340 file_oformat = guess_format(arg, NULL, NULL);
2341 if (!file_iformat && !file_oformat) {
2342 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2347 static void opt_video_rc_override_string(const char *arg)
2349 video_rc_override_string = arg;
2352 static int opt_me_threshold(const char *opt, const char *arg)
2354 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2358 static int opt_verbose(const char *opt, const char *arg)
2360 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2364 static int opt_frame_rate(const char *opt, const char *arg)
2366 if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2367 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2373 static int opt_bitrate(const char *opt, const char *arg)
2375 int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2377 opt_default(opt, arg);
2379 if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2380 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2385 static void opt_frame_crop_top(const char *arg)
2387 frame_topBand = atoi(arg);
2388 if (frame_topBand < 0) {
2389 fprintf(stderr, "Incorrect top crop size\n");
2392 if ((frame_topBand) >= frame_height){
2393 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2396 frame_height -= frame_topBand;
2399 static void opt_frame_crop_bottom(const char *arg)
2401 frame_bottomBand = atoi(arg);
2402 if (frame_bottomBand < 0) {
2403 fprintf(stderr, "Incorrect bottom crop size\n");
2406 if ((frame_bottomBand) >= frame_height){
2407 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2410 frame_height -= frame_bottomBand;
2413 static void opt_frame_crop_left(const char *arg)
2415 frame_leftBand = atoi(arg);
2416 if (frame_leftBand < 0) {
2417 fprintf(stderr, "Incorrect left crop size\n");
2420 if ((frame_leftBand) >= frame_width){
2421 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2424 frame_width -= frame_leftBand;
2427 static void opt_frame_crop_right(const char *arg)
2429 frame_rightBand = atoi(arg);
2430 if (frame_rightBand < 0) {
2431 fprintf(stderr, "Incorrect right crop size\n");
2434 if ((frame_rightBand) >= frame_width){
2435 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2438 frame_width -= frame_rightBand;
2441 static void opt_frame_size(const char *arg)
2443 if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2444 fprintf(stderr, "Incorrect frame size\n");
2447 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2448 fprintf(stderr, "Frame size must be a multiple of 2\n");
2453 static void opt_pad_color(const char *arg) {
2454 /* Input is expected to be six hex digits similar to
2455 how colors are expressed in html tags (but without the #) */
2456 int rgb = strtol(arg, NULL, 16);
2460 g = ((rgb >> 8) & 255);
2463 padcolor[0] = RGB_TO_Y(r,g,b);
2464 padcolor[1] = RGB_TO_U(r,g,b,0);
2465 padcolor[2] = RGB_TO_V(r,g,b,0);
2468 static void opt_frame_pad_top(const char *arg)
2470 frame_padtop = atoi(arg);
2471 if (frame_padtop < 0) {
2472 fprintf(stderr, "Incorrect top pad size\n");
2477 static void opt_frame_pad_bottom(const char *arg)
2479 frame_padbottom = atoi(arg);
2480 if (frame_padbottom < 0) {
2481 fprintf(stderr, "Incorrect bottom pad size\n");
2487 static void opt_frame_pad_left(const char *arg)
2489 frame_padleft = atoi(arg);
2490 if (frame_padleft < 0) {
2491 fprintf(stderr, "Incorrect left pad size\n");
2497 static void opt_frame_pad_right(const char *arg)
2499 frame_padright = atoi(arg);
2500 if (frame_padright < 0) {
2501 fprintf(stderr, "Incorrect right pad size\n");
2506 static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2510 for (i=-1; i < nb_fmts; i++) {
2511 get_fmt_string (fmt_str, sizeof(fmt_str), i);
2512 fprintf(stdout, "%s\n", fmt_str);
2516 static void opt_frame_pix_fmt(const char *arg)
2518 if (strcmp(arg, "list")) {
2519 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2520 if (frame_pix_fmt == PIX_FMT_NONE) {
2521 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2525 list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2530 static void opt_frame_aspect_ratio(const char *arg)
2537 p = strchr(arg, ':');
2539 x = strtol(arg, &end, 10);
2541 y = strtol(end+1, &end, 10);
2543 ar = (double)x / (double)y;
2545 ar = strtod(arg, NULL);
2548 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2551 frame_aspect_ratio = ar;
2554 static int opt_metadata(const char *opt, const char *arg)
2556 char *mid= strchr(arg, '=');
2559 fprintf(stderr, "Missing =\n");
2565 metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2566 metadata[metadata_count-1].key = av_strdup(arg);
2567 metadata[metadata_count-1].value= av_strdup(mid);
2572 static void opt_qscale(const char *arg)
2574 video_qscale = atof(arg);
2575 if (video_qscale <= 0 ||
2576 video_qscale > 255) {
2577 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2582 static void opt_top_field_first(const char *arg)
2584 top_field_first= atoi(arg);
2587 static int opt_thread_count(const char *opt, const char *arg)
2589 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2592 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2597 static void opt_audio_sample_fmt(const char *arg)
2599 if (strcmp(arg, "list"))
2600 audio_sample_fmt = avcodec_get_sample_fmt(arg);
2602 list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2607 static int opt_audio_rate(const char *opt, const char *arg)
2609 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2613 static int opt_audio_channels(const char *opt, const char *arg)
2615 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2619 static void opt_video_channel(const char *arg)
2621 video_channel = strtol(arg, NULL, 0);
2624 static void opt_video_standard(const char *arg)
2626 video_standard = av_strdup(arg);
2629 static void opt_codec(int *pstream_copy, char **pcodec_name,
2630 int codec_type, const char *arg)
2632 av_freep(pcodec_name);
2633 if (!strcmp(arg, "copy")) {
2636 *pcodec_name = av_strdup(arg);
2640 static void opt_audio_codec(const char *arg)
2642 opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2645 static void opt_audio_tag(const char *arg)
2648 audio_codec_tag= strtol(arg, &tail, 0);
2651 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2654 static void opt_video_tag(const char *arg)
2657 video_codec_tag= strtol(arg, &tail, 0);
2660 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2663 static void opt_video_codec(const char *arg)
2665 opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2668 static void opt_subtitle_codec(const char *arg)
2670 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2673 static void opt_subtitle_tag(const char *arg)
2676 subtitle_codec_tag= strtol(arg, &tail, 0);
2679 subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2682 static void opt_map(const char *arg)
2687 m = &stream_maps[nb_stream_maps++];
2689 m->file_index = strtol(arg, &p, 0);
2693 m->stream_index = strtol(p, &p, 0);
2696 m->sync_file_index = strtol(p, &p, 0);
2699 m->sync_stream_index = strtol(p, &p, 0);
2701 m->sync_file_index = m->file_index;
2702 m->sync_stream_index = m->stream_index;
2706 static void opt_map_meta_data(const char *arg)
2711 m = &meta_data_maps[nb_meta_data_maps++];
2713 m->out_file = strtol(arg, &p, 0);
2717 m->in_file = strtol(p, &p, 0);
2720 static void opt_input_ts_scale(const char *arg)
2722 unsigned int stream;
2726 stream = strtol(arg, &p, 0);
2729 scale= strtod(p, &p);
2731 if(stream >= MAX_STREAMS)
2734 input_files_ts_scale[nb_input_files][stream]= scale;
2737 static int opt_recording_time(const char *opt, const char *arg)
2739 recording_time = parse_time_or_die(opt, arg, 1);
2743 static int opt_start_time(const char *opt, const char *arg)
2745 start_time = parse_time_or_die(opt, arg, 1);
2749 static int opt_rec_timestamp(const char *opt, const char *arg)
2751 rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2755 static int opt_input_ts_offset(const char *opt, const char *arg)
2757 input_ts_offset = parse_time_or_die(opt, arg, 1);
2761 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2763 const char *codec_string = encoder ? "encoder" : "decoder";
2767 return CODEC_ID_NONE;
2769 avcodec_find_encoder_by_name(name) :
2770 avcodec_find_decoder_by_name(name);
2772 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2775 if(codec->type != type) {
2776 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2782 static void opt_input_file(const char *filename)
2784 AVFormatContext *ic;
2785 AVFormatParameters params, *ap = ¶ms;
2786 int err, i, ret, rfps, rfps_base;
2789 if (!strcmp(filename, "-"))
2792 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2793 !strcmp(filename, "/dev/stdin");
2795 /* get default parameters from command line */
2796 ic = avformat_alloc_context();
2798 memset(ap, 0, sizeof(*ap));
2799 ap->prealloced_context = 1;
2800 ap->sample_rate = audio_sample_rate;
2801 ap->channels = audio_channels;
2802 ap->time_base.den = frame_rate.num;
2803 ap->time_base.num = frame_rate.den;
2804 ap->width = frame_width + frame_padleft + frame_padright;
2805 ap->height = frame_height + frame_padtop + frame_padbottom;
2806 ap->pix_fmt = frame_pix_fmt;
2807 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2808 ap->channel = video_channel;
2809 ap->standard = video_standard;
2810 ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2811 ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2812 if(pgmyuv_compatibility_hack)
2813 ap->video_codec_id= CODEC_ID_PGMYUV;
2815 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2817 ic->video_codec_id = find_codec_or_die(video_codec_name , CODEC_TYPE_VIDEO , 0);
2818 ic->audio_codec_id = find_codec_or_die(audio_codec_name , CODEC_TYPE_AUDIO , 0);
2819 ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2820 ic->flags |= AVFMT_FLAG_NONBLOCK;
2822 /* open the input file with generic libav function */
2823 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2825 print_error(filename, err);
2830 for(i=0; i<ic->nb_programs; i++)
2831 if(ic->programs[i]->id != opt_programid)
2832 ic->programs[i]->discard = AVDISCARD_ALL;
2835 ic->loop_input = loop_input;
2837 /* If not enough info to get the stream parameters, we decode the
2838 first frames to get it. (used in mpeg case for example) */
2839 ret = av_find_stream_info(ic);
2840 if (ret < 0 && verbose >= 0) {
2841 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2845 timestamp = start_time;
2846 /* add the stream start time */
2847 if (ic->start_time != AV_NOPTS_VALUE)
2848 timestamp += ic->start_time;
2850 /* if seeking requested, we execute it */
2851 if (start_time != 0) {
2852 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2854 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2855 filename, (double)timestamp / AV_TIME_BASE);
2857 /* reset seek info */
2861 /* update the current parameters so that they match the one of the input stream */
2862 for(i=0;i<ic->nb_streams;i++) {
2863 AVCodecContext *enc = ic->streams[i]->codec;
2865 avcodec_thread_init(enc, thread_count);
2866 enc->thread_count= thread_count;
2867 switch(enc->codec_type) {
2868 case CODEC_TYPE_AUDIO:
2869 set_context_opts(enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2870 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2871 channel_layout = enc->channel_layout;
2872 audio_channels = enc->channels;
2873 audio_sample_rate = enc->sample_rate;
2874 audio_sample_fmt = enc->sample_fmt;
2875 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
2877 ic->streams[i]->discard= AVDISCARD_ALL;
2879 case CODEC_TYPE_VIDEO:
2880 set_context_opts(enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2881 frame_height = enc->height;
2882 frame_width = enc->width;
2883 if(ic->streams[i]->sample_aspect_ratio.num)
2884 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
2886 frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
2887 frame_aspect_ratio *= (float) enc->width / enc->height;
2888 frame_pix_fmt = enc->pix_fmt;
2889 rfps = ic->streams[i]->r_frame_rate.num;
2890 rfps_base = ic->streams[i]->r_frame_rate.den;
2891 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2893 enc->debug |= FF_DEBUG_MV;
2895 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2898 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2899 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2901 (float)rfps / rfps_base, rfps, rfps_base);
2903 /* update the current frame rate to match the stream frame rate */
2904 frame_rate.num = rfps;
2905 frame_rate.den = rfps_base;
2907 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2909 ic->streams[i]->discard= AVDISCARD_ALL;
2910 else if(video_discard)
2911 ic->streams[i]->discard= video_discard;
2913 case CODEC_TYPE_DATA:
2915 case CODEC_TYPE_SUBTITLE:
2916 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
2917 if(subtitle_disable)
2918 ic->streams[i]->discard = AVDISCARD_ALL;
2920 case CODEC_TYPE_ATTACHMENT:
2921 case CODEC_TYPE_UNKNOWN:
2929 input_files[nb_input_files] = ic;
2930 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2931 /* dump the file content */
2933 dump_format(ic, nb_input_files, filename, 0);
2936 file_iformat = NULL;
2937 file_oformat = NULL;
2941 av_freep(&video_codec_name);
2942 av_freep(&audio_codec_name);
2943 av_freep(&subtitle_codec_name);
2946 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2947 int *has_subtitle_ptr)
2949 int has_video, has_audio, has_subtitle, i, j;
2950 AVFormatContext *ic;
2955 for(j=0;j<nb_input_files;j++) {
2956 ic = input_files[j];
2957 for(i=0;i<ic->nb_streams;i++) {
2958 AVCodecContext *enc = ic->streams[i]->codec;
2959 switch(enc->codec_type) {
2960 case CODEC_TYPE_AUDIO:
2963 case CODEC_TYPE_VIDEO:
2966 case CODEC_TYPE_SUBTITLE:
2969 case CODEC_TYPE_DATA:
2970 case CODEC_TYPE_ATTACHMENT:
2971 case CODEC_TYPE_UNKNOWN:
2978 *has_video_ptr = has_video;
2979 *has_audio_ptr = has_audio;
2980 *has_subtitle_ptr = has_subtitle;
2983 static void new_video_stream(AVFormatContext *oc)
2986 AVCodecContext *video_enc;
2989 st = av_new_stream(oc, oc->nb_streams);
2991 fprintf(stderr, "Could not alloc stream\n");
2994 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2995 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2996 video_bitstream_filters= NULL;
2999 avcodec_thread_init(st->codec, thread_count);
3001 video_enc = st->codec;
3004 video_enc->codec_tag= video_codec_tag;
3006 if( (video_global_header&1)
3007 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3008 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3009 avcodec_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3011 if(video_global_header&2){
3012 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3013 avcodec_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3016 if (video_stream_copy) {
3017 st->stream_copy = 1;
3018 video_enc->codec_type = CODEC_TYPE_VIDEO;
3019 video_enc->sample_aspect_ratio =
3020 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3025 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3027 if (video_codec_name) {
3028 codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3029 codec = avcodec_find_encoder_by_name(video_codec_name);
3030 output_codecs[nb_ocodecs] = codec;
3032 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3033 codec = avcodec_find_encoder(codec_id);
3036 video_enc->codec_id = codec_id;
3038 set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3040 if (codec && codec->supported_framerates && !force_fps)
3041 fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3042 video_enc->time_base.den = fps.num;
3043 video_enc->time_base.num = fps.den;
3045 video_enc->width = frame_width + frame_padright + frame_padleft;
3046 video_enc->height = frame_height + frame_padtop + frame_padbottom;
3047 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3048 video_enc->pix_fmt = frame_pix_fmt;
3049 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3051 if(codec && codec->pix_fmts){
3052 const enum PixelFormat *p= codec->pix_fmts;
3054 if(*p == video_enc->pix_fmt)
3058 video_enc->pix_fmt = codec->pix_fmts[0];
3062 video_enc->gop_size = 0;
3063 if (video_qscale || same_quality) {
3064 video_enc->flags |= CODEC_FLAG_QSCALE;
3065 video_enc->global_quality=
3066 st->quality = FF_QP2LAMBDA * video_qscale;
3070 video_enc->intra_matrix = intra_matrix;
3072 video_enc->inter_matrix = inter_matrix;
3074 video_enc->thread_count = thread_count;
3075 p= video_rc_override_string;
3078 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3080 fprintf(stderr, "error parsing rc_override\n");
3083 video_enc->rc_override=
3084 av_realloc(video_enc->rc_override,
3085 sizeof(RcOverride)*(i+1));
3086 video_enc->rc_override[i].start_frame= start;
3087 video_enc->rc_override[i].end_frame = end;
3089 video_enc->rc_override[i].qscale= q;
3090 video_enc->rc_override[i].quality_factor= 1.0;
3093 video_enc->rc_override[i].qscale= 0;
3094 video_enc->rc_override[i].quality_factor= -q/100.0;
3099 video_enc->rc_override_count=i;
3100 if (!video_enc->rc_initial_buffer_occupancy)
3101 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3102 video_enc->me_threshold= me_threshold;
3103 video_enc->intra_dc_precision= intra_dc_precision - 8;
3106 video_enc->flags|= CODEC_FLAG_PSNR;
3111 video_enc->flags |= CODEC_FLAG_PASS1;
3113 video_enc->flags |= CODEC_FLAG_PASS2;
3119 /* reset some key parameters */
3121 av_freep(&video_codec_name);
3122 video_stream_copy = 0;
3125 static void new_audio_stream(AVFormatContext *oc)
3128 AVCodecContext *audio_enc;
3131 st = av_new_stream(oc, oc->nb_streams);
3133 fprintf(stderr, "Could not alloc stream\n");
3136 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3138 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3139 audio_bitstream_filters= NULL;
3142 avcodec_thread_init(st->codec, thread_count);
3144 audio_enc = st->codec;
3145 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3148 audio_enc->codec_tag= audio_codec_tag;
3150 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3151 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3152 avcodec_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3154 if (audio_stream_copy) {
3155 st->stream_copy = 1;
3156 audio_enc->channels = audio_channels;
3160 set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3162 if (audio_codec_name) {
3163 codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3164 codec = avcodec_find_encoder_by_name(audio_codec_name);
3165 output_codecs[nb_ocodecs] = codec;
3167 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3168 codec = avcodec_find_encoder(codec_id);
3170 audio_enc->codec_id = codec_id;
3172 if (audio_qscale > QSCALE_NONE) {
3173 audio_enc->flags |= CODEC_FLAG_QSCALE;
3174 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3176 audio_enc->thread_count = thread_count;
3177 audio_enc->channels = audio_channels;
3178 audio_enc->sample_fmt = audio_sample_fmt;
3179 audio_enc->channel_layout = channel_layout;
3180 if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3181 audio_enc->channel_layout = 0;
3183 if(codec && codec->sample_fmts){
3184 const enum SampleFormat *p= codec->sample_fmts;
3186 if(*p == audio_enc->sample_fmt)
3190 audio_enc->sample_fmt = codec->sample_fmts[0];
3194 audio_enc->sample_rate = audio_sample_rate;
3195 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3196 if (audio_language) {
3197 av_metadata_set(&st->metadata, "language", audio_language);
3198 av_free(audio_language);
3199 audio_language = NULL;
3202 /* reset some key parameters */
3204 av_freep(&audio_codec_name);
3205 audio_stream_copy = 0;
3208 static void new_subtitle_stream(AVFormatContext *oc)
3211 AVCodecContext *subtitle_enc;
3213 st = av_new_stream(oc, oc->nb_streams);
3215 fprintf(stderr, "Could not alloc stream\n");
3218 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3220 bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3221 subtitle_bitstream_filters= NULL;
3223 subtitle_enc = st->codec;
3224 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3226 if(subtitle_codec_tag)
3227 subtitle_enc->codec_tag= subtitle_codec_tag;
3229 if (subtitle_stream_copy) {
3230 st->stream_copy = 1;
3232 set_context_opts(avcodec_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3233 subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3234 output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3238 if (subtitle_language) {
3239 av_metadata_set(&st->metadata, "language", subtitle_language);
3240 av_free(subtitle_language);
3241 subtitle_language = NULL;
3244 subtitle_disable = 0;
3245 av_freep(&subtitle_codec_name);
3246 subtitle_stream_copy = 0;
3249 static void opt_new_audio_stream(void)
3251 AVFormatContext *oc;
3252 if (nb_output_files <= 0) {
3253 fprintf(stderr, "At least one output file must be specified\n");
3256 oc = output_files[nb_output_files - 1];
3257 new_audio_stream(oc);
3260 static void opt_new_video_stream(void)
3262 AVFormatContext *oc;
3263 if (nb_output_files <= 0) {
3264 fprintf(stderr, "At least one output file must be specified\n");
3267 oc = output_files[nb_output_files - 1];
3268 new_video_stream(oc);
3271 static void opt_new_subtitle_stream(void)
3273 AVFormatContext *oc;
3274 if (nb_output_files <= 0) {
3275 fprintf(stderr, "At least one output file must be specified\n");
3278 oc = output_files[nb_output_files - 1];
3279 new_subtitle_stream(oc);
3282 static void opt_output_file(const char *filename)
3284 AVFormatContext *oc;
3285 int use_video, use_audio, use_subtitle;
3286 int input_has_video, input_has_audio, input_has_subtitle;
3287 AVFormatParameters params, *ap = ¶ms;
3289 if (!strcmp(filename, "-"))
3292 oc = avformat_alloc_context();
3294 if (!file_oformat) {
3295 file_oformat = guess_format(NULL, filename, NULL);
3296 if (!file_oformat) {
3297 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3303 oc->oformat = file_oformat;
3304 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3306 if (!strcmp(file_oformat->name, "ffm") &&
3307 av_strstart(filename, "http:", NULL)) {
3308 /* special case for files sent to ffserver: we get the stream
3309 parameters from ffserver */
3310 int err = read_ffserver_streams(oc, filename);
3312 print_error(filename, err);
3316 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3317 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3318 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3320 /* disable if no corresponding type found and at least one
3322 if (nb_input_files > 0) {
3323 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3324 &input_has_subtitle);
3325 if (!input_has_video)
3327 if (!input_has_audio)
3329 if (!input_has_subtitle)
3333 /* manual disable */
3334 if (audio_disable) {
3337 if (video_disable) {
3340 if (subtitle_disable) {
3345 new_video_stream(oc);
3349 new_audio_stream(oc);
3353 new_subtitle_stream(oc);
3356 oc->timestamp = rec_timestamp;
3358 for(; metadata_count>0; metadata_count--){
3359 av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3360 metadata[metadata_count-1].value);
3362 av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3365 output_files[nb_output_files++] = oc;
3367 /* check filename in case of an image number is expected */
3368 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3369 if (!av_filename_number_test(oc->filename)) {
3370 print_error(oc->filename, AVERROR_NUMEXPECTED);
3375 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3376 /* test if it already exists to avoid loosing precious files */
3377 if (!file_overwrite &&
3378 (strchr(filename, ':') == NULL ||
3379 filename[1] == ':' ||
3380 av_strstart(filename, "file:", NULL))) {
3381 if (url_exist(filename)) {
3383 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3385 if (!read_yesno()) {
3386 fprintf(stderr, "Not overwriting - exiting\n");
3391 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3398 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3399 fprintf(stderr, "Could not open '%s'\n", filename);
3404 memset(ap, 0, sizeof(*ap));
3405 if (av_set_parameters(oc, ap) < 0) {
3406 fprintf(stderr, "%s: Invalid encoding parameters\n",
3411 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3412 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3413 oc->loop_output = loop_output;
3414 oc->flags |= AVFMT_FLAG_NONBLOCK;
3416 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3418 /* reset some options */
3419 file_oformat = NULL;
3420 file_iformat = NULL;
3423 /* same option as mencoder */
3424 static void opt_pass(const char *pass_str)
3427 pass = atoi(pass_str);
3428 if (pass != 1 && pass != 2) {
3429 fprintf(stderr, "pass number can be only 1 or 2\n");
3435 static int64_t getutime(void)
3438 struct rusage rusage;
3440 getrusage(RUSAGE_SELF, &rusage);
3441 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3442 #elif HAVE_GETPROCESSTIMES
3444 FILETIME c, e, k, u;
3445 proc = GetCurrentProcess();
3446 GetProcessTimes(proc, &c, &e, &k, &u);
3447 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3449 return av_gettime();
3453 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3456 const char *p = str;
3463 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3470 static void opt_inter_matrix(const char *arg)
3472 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3473 parse_matrix_coeffs(inter_matrix, arg);
3476 static void opt_intra_matrix(const char *arg)
3478 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3479 parse_matrix_coeffs(intra_matrix, arg);
3483 * Trivial log callback.
3484 * Only suitable for show_help and similar since it lacks prefix handling.
3486 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3488 vfprintf(stdout, fmt, vl);
3491 static void show_help(void)
3493 av_log_set_callback(log_callback_help);
3494 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3495 "Hyper fast Audio and Video encoder\n");
3497 show_help_options(options, "Main options:\n",
3498 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3499 show_help_options(options, "\nAdvanced options:\n",
3500 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3502 show_help_options(options, "\nVideo options:\n",
3503 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3505 show_help_options(options, "\nAdvanced Video options:\n",
3506 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3507 OPT_VIDEO | OPT_EXPERT);
3508 show_help_options(options, "\nAudio options:\n",
3509 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3511 show_help_options(options, "\nAdvanced Audio options:\n",
3512 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3513 OPT_AUDIO | OPT_EXPERT);
3514 show_help_options(options, "\nSubtitle options:\n",
3515 OPT_SUBTITLE | OPT_GRAB,
3517 show_help_options(options, "\nAudio/Video grab options:\n",
3521 av_opt_show(avcodec_opts[0], NULL);
3523 av_opt_show(avformat_opts, NULL);
3525 av_opt_show(sws_opts, NULL);
3528 static void opt_target(const char *arg)
3531 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3533 if(!strncmp(arg, "pal-", 4)) {
3536 } else if(!strncmp(arg, "ntsc-", 5)) {
3539 } else if(!strncmp(arg, "film-", 5)) {
3544 /* Calculate FR via float to avoid int overflow */
3545 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3548 } else if((fr == 29970) || (fr == 23976)) {
3551 /* Try to determine PAL/NTSC by peeking in the input files */
3552 if(nb_input_files) {
3554 for(j = 0; j < nb_input_files; j++) {
3555 for(i = 0; i < input_files[j]->nb_streams; i++) {
3556 AVCodecContext *c = input_files[j]->streams[i]->codec;
3557 if(c->codec_type != CODEC_TYPE_VIDEO)
3559 fr = c->time_base.den * 1000 / c->time_base.num;
3563 } else if((fr == 29970) || (fr == 23976)) {
3573 if(verbose && norm >= 0)
3574 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3578 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3579 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3580 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3584 if(!strcmp(arg, "vcd")) {
3586 opt_video_codec("mpeg1video");
3587 opt_audio_codec("mp2");
3590 opt_frame_size(norm ? "352x240" : "352x288");
3591 opt_frame_rate(NULL, frame_rates[norm]);
3592 opt_default("gop", norm ? "18" : "15");
3594 opt_default("b", "1150000");
3595 opt_default("maxrate", "1150000");
3596 opt_default("minrate", "1150000");
3597 opt_default("bufsize", "327680"); // 40*1024*8;
3599 opt_default("ab", "224000");
3600 audio_sample_rate = 44100;
3603 opt_default("packetsize", "2324");
3604 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3606 /* We have to offset the PTS, so that it is consistent with the SCR.
3607 SCR starts at 36000, but the first two packs contain only padding
3608 and the first pack from the other stream, respectively, may also have
3609 been written before.
3610 So the real data starts at SCR 36000+3*1200. */
3611 mux_preload= (36000+3*1200) / 90000.0; //0.44
3612 } else if(!strcmp(arg, "svcd")) {
3614 opt_video_codec("mpeg2video");
3615 opt_audio_codec("mp2");
3618 opt_frame_size(norm ? "480x480" : "480x576");
3619 opt_frame_rate(NULL, frame_rates[norm]);
3620 opt_default("gop", norm ? "18" : "15");
3622 opt_default("b", "2040000");
3623 opt_default("maxrate", "2516000");
3624 opt_default("minrate", "0"); //1145000;
3625 opt_default("bufsize", "1835008"); //224*1024*8;
3626 opt_default("flags", "+scan_offset");
3629 opt_default("ab", "224000");
3630 audio_sample_rate = 44100;
3632 opt_default("packetsize", "2324");
3634 } else if(!strcmp(arg, "dvd")) {
3636 opt_video_codec("mpeg2video");
3637 opt_audio_codec("ac3");
3640 opt_frame_size(norm ? "720x480" : "720x576");
3641 opt_frame_rate(NULL, frame_rates[norm]);
3642 opt_default("gop", norm ? "18" : "15");
3644 opt_default("b", "6000000");
3645 opt_default("maxrate", "9000000");
3646 opt_default("minrate", "0"); //1500000;
3647 opt_default("bufsize", "1835008"); //224*1024*8;
3649 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3650 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3652 opt_default("ab", "448000");
3653 audio_sample_rate = 48000;
3655 } else if(!strncmp(arg, "dv", 2)) {
3659 opt_frame_size(norm ? "720x480" : "720x576");
3660 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3661 (norm ? "yuv411p" : "yuv420p"));
3662 opt_frame_rate(NULL, frame_rates[norm]);
3664 audio_sample_rate = 48000;
3668 fprintf(stderr, "Unknown target: %s\n", arg);
3673 static void opt_vstats_file (const char *arg)
3675 av_free (vstats_filename);
3676 vstats_filename=av_strdup (arg);
3679 static void opt_vstats (void)
3682 time_t today2 = time(NULL);
3683 struct tm *today = localtime(&today2);
3685 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3687 opt_vstats_file(filename);
3690 static int opt_bsf(const char *opt, const char *arg)
3692 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3693 AVBitStreamFilterContext **bsfp;
3696 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3700 bsfp= *opt == 'v' ? &video_bitstream_filters :
3701 *opt == 'a' ? &audio_bitstream_filters :
3702 &subtitle_bitstream_filters;
3704 bsfp= &(*bsfp)->next;
3711 static int opt_preset(const char *opt, const char *arg)
3714 char filename[1000], tmp[1000], tmp2[1000], line[1000];
3716 const char *base[2]= { getenv("HOME"),
3720 for(i=!base[0]; i<2 && !f; i++){
3721 snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
3722 f= fopen(filename, "r");
3724 char *codec_name= *opt == 'v' ? video_codec_name :
3725 *opt == 'a' ? audio_codec_name :
3726 subtitle_codec_name;
3727 snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i], i ? "" : "/.ffmpeg", codec_name, arg);
3728 f= fopen(filename, "r");
3731 if(!f && ((arg[0]=='.' && arg[1]=='/') || arg[0]=='/' ||
3733 av_strlcpy(filename, arg, sizeof(filename));
3734 f= fopen(filename, "r");
3738 fprintf(stderr, "File for preset '%s' not found\n", arg);
3743 int e= fscanf(f, "%999[^\n]\n", line) - 1;
3744 if(line[0] == '#' && !e)
3746 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3748 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3751 if(!strcmp(tmp, "acodec")){
3752 opt_audio_codec(tmp2);
3753 }else if(!strcmp(tmp, "vcodec")){
3754 opt_video_codec(tmp2);
3755 }else if(!strcmp(tmp, "scodec")){
3756 opt_subtitle_codec(tmp2);
3757 }else if(opt_default(tmp, tmp2) < 0){
3758 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3768 static const OptionDef options[] = {
3770 { "L", OPT_EXIT, {(void*)show_license}, "show license" },
3771 { "h", OPT_EXIT, {(void*)show_help}, "show help" },
3772 { "version", OPT_EXIT, {(void*)show_version}, "show version" },
3773 { "formats", OPT_EXIT, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3774 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3775 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3776 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3777 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3778 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3779 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3780 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3781 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3782 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3783 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
3784 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_rec_timestamp}, "set the timestamp ('now' to set the current time)", "time" },
3785 { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
3786 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3787 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3788 "add timings for benchmarking" },
3789 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3790 "dump each input packet" },
3791 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3792 "when dumping packets, also dump the payload" },
3793 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3794 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3795 { "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)", "" },
3796 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
3797 { "loglevel", HAS_ARG | OPT_FUNC2, {(void*)opt_loglevel}, "set libav* logging level", "logging level number or string" },
3798 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3799 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3800 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3801 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3802 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3803 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3804 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3805 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3806 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3807 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3808 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
3809 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
3812 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3813 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3814 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3815 { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3816 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3817 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3818 { "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" },
3819 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3820 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3821 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3822 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3823 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3824 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3825 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3826 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3827 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3828 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3829 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3830 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3831 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3832 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3833 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3834 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
3835 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3836 "use same video quality as source (implies VBR)" },
3837 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3838 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
3839 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3840 "deinterlace pictures" },
3841 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3842 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3843 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3844 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3845 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3846 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3847 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3848 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3849 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3850 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3851 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
3854 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3855 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3856 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3857 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3858 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3859 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3860 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3861 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3862 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3863 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3864 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3865 { "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" },
3867 /* subtitle options */
3868 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3869 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3870 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3871 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3872 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
3875 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3876 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3877 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3880 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3881 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3883 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3884 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3885 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3887 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3888 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3889 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3891 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3895 int main(int argc, char **argv)
3900 avcodec_register_all();
3901 avdevice_register_all();
3904 if(isatty(STDIN_FILENO))
3905 url_set_interrupt_cb(decode_interrupt_cb);
3907 for(i=0; i<CODEC_TYPE_NB; i++){
3908 avcodec_opts[i]= avcodec_alloc_context2(i);
3910 avformat_opts = avformat_alloc_context();
3911 sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3916 parse_options(argc, argv, options, opt_output_file);
3918 /* file converter / grab */
3919 if (nb_output_files <= 0) {
3920 fprintf(stderr, "At least one output file must be specified\n");
3924 if (nb_input_files == 0) {
3925 fprintf(stderr, "At least one input file must be specified\n");
3930 if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
3931 stream_maps, nb_stream_maps) < 0)
3933 ti = getutime() - ti;
3935 printf("bench: utime=%0.3fs\n", ti / 1000000.0);