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/pixdesc.h"
42 #include "libavutil/avstring.h"
43 #include "libavformat/os_support.h"
45 #if HAVE_SYS_RESOURCE_H
46 #include <sys/types.h>
47 #include <sys/resource.h>
48 #elif HAVE_GETPROCESSTIMES
53 #include <sys/select.h>
58 #include <sys/ioctl.h>
64 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
74 const char program_name[] = "FFmpeg";
75 const int program_birth_year = 2000;
77 /* select an input stream for an output stream */
78 typedef struct AVStreamMap {
82 int sync_stream_index;
85 /** select an input file for an output file */
86 typedef struct AVMetaDataMap {
91 static const OptionDef options[];
95 static const char *last_asked_format = NULL;
96 static AVFormatContext *input_files[MAX_FILES];
97 static int64_t input_files_ts_offset[MAX_FILES];
98 static double input_files_ts_scale[MAX_FILES][MAX_STREAMS];
99 static AVCodec *input_codecs[MAX_FILES*MAX_STREAMS];
100 static int nb_input_files = 0;
101 static int nb_icodecs;
103 static AVFormatContext *output_files[MAX_FILES];
104 static AVCodec *output_codecs[MAX_FILES*MAX_STREAMS];
105 static int nb_output_files = 0;
106 static int nb_ocodecs;
108 static AVStreamMap stream_maps[MAX_FILES*MAX_STREAMS];
109 static int nb_stream_maps;
111 static AVMetaDataMap meta_data_maps[MAX_FILES];
112 static int nb_meta_data_maps;
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 static const char *video_rc_override_string=NULL;
134 static int video_disable = 0;
135 static int video_discard = 0;
136 static char *video_codec_name = NULL;
137 static int video_codec_tag = 0;
138 static char *video_language = NULL;
139 static int same_quality = 0;
140 static int do_deinterlace = 0;
141 static int top_field_first = -1;
142 static int me_threshold = 0;
143 static int intra_dc_precision = 8;
144 static int loop_input = 0;
145 static int loop_output = AVFMT_NOOUTPUTLOOP;
146 static int qp_hist = 0;
148 static int intra_only = 0;
149 static int audio_sample_rate = 44100;
150 static int64_t channel_layout = 0;
151 #define QSCALE_NONE -99999
152 static float audio_qscale = QSCALE_NONE;
153 static int audio_disable = 0;
154 static int audio_channels = 1;
155 static char *audio_codec_name = NULL;
156 static int audio_codec_tag = 0;
157 static char *audio_language = NULL;
159 static int subtitle_disable = 0;
160 static char *subtitle_codec_name = NULL;
161 static char *subtitle_language = NULL;
162 static int subtitle_codec_tag = 0;
164 static float mux_preload= 0.5;
165 static float mux_max_delay= 0.7;
167 static int64_t recording_time = INT64_MAX;
168 static int64_t start_time = 0;
169 static int64_t rec_timestamp = 0;
170 static int64_t input_ts_offset = 0;
171 static int file_overwrite = 0;
172 static int metadata_count;
173 static AVMetadataTag *metadata;
174 static int do_benchmark = 0;
175 static int do_hex_dump = 0;
176 static int do_pkt_dump = 0;
177 static int do_psnr = 0;
178 static int do_pass = 0;
179 static char *pass_logfilename_prefix = NULL;
180 static int audio_stream_copy = 0;
181 static int video_stream_copy = 0;
182 static int subtitle_stream_copy = 0;
183 static int video_sync_method= -1;
184 static int audio_sync_method= 0;
185 static float audio_drift_threshold= 0.1;
186 static int copy_ts= 0;
187 static int opt_shortest = 0;
188 static int video_global_header = 0;
189 static char *vstats_filename;
190 static FILE *vstats_file;
191 static int opt_programid = 0;
192 static int copy_initial_nonkeyframes = 0;
194 static int rate_emu = 0;
196 static int video_channel = 0;
197 static char *video_standard;
199 static int audio_volume = 256;
201 static int exit_on_error = 0;
202 static int using_stdin = 0;
203 static int verbose = 1;
204 static int thread_count= 1;
205 static int q_pressed = 0;
206 static int64_t video_size = 0;
207 static int64_t audio_size = 0;
208 static int64_t extra_size = 0;
209 static int nb_frames_dup = 0;
210 static int nb_frames_drop = 0;
211 static int input_sync;
212 static uint64_t limit_filesize = 0;
213 static int force_fps = 0;
215 static int pgmyuv_compatibility_hack=0;
216 static float dts_delta_threshold = 10;
218 static unsigned int sws_flags = SWS_BICUBIC;
220 static int64_t timer_start;
222 static uint8_t *audio_buf;
223 static uint8_t *audio_out;
224 unsigned int allocated_audio_out_size, allocated_audio_buf_size;
226 static short *samples;
228 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
229 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
230 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
231 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
233 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
235 struct AVInputStream;
237 typedef struct AVOutputStream {
238 int file_index; /* file index */
239 int index; /* stream index in the output file */
240 int source_index; /* AVInputStream index */
241 AVStream *st; /* stream in the output file */
242 int encoding_needed; /* true if encoding needed for this stream */
244 /* input pts and corresponding output pts
246 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
247 struct AVInputStream *sync_ist; /* input stream to sync against */
248 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
251 AVFrame pict_tmp; /* temporary image for resampling */
252 struct SwsContext *img_resample_ctx; /* for image resampling */
255 int resample_pix_fmt;
257 /* full frame size of first frame */
261 /* cropping area sizes */
268 /* cropping area of first frame */
269 int original_topBand;
270 int original_bottomBand;
271 int original_leftBand;
272 int original_rightBand;
274 /* padding area sizes */
283 ReSampleContext *resample; /* for audio resampling */
285 AVAudioConvert *reformat_ctx;
286 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
290 typedef struct AVInputStream {
294 int discard; /* true if stream data should be discarded */
295 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
296 int64_t sample_index; /* current sample */
298 int64_t start; /* time when read started */
299 int64_t next_pts; /* synthetic pts for cases where pkt.pts
301 int64_t pts; /* current pts */
302 int is_start; /* is 1 at the start and after a discontinuity */
303 int showed_multi_packet_warning;
306 typedef struct AVInputFile {
307 int eof_reached; /* true if eof reached */
308 int ist_index; /* index of first stream in ist_table */
309 int buffer_size; /* current total buffer size */
310 int nb_streams; /* nb streams we are aware of */
315 /* init terminal so that we can grab keys */
316 static struct termios oldtty;
319 static void term_exit(void)
322 tcsetattr (0, TCSANOW, &oldtty);
326 static volatile int received_sigterm = 0;
329 sigterm_handler(int sig)
331 received_sigterm = sig;
335 static void term_init(void)
343 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
344 |INLCR|IGNCR|ICRNL|IXON);
345 tty.c_oflag |= OPOST;
346 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
347 tty.c_cflag &= ~(CSIZE|PARENB);
352 tcsetattr (0, TCSANOW, &tty);
353 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
356 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
357 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
359 signal(SIGXCPU, sigterm_handler);
363 register a function to be called at normal program termination
366 #if CONFIG_BEOS_NETSERVER
367 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
371 /* read a key without blocking */
372 static int read_key(void)
377 #if !CONFIG_BEOS_NETSERVER
385 n = select(1, &rfds, NULL, NULL, &tv);
401 static int decode_interrupt_cb(void)
403 return q_pressed || (q_pressed = read_key() == 'q');
406 static int av_exit(int ret)
411 for(i=0;i<nb_output_files;i++) {
412 /* maybe av_close_output_file ??? */
413 AVFormatContext *s = output_files[i];
415 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
417 for(j=0;j<s->nb_streams;j++) {
418 av_metadata_free(&s->streams[j]->metadata);
419 av_free(s->streams[j]->codec);
420 av_free(s->streams[j]);
422 for(j=0;j<s->nb_programs;j++) {
423 av_metadata_free(&s->programs[j]->metadata);
425 for(j=0;j<s->nb_chapters;j++) {
426 av_metadata_free(&s->chapters[j]->metadata);
428 av_metadata_free(&s->metadata);
431 for(i=0;i<nb_input_files;i++)
432 av_close_input_file(input_files[i]);
434 av_free(intra_matrix);
435 av_free(inter_matrix);
439 av_free(vstats_filename);
443 av_free(video_codec_name);
444 av_free(audio_codec_name);
445 av_free(subtitle_codec_name);
447 av_free(video_standard);
449 #if CONFIG_POWERPC_PERF
450 void powerpc_display_perf_report(void);
451 powerpc_display_perf_report();
452 #endif /* CONFIG_POWERPC_PERF */
454 for (i=0;i<CODEC_TYPE_NB;i++)
455 av_free(avcodec_opts[i]);
456 av_free(avformat_opts);
460 allocated_audio_buf_size= allocated_audio_out_size= 0;
463 if (received_sigterm) {
465 "Received signal %d: terminating.\n",
466 (int) received_sigterm);
470 exit(ret); /* not all OS-es handle main() return value */
474 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
480 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
483 /* copy stream format */
484 s->nb_streams = ic->nb_streams;
485 for(i=0;i<ic->nb_streams;i++) {
488 // FIXME: a more elegant solution is needed
489 st = av_mallocz(sizeof(AVStream));
490 memcpy(st, ic->streams[i], sizeof(AVStream));
491 st->codec = avcodec_alloc_context();
493 print_error(filename, AVERROR(ENOMEM));
496 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
499 if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
501 else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
504 if(!st->codec->thread_count)
505 st->codec->thread_count = 1;
506 if(st->codec->thread_count>1)
507 avcodec_thread_init(st->codec, st->codec->thread_count);
509 if(st->codec->flags & CODEC_FLAG_BITEXACT)
514 s->timestamp = av_gettime();
516 av_close_input_file(ic);
521 get_sync_ipts(const AVOutputStream *ost)
523 const AVInputStream *ist = ost->sync_ist;
524 return (double)(ist->pts - start_time)/AV_TIME_BASE;
527 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
531 AVPacket new_pkt= *pkt;
532 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
533 &new_pkt.data, &new_pkt.size,
534 pkt->data, pkt->size,
535 pkt->flags & PKT_FLAG_KEY);
538 new_pkt.destruct= av_destruct_packet;
540 fprintf(stderr, "%s failed for stream %d, codec %s",
541 bsfc->filter->name, pkt->stream_index,
542 avctx->codec ? avctx->codec->name : "copy");
552 ret= av_interleaved_write_frame(s, pkt);
554 print_error("av_interleaved_write_frame()", ret);
559 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
561 static void do_audio_out(AVFormatContext *s,
564 unsigned char *buf, int size)
567 int64_t audio_out_size, audio_buf_size;
568 int64_t allocated_for_size= size;
570 int size_out, frame_bytes, ret;
571 AVCodecContext *enc= ost->st->codec;
572 AVCodecContext *dec= ist->st->codec;
573 int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
574 int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
575 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
578 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
579 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
580 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
581 audio_buf_size*= osize*enc->channels;
583 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
584 if(coded_bps > 8*osize)
585 audio_out_size= audio_out_size * coded_bps / (8*osize);
586 audio_out_size += FF_MIN_BUFFER_SIZE;
588 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
589 fprintf(stderr, "Buffer sizes too large\n");
593 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
594 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
595 if (!audio_buf || !audio_out){
596 fprintf(stderr, "Out of memory in do_audio_out\n");
600 if (enc->channels != dec->channels)
601 ost->audio_resample = 1;
603 if (ost->audio_resample && !ost->resample) {
604 if (dec->sample_fmt != SAMPLE_FMT_S16)
605 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
606 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
607 enc->sample_rate, dec->sample_rate,
608 enc->sample_fmt, dec->sample_fmt,
610 if (!ost->resample) {
611 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
612 dec->channels, dec->sample_rate,
613 enc->channels, enc->sample_rate);
618 #define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
619 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
620 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
621 if (ost->reformat_ctx)
622 av_audio_convert_free(ost->reformat_ctx);
623 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
624 dec->sample_fmt, 1, NULL, 0);
625 if (!ost->reformat_ctx) {
626 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
627 avcodec_get_sample_fmt_name(dec->sample_fmt),
628 avcodec_get_sample_fmt_name(enc->sample_fmt));
631 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
634 if(audio_sync_method){
635 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
636 - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2);
637 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
638 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
640 //FIXME resample delay
641 if(fabs(delta) > 50){
642 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
644 byte_delta= FFMAX(byte_delta, -size);
648 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
653 static uint8_t *input_tmp= NULL;
654 input_tmp= av_realloc(input_tmp, byte_delta + size);
656 if(byte_delta > allocated_for_size - size){
657 allocated_for_size= byte_delta + (int64_t)size;
662 memset(input_tmp, 0, byte_delta);
663 memcpy(input_tmp + byte_delta, buf, size);
667 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
669 }else if(audio_sync_method>1){
670 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
671 assert(ost->audio_resample);
673 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
674 // 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));
675 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
679 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
680 - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
682 if (ost->audio_resample) {
684 size_out = audio_resample(ost->resample,
685 (short *)buftmp, (short *)buf,
686 size / (ist->st->codec->channels * isize));
687 size_out = size_out * enc->channels * osize;
693 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
694 const void *ibuf[6]= {buftmp};
695 void *obuf[6]= {audio_buf};
696 int istride[6]= {isize};
697 int ostride[6]= {osize};
698 int len= size_out/istride[0];
699 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
700 printf("av_audio_convert() failed\n");
706 size_out = len*osize;
709 /* now encode as many frames as possible */
710 if (enc->frame_size > 1) {
711 /* output resampled raw samples */
712 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
713 fprintf(stderr, "av_fifo_realloc2() failed\n");
716 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
718 frame_bytes = enc->frame_size * osize * enc->channels;
720 while (av_fifo_size(ost->fifo) >= frame_bytes) {
722 av_init_packet(&pkt);
724 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
726 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
728 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
731 fprintf(stderr, "Audio encoding failed\n");
735 pkt.stream_index= ost->index;
738 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
739 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
740 pkt.flags |= PKT_FLAG_KEY;
741 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
743 ost->sync_opts += enc->frame_size;
747 av_init_packet(&pkt);
749 ost->sync_opts += size_out / (osize * enc->channels);
751 /* output a pcm frame */
752 /* determine the size of the coded buffer */
755 size_out = size_out*coded_bps/8;
757 if(size_out > audio_out_size){
758 fprintf(stderr, "Internal error, buffer size too small\n");
762 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
763 ret = avcodec_encode_audio(enc, audio_out, size_out,
766 fprintf(stderr, "Audio encoding failed\n");
770 pkt.stream_index= ost->index;
773 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
774 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
775 pkt.flags |= PKT_FLAG_KEY;
776 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
780 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
784 AVPicture picture_tmp;
787 dec = ist->st->codec;
789 /* deinterlace : must be done before any resize */
790 if (do_deinterlace) {
793 /* create temporary picture */
794 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
795 buf = av_malloc(size);
799 picture2 = &picture_tmp;
800 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
802 if(avpicture_deinterlace(picture2, picture,
803 dec->pix_fmt, dec->width, dec->height) < 0) {
804 /* if error, do not deinterlace */
805 fprintf(stderr, "Deinterlacing failed\n");
814 if (picture != picture2)
815 *picture = *picture2;
819 /* we begin to correct av delay at this threshold */
820 #define AV_DELAY_MAX 0.100
822 static void do_subtitle_out(AVFormatContext *s,
828 static uint8_t *subtitle_out = NULL;
829 int subtitle_out_max_size = 1024 * 1024;
830 int subtitle_out_size, nb, i;
834 if (pts == AV_NOPTS_VALUE) {
835 fprintf(stderr, "Subtitle packets must have a pts\n");
841 enc = ost->st->codec;
844 subtitle_out = av_malloc(subtitle_out_max_size);
847 /* Note: DVB subtitle need one packet to draw them and one other
848 packet to clear them */
849 /* XXX: signal it in the codec context ? */
850 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
855 for(i = 0; i < nb; i++) {
856 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
857 // start_display_time is required to be 0
858 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
859 sub->end_display_time -= sub->start_display_time;
860 sub->start_display_time = 0;
861 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
862 subtitle_out_max_size, sub);
863 if (subtitle_out_size < 0) {
864 fprintf(stderr, "Subtitle encoding failed\n");
868 av_init_packet(&pkt);
869 pkt.stream_index = ost->index;
870 pkt.data = subtitle_out;
871 pkt.size = subtitle_out_size;
872 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
873 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
874 /* XXX: the pts correction is handled here. Maybe handling
875 it in the codec would be better */
877 pkt.pts += 90 * sub->start_display_time;
879 pkt.pts += 90 * sub->end_display_time;
881 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
885 static int bit_buffer_size= 1024*256;
886 static uint8_t *bit_buffer= NULL;
888 static void do_video_out(AVFormatContext *s,
894 int nb_frames, i, ret;
895 int64_t topBand, bottomBand, leftBand, rightBand;
896 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
897 AVFrame picture_crop_temp, picture_pad_temp;
898 AVCodecContext *enc, *dec;
900 avcodec_get_frame_defaults(&picture_crop_temp);
901 avcodec_get_frame_defaults(&picture_pad_temp);
903 enc = ost->st->codec;
904 dec = ist->st->codec;
906 /* by default, we output a single frame */
911 if(video_sync_method){
913 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
914 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
917 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
921 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
922 }else if (vdelta > 1.1)
923 nb_frames = lrintf(vdelta);
924 //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);
928 fprintf(stderr, "*** drop!\n");
929 }else if (nb_frames > 1) {
930 nb_frames_dup += nb_frames - 1;
932 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
935 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
937 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
941 if (ost->video_crop) {
942 if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
943 fprintf(stderr, "error cropping picture\n");
948 formatted_picture = &picture_crop_temp;
950 formatted_picture = in_picture;
953 final_picture = formatted_picture;
954 padding_src = formatted_picture;
955 resampling_dst = &ost->pict_tmp;
956 if (ost->video_pad) {
957 final_picture = &ost->pict_tmp;
958 if (ost->video_resample) {
959 if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
960 fprintf(stderr, "error padding picture\n");
965 resampling_dst = &picture_pad_temp;
969 if( (ost->resample_height != (ist->st->codec->height - (ost->topBand + ost->bottomBand)))
970 || (ost->resample_width != (ist->st->codec->width - (ost->leftBand + ost->rightBand)))
971 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
973 fprintf(stderr,"Input Stream #%d.%d frame size changed to %dx%d, %s\n", ist->file_index, ist->index, ist->st->codec->width, ist->st->codec->height,avcodec_get_pix_fmt_name(ist->st->codec->pix_fmt));
974 if(!ost->video_resample)
978 if (ost->video_resample) {
980 final_picture = &ost->pict_tmp;
981 if( (ost->resample_height != (ist->st->codec->height - (ost->topBand + ost->bottomBand)))
982 || (ost->resample_width != (ist->st->codec->width - (ost->leftBand + ost->rightBand)))
983 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
985 /* keep bands proportional to the frame size */
986 topBand = ((int64_t)ist->st->codec->height * ost->original_topBand / ost->original_height) & ~1;
987 bottomBand = ((int64_t)ist->st->codec->height * ost->original_bottomBand / ost->original_height) & ~1;
988 leftBand = ((int64_t)ist->st->codec->width * ost->original_leftBand / ost->original_width) & ~1;
989 rightBand = ((int64_t)ist->st->codec->width * ost->original_rightBand / ost->original_width) & ~1;
991 /* sanity check to ensure no bad band sizes sneak in */
992 assert(topBand <= INT_MAX && topBand >= 0);
993 assert(bottomBand <= INT_MAX && bottomBand >= 0);
994 assert(leftBand <= INT_MAX && leftBand >= 0);
995 assert(rightBand <= INT_MAX && rightBand >= 0);
997 ost->topBand = topBand;
998 ost->bottomBand = bottomBand;
999 ost->leftBand = leftBand;
1000 ost->rightBand = rightBand;
1002 ost->resample_height = ist->st->codec->height - (ost->topBand + ost->bottomBand);
1003 ost->resample_width = ist->st->codec->width - (ost->leftBand + ost->rightBand);
1004 ost->resample_pix_fmt= ist->st->codec->pix_fmt;
1006 /* initialize a new scaler context */
1007 sws_freeContext(ost->img_resample_ctx);
1008 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1009 ost->img_resample_ctx = sws_getContext(
1010 ist->st->codec->width - (ost->leftBand + ost->rightBand),
1011 ist->st->codec->height - (ost->topBand + ost->bottomBand),
1012 ist->st->codec->pix_fmt,
1013 ost->st->codec->width - (ost->padleft + ost->padright),
1014 ost->st->codec->height - (ost->padtop + ost->padbottom),
1015 ost->st->codec->pix_fmt,
1016 sws_flags, NULL, NULL, NULL);
1017 if (ost->img_resample_ctx == NULL) {
1018 fprintf(stderr, "Cannot get resampling context\n");
1022 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1023 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1026 if (ost->video_pad) {
1027 av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
1028 enc->height, enc->width, enc->pix_fmt,
1029 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
1032 /* duplicates frame if needed */
1033 for(i=0;i<nb_frames;i++) {
1035 av_init_packet(&pkt);
1036 pkt.stream_index= ost->index;
1038 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1039 /* raw pictures are written as AVPicture structure to
1040 avoid any copies. We support temorarily the older
1042 AVFrame* old_frame = enc->coded_frame;
1043 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1044 pkt.data= (uint8_t *)final_picture;
1045 pkt.size= sizeof(AVPicture);
1046 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1047 pkt.flags |= PKT_FLAG_KEY;
1049 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1050 enc->coded_frame = old_frame;
1052 AVFrame big_picture;
1054 big_picture= *final_picture;
1055 /* better than nothing: use input picture interlaced
1057 big_picture.interlaced_frame = in_picture->interlaced_frame;
1058 if(avcodec_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1059 if(top_field_first == -1)
1060 big_picture.top_field_first = in_picture->top_field_first;
1062 big_picture.top_field_first = top_field_first;
1065 /* handles sameq here. This is not correct because it may
1066 not be a global option */
1068 big_picture.quality = ist->st->quality;
1070 big_picture.quality = ost->st->quality;
1072 big_picture.pict_type = 0;
1073 // big_picture.pts = AV_NOPTS_VALUE;
1074 big_picture.pts= ost->sync_opts;
1075 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1076 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1077 ret = avcodec_encode_video(enc,
1078 bit_buffer, bit_buffer_size,
1081 fprintf(stderr, "Video encoding failed\n");
1086 pkt.data= bit_buffer;
1088 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1089 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1090 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1091 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1092 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1094 if(enc->coded_frame->key_frame)
1095 pkt.flags |= PKT_FLAG_KEY;
1096 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1099 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1100 // enc->frame_number-1, ret, enc->pict_type);
1101 /* if two pass, output log */
1102 if (ost->logfile && enc->stats_out) {
1103 fprintf(ost->logfile, "%s", enc->stats_out);
1108 ost->frame_number++;
1112 static double psnr(double d){
1113 return -10.0*log(d)/log(10.0);
1116 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1119 AVCodecContext *enc;
1121 double ti1, bitrate, avg_bitrate;
1123 /* this is executed just the first time do_video_stats is called */
1125 vstats_file = fopen(vstats_filename, "w");
1132 enc = ost->st->codec;
1133 if (enc->codec_type == CODEC_TYPE_VIDEO) {
1134 frame_number = ost->frame_number;
1135 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1136 if (enc->flags&CODEC_FLAG_PSNR)
1137 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1139 fprintf(vstats_file,"f_size= %6d ", frame_size);
1140 /* compute pts value */
1141 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1145 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1146 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1147 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1148 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1149 fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1153 static void print_report(AVFormatContext **output_files,
1154 AVOutputStream **ost_table, int nb_ostreams,
1158 AVOutputStream *ost;
1159 AVFormatContext *oc;
1161 AVCodecContext *enc;
1162 int frame_number, vid, i;
1163 double bitrate, ti1, pts;
1164 static int64_t last_time = -1;
1165 static int qp_histogram[52];
1167 if (!is_last_report) {
1169 /* display the report every 0.5 seconds */
1170 cur_time = av_gettime();
1171 if (last_time == -1) {
1172 last_time = cur_time;
1175 if ((cur_time - last_time) < 500000)
1177 last_time = cur_time;
1181 oc = output_files[0];
1183 total_size = url_fsize(oc->pb);
1184 if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1185 total_size= url_ftell(oc->pb);
1190 for(i=0;i<nb_ostreams;i++) {
1192 enc = ost->st->codec;
1193 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1194 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1195 !ost->st->stream_copy ?
1196 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1198 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1199 float t = (av_gettime()-timer_start) / 1000000.0;
1201 frame_number = ost->frame_number;
1202 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1203 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1204 !ost->st->stream_copy ?
1205 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1207 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1210 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1211 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1214 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1216 if (enc->flags&CODEC_FLAG_PSNR){
1218 double error, error_sum=0;
1219 double scale, scale_sum=0;
1220 char type[3]= {'Y','U','V'};
1221 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1224 error= enc->error[j];
1225 scale= enc->width*enc->height*255.0*255.0*frame_number;
1227 error= enc->coded_frame->error[j];
1228 scale= enc->width*enc->height*255.0*255.0;
1233 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1235 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1239 /* compute min output value */
1240 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1241 if ((pts < ti1) && (pts > 0))
1247 if (verbose || is_last_report) {
1248 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1250 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1251 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1252 (double)total_size / 1024, ti1, bitrate);
1254 if (nb_frames_dup || nb_frames_drop)
1255 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1256 nb_frames_dup, nb_frames_drop);
1259 fprintf(stderr, "%s \r", buf);
1264 if (is_last_report && verbose >= 0){
1265 int64_t raw= audio_size + video_size + extra_size;
1266 fprintf(stderr, "\n");
1267 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1271 100.0*(total_size - raw)/raw
1276 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1277 static int output_packet(AVInputStream *ist, int ist_index,
1278 AVOutputStream **ost_table, int nb_ostreams,
1279 const AVPacket *pkt)
1281 AVFormatContext *os;
1282 AVOutputStream *ost;
1286 void *buffer_to_free;
1287 static unsigned int samples_size= 0;
1288 AVSubtitle subtitle, *subtitle_to_free;
1291 int bps = av_get_bits_per_sample_format(ist->st->codec->sample_fmt)>>3;
1293 if(ist->next_pts == AV_NOPTS_VALUE)
1294 ist->next_pts= ist->pts;
1298 av_init_packet(&avpkt);
1306 if(pkt->dts != AV_NOPTS_VALUE)
1307 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1309 //while we have more to decode or while the decoder did output something on EOF
1310 while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1311 uint8_t *data_buf, *decoded_data_buf;
1312 int data_size, decoded_data_size;
1314 ist->pts= ist->next_pts;
1316 if(avpkt.size && avpkt.size != pkt->size &&
1317 (!ist->showed_multi_packet_warning && verbose>0 || verbose>1)){
1318 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1319 ist->showed_multi_packet_warning=1;
1322 /* decode the packet if needed */
1323 decoded_data_buf = NULL; /* fail safe */
1324 decoded_data_size= 0;
1325 data_buf = avpkt.data;
1326 data_size = avpkt.size;
1327 subtitle_to_free = NULL;
1328 if (ist->decoding_needed) {
1329 switch(ist->st->codec->codec_type) {
1330 case CODEC_TYPE_AUDIO:{
1331 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1332 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1334 samples= av_malloc(samples_size);
1336 decoded_data_size= samples_size;
1337 /* XXX: could avoid copy if PCM 16 bits with same
1338 endianness as CPU */
1339 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1346 /* Some bug in mpeg audio decoder gives */
1347 /* decoded_data_size < 0, it seems they are overflows */
1348 if (decoded_data_size <= 0) {
1349 /* no audio frame */
1352 decoded_data_buf = (uint8_t *)samples;
1353 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1354 (ist->st->codec->sample_rate * ist->st->codec->channels);
1356 case CODEC_TYPE_VIDEO:
1357 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1358 /* XXX: allocate picture correctly */
1359 avcodec_get_frame_defaults(&picture);
1361 ret = avcodec_decode_video2(ist->st->codec,
1362 &picture, &got_picture, &avpkt);
1363 ist->st->quality= picture.quality;
1367 /* no picture yet */
1368 goto discard_packet;
1370 if (ist->st->codec->time_base.num != 0) {
1371 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1372 ist->next_pts += ((int64_t)AV_TIME_BASE *
1373 ist->st->codec->time_base.num * ticks) /
1374 ist->st->codec->time_base.den;
1378 case CODEC_TYPE_SUBTITLE:
1379 ret = avcodec_decode_subtitle2(ist->st->codec,
1380 &subtitle, &got_subtitle, &avpkt);
1383 if (!got_subtitle) {
1384 goto discard_packet;
1386 subtitle_to_free = &subtitle;
1393 switch(ist->st->codec->codec_type) {
1394 case CODEC_TYPE_AUDIO:
1395 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1396 ist->st->codec->sample_rate;
1398 case CODEC_TYPE_VIDEO:
1399 if (ist->st->codec->time_base.num != 0) {
1400 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1401 ist->next_pts += ((int64_t)AV_TIME_BASE *
1402 ist->st->codec->time_base.num * ticks) /
1403 ist->st->codec->time_base.den;
1411 buffer_to_free = NULL;
1412 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1413 pre_process_video_frame(ist, (AVPicture *)&picture,
1417 // preprocess audio (volume)
1418 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1419 if (audio_volume != 256) {
1422 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1423 int v = ((*volp) * audio_volume + 128) >> 8;
1424 if (v < -32768) v = -32768;
1425 if (v > 32767) v = 32767;
1431 /* frame rate emulation */
1433 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1434 int64_t now = av_gettime() - ist->start;
1439 /* if output time reached then transcode raw format,
1440 encode packets and output them */
1441 if (start_time == 0 || ist->pts >= start_time)
1442 for(i=0;i<nb_ostreams;i++) {
1446 if (ost->source_index == ist_index) {
1447 os = output_files[ost->file_index];
1449 /* set the input output pts pairs */
1450 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1452 if (ost->encoding_needed) {
1453 assert(ist->decoding_needed);
1454 switch(ost->st->codec->codec_type) {
1455 case CODEC_TYPE_AUDIO:
1456 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1458 case CODEC_TYPE_VIDEO:
1459 do_video_out(os, ost, ist, &picture, &frame_size);
1460 if (vstats_filename && frame_size)
1461 do_video_stats(os, ost, frame_size);
1463 case CODEC_TYPE_SUBTITLE:
1464 do_subtitle_out(os, ost, ist, &subtitle,
1471 AVFrame avframe; //FIXME/XXX remove this
1473 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1475 av_init_packet(&opkt);
1477 if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1480 /* no reencoding needed : output the packet directly */
1481 /* force the input stream PTS */
1483 avcodec_get_frame_defaults(&avframe);
1484 ost->st->codec->coded_frame= &avframe;
1485 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1487 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1488 audio_size += data_size;
1489 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1490 video_size += data_size;
1494 opkt.stream_index= ost->index;
1495 if(pkt->pts != AV_NOPTS_VALUE)
1496 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1498 opkt.pts= AV_NOPTS_VALUE;
1500 if (pkt->dts == AV_NOPTS_VALUE)
1501 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1503 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1504 opkt.dts -= ost_tb_start_time;
1506 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1507 opkt.flags= pkt->flags;
1509 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1510 if( ost->st->codec->codec_id != CODEC_ID_H264
1511 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1512 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1514 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1515 opkt.destruct= av_destruct_packet;
1517 opkt.data = data_buf;
1518 opkt.size = data_size;
1521 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1522 ost->st->codec->frame_number++;
1523 ost->frame_number++;
1524 av_free_packet(&opkt);
1528 av_free(buffer_to_free);
1529 /* XXX: allocate the subtitles in the codec ? */
1530 if (subtitle_to_free) {
1531 if (subtitle_to_free->rects != NULL) {
1532 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1533 av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1534 av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1535 av_freep(&subtitle_to_free->rects[i]);
1537 av_freep(&subtitle_to_free->rects);
1539 subtitle_to_free->num_rects = 0;
1540 subtitle_to_free = NULL;
1547 for(i=0;i<nb_ostreams;i++) {
1549 if (ost->source_index == ist_index) {
1550 AVCodecContext *enc= ost->st->codec;
1551 os = output_files[ost->file_index];
1553 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1555 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1558 if (ost->encoding_needed) {
1562 av_init_packet(&pkt);
1563 pkt.stream_index= ost->index;
1565 switch(ost->st->codec->codec_type) {
1566 case CODEC_TYPE_AUDIO:
1567 fifo_bytes = av_fifo_size(ost->fifo);
1569 /* encode any samples remaining in fifo */
1570 if (fifo_bytes > 0) {
1571 int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
1572 int fs_tmp = enc->frame_size;
1574 av_fifo_generic_read(ost->fifo, samples, fifo_bytes, NULL);
1575 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1576 enc->frame_size = fifo_bytes / (osize * enc->channels);
1578 int frame_bytes = enc->frame_size*osize*enc->channels;
1579 if (samples_size < frame_bytes)
1581 memset((uint8_t*)samples+fifo_bytes, 0, frame_bytes - fifo_bytes);
1584 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1585 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1586 ost->st->time_base.num, enc->sample_rate);
1587 enc->frame_size = fs_tmp;
1590 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1593 fprintf(stderr, "Audio encoding failed\n");
1597 pkt.flags |= PKT_FLAG_KEY;
1599 case CODEC_TYPE_VIDEO:
1600 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1602 fprintf(stderr, "Video encoding failed\n");
1606 if(enc->coded_frame && enc->coded_frame->key_frame)
1607 pkt.flags |= PKT_FLAG_KEY;
1608 if (ost->logfile && enc->stats_out) {
1609 fprintf(ost->logfile, "%s", enc->stats_out);
1618 pkt.data= bit_buffer;
1620 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1621 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1622 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1634 static void print_sdp(AVFormatContext **avc, int n)
1638 avf_sdp_create(avc, n, sdp, sizeof(sdp));
1639 printf("SDP:\n%s\n", sdp);
1643 static int stream_index_from_inputs(AVFormatContext **input_files,
1645 AVInputFile *file_table,
1646 AVInputStream **ist_table,
1647 enum CodecType type,
1651 for(z=0; z<nb_input_files; z++) {
1652 AVFormatContext *ic = input_files[z];
1653 for(p=0; p<ic->nb_programs; p++) {
1654 AVProgram *program = ic->programs[p];
1655 if(program->id != programid)
1657 for(q=0; q<program->nb_stream_indexes; q++) {
1658 int sidx = program->stream_index[q];
1659 int ris = file_table[z].ist_index + sidx;
1660 if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1670 * The following code is the main loop of the file converter
1672 static int av_encode(AVFormatContext **output_files,
1673 int nb_output_files,
1674 AVFormatContext **input_files,
1676 AVStreamMap *stream_maps, int nb_stream_maps)
1678 int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1679 AVFormatContext *is, *os;
1680 AVCodecContext *codec, *icodec;
1681 AVOutputStream *ost, **ost_table = NULL;
1682 AVInputStream *ist, **ist_table = NULL;
1683 AVInputFile *file_table;
1687 uint8_t no_packet[MAX_FILES]={0};
1688 int no_packet_count=0;
1690 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1694 /* input stream init */
1696 for(i=0;i<nb_input_files;i++) {
1697 is = input_files[i];
1698 file_table[i].ist_index = j;
1699 file_table[i].nb_streams = is->nb_streams;
1700 j += is->nb_streams;
1704 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1708 for(i=0;i<nb_istreams;i++) {
1709 ist = av_mallocz(sizeof(AVInputStream));
1715 for(i=0;i<nb_input_files;i++) {
1716 is = input_files[i];
1717 for(k=0;k<is->nb_streams;k++) {
1718 ist = ist_table[j++];
1719 ist->st = is->streams[k];
1720 ist->file_index = i;
1722 ist->discard = 1; /* the stream is discarded by default
1726 ist->start = av_gettime();
1731 /* output stream init */
1733 for(i=0;i<nb_output_files;i++) {
1734 os = output_files[i];
1735 if (!os->nb_streams) {
1736 dump_format(output_files[i], i, output_files[i]->filename, 1);
1737 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1740 nb_ostreams += os->nb_streams;
1742 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1743 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1747 /* Sanity check the mapping args -- do the input files & streams exist? */
1748 for(i=0;i<nb_stream_maps;i++) {
1749 int fi = stream_maps[i].file_index;
1750 int si = stream_maps[i].stream_index;
1752 if (fi < 0 || fi > nb_input_files - 1 ||
1753 si < 0 || si > file_table[fi].nb_streams - 1) {
1754 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1757 fi = stream_maps[i].sync_file_index;
1758 si = stream_maps[i].sync_stream_index;
1759 if (fi < 0 || fi > nb_input_files - 1 ||
1760 si < 0 || si > file_table[fi].nb_streams - 1) {
1761 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1766 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1769 for(i=0;i<nb_ostreams;i++) {
1770 ost = av_mallocz(sizeof(AVOutputStream));
1777 for(k=0;k<nb_output_files;k++) {
1778 os = output_files[k];
1779 for(i=0;i<os->nb_streams;i++,n++) {
1782 ost->file_index = k;
1784 ost->st = os->streams[i];
1785 if (nb_stream_maps > 0) {
1786 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1787 stream_maps[n].stream_index;
1789 /* Sanity check that the stream types match */
1790 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1791 int i= ost->file_index;
1792 dump_format(output_files[i], i, output_files[i]->filename, 1);
1793 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1794 stream_maps[n].file_index, stream_maps[n].stream_index,
1795 ost->file_index, ost->index);
1802 j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1804 ost->source_index = j;
1808 /* get corresponding input stream index : we select the first one with the right type */
1810 for(j=0;j<nb_istreams;j++) {
1813 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1814 ost->source_index = j;
1822 if(! opt_programid) {
1823 /* try again and reuse existing stream */
1824 for(j=0;j<nb_istreams;j++) {
1826 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1827 ost->source_index = j;
1833 int i= ost->file_index;
1834 dump_format(output_files[i], i, output_files[i]->filename, 1);
1835 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1836 ost->file_index, ost->index);
1841 ist = ist_table[ost->source_index];
1843 ost->sync_ist = (nb_stream_maps > 0) ?
1844 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
1845 stream_maps[n].sync_stream_index] : ist;
1849 /* for each output stream, we compute the right encoding parameters */
1850 for(i=0;i<nb_ostreams;i++) {
1851 AVMetadataTag *lang;
1853 os = output_files[ost->file_index];
1854 ist = ist_table[ost->source_index];
1856 codec = ost->st->codec;
1857 icodec = ist->st->codec;
1859 if ((lang=av_metadata_get(ist->st->metadata, "language", NULL, 0))
1860 && !av_metadata_get(ost->st->metadata, "language", NULL, 0))
1861 av_metadata_set(&ost->st->metadata, "language", lang->value);
1863 ost->st->disposition = ist->st->disposition;
1864 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1865 codec->chroma_sample_location = icodec->chroma_sample_location;
1867 if (ost->st->stream_copy) {
1868 /* if stream_copy is selected, no need to decode or encode */
1869 codec->codec_id = icodec->codec_id;
1870 codec->codec_type = icodec->codec_type;
1872 if(!codec->codec_tag){
1873 if( !os->oformat->codec_tag
1874 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
1875 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1876 codec->codec_tag = icodec->codec_tag;
1879 codec->bit_rate = icodec->bit_rate;
1880 codec->extradata= icodec->extradata;
1881 codec->extradata_size= icodec->extradata_size;
1882 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){
1883 codec->time_base = icodec->time_base;
1884 codec->time_base.num *= icodec->ticks_per_frame;
1886 codec->time_base = ist->st->time_base;
1887 switch(codec->codec_type) {
1888 case CODEC_TYPE_AUDIO:
1889 if(audio_volume != 256) {
1890 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1893 codec->channel_layout = icodec->channel_layout;
1894 codec->sample_rate = icodec->sample_rate;
1895 codec->channels = icodec->channels;
1896 codec->frame_size = icodec->frame_size;
1897 codec->block_align= icodec->block_align;
1898 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1899 codec->block_align= 0;
1900 if(codec->codec_id == CODEC_ID_AC3)
1901 codec->block_align= 0;
1903 case CODEC_TYPE_VIDEO:
1904 codec->pix_fmt = icodec->pix_fmt;
1905 codec->width = icodec->width;
1906 codec->height = icodec->height;
1907 codec->has_b_frames = icodec->has_b_frames;
1909 case CODEC_TYPE_SUBTITLE:
1910 codec->width = icodec->width;
1911 codec->height = icodec->height;
1917 switch(codec->codec_type) {
1918 case CODEC_TYPE_AUDIO:
1919 ost->fifo= av_fifo_alloc(1024);
1922 ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
1923 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1924 icodec->request_channels = codec->channels;
1925 ist->decoding_needed = 1;
1926 ost->encoding_needed = 1;
1928 case CODEC_TYPE_VIDEO:
1929 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
1930 fprintf(stderr, "Video pixel format is unknown, stream cannot be decoded\n");
1933 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1934 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1935 ost->video_resample = ((codec->width != icodec->width -
1936 (frame_leftBand + frame_rightBand) +
1937 (frame_padleft + frame_padright)) ||
1938 (codec->height != icodec->height -
1939 (frame_topBand + frame_bottomBand) +
1940 (frame_padtop + frame_padbottom)) ||
1941 (codec->pix_fmt != icodec->pix_fmt));
1942 if (ost->video_crop) {
1943 ost->topBand = ost->original_topBand = frame_topBand;
1944 ost->bottomBand = ost->original_bottomBand = frame_bottomBand;
1945 ost->leftBand = ost->original_leftBand = frame_leftBand;
1946 ost->rightBand = ost->original_rightBand = frame_rightBand;
1948 if (ost->video_pad) {
1949 ost->padtop = frame_padtop;
1950 ost->padleft = frame_padleft;
1951 ost->padbottom = frame_padbottom;
1952 ost->padright = frame_padright;
1953 if (!ost->video_resample) {
1954 avcodec_get_frame_defaults(&ost->pict_tmp);
1955 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1956 codec->width, codec->height))
1960 if (ost->video_resample) {
1961 avcodec_get_frame_defaults(&ost->pict_tmp);
1962 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1963 codec->width, codec->height)) {
1964 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1967 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1968 ost->img_resample_ctx = sws_getContext(
1969 icodec->width - (frame_leftBand + frame_rightBand),
1970 icodec->height - (frame_topBand + frame_bottomBand),
1972 codec->width - (frame_padleft + frame_padright),
1973 codec->height - (frame_padtop + frame_padbottom),
1975 sws_flags, NULL, NULL, NULL);
1976 if (ost->img_resample_ctx == NULL) {
1977 fprintf(stderr, "Cannot get resampling context\n");
1981 ost->original_height = icodec->height;
1982 ost->original_width = icodec->width;
1984 codec->bits_per_raw_sample= 0;
1986 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1987 ost->resample_width = icodec->width - (frame_leftBand + frame_rightBand);
1988 ost->resample_pix_fmt= icodec->pix_fmt;
1989 ost->encoding_needed = 1;
1990 ist->decoding_needed = 1;
1992 case CODEC_TYPE_SUBTITLE:
1993 ost->encoding_needed = 1;
1994 ist->decoding_needed = 1;
2001 if (ost->encoding_needed &&
2002 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2003 char logfilename[1024];
2008 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2009 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2011 if (codec->flags & CODEC_FLAG_PASS1) {
2012 f = fopen(logfilename, "w");
2014 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2019 /* read the log file */
2020 f = fopen(logfilename, "r");
2022 fprintf(stderr, "Cannot read log file '%s' for pass-2 encoding: %s\n", logfilename, strerror(errno));
2025 fseek(f, 0, SEEK_END);
2027 fseek(f, 0, SEEK_SET);
2028 logbuffer = av_malloc(size + 1);
2030 fprintf(stderr, "Could not allocate log buffer\n");
2033 size = fread(logbuffer, 1, size, f);
2035 logbuffer[size] = '\0';
2036 codec->stats_in = logbuffer;
2040 if(codec->codec_type == CODEC_TYPE_VIDEO){
2041 int size= codec->width * codec->height;
2042 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2047 bit_buffer = av_malloc(bit_buffer_size);
2049 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2051 ret = AVERROR(ENOMEM);
2055 /* open each encoder */
2056 for(i=0;i<nb_ostreams;i++) {
2058 if (ost->encoding_needed) {
2059 AVCodec *codec = output_codecs[i];
2061 codec = avcodec_find_encoder(ost->st->codec->codec_id);
2063 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2064 ost->st->codec->codec_id, ost->file_index, ost->index);
2065 ret = AVERROR(EINVAL);
2068 if (avcodec_open(ost->st->codec, codec) < 0) {
2069 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2070 ost->file_index, ost->index);
2071 ret = AVERROR(EINVAL);
2074 extra_size += ost->st->codec->extradata_size;
2078 /* open each decoder */
2079 for(i=0;i<nb_istreams;i++) {
2081 if (ist->decoding_needed) {
2082 AVCodec *codec = input_codecs[i];
2084 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2086 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2087 ist->st->codec->codec_id, ist->file_index, ist->index);
2088 ret = AVERROR(EINVAL);
2091 if (avcodec_open(ist->st->codec, codec) < 0) {
2092 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2093 ist->file_index, ist->index);
2094 ret = AVERROR(EINVAL);
2097 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
2098 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2103 for(i=0;i<nb_istreams;i++) {
2106 ist->next_pts = AV_NOPTS_VALUE;
2110 /* set the duration of the output to the duration of the input
2111 * if the output ends up being different, it'll be corrected later */
2112 for (i=0;i<nb_output_files;i++) {
2113 AVFormatContext *out_file = output_files[i];
2114 AVFormatContext *in_file = input_files[i];
2116 if (recording_time != INT64_MAX) {
2117 out_file->duration = recording_time / 1000000 * AV_TIME_BASE;
2119 out_file->duration = in_file->duration;
2123 /* set meta data information from input file if required */
2124 for (i=0;i<nb_meta_data_maps;i++) {
2125 AVFormatContext *out_file;
2126 AVFormatContext *in_file;
2127 AVMetadataTag *mtag;
2129 int out_file_index = meta_data_maps[i].out_file;
2130 int in_file_index = meta_data_maps[i].in_file;
2131 if (out_file_index < 0 || out_file_index >= nb_output_files) {
2132 snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
2133 out_file_index, out_file_index, in_file_index);
2134 ret = AVERROR(EINVAL);
2137 if (in_file_index < 0 || in_file_index >= nb_input_files) {
2138 snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
2139 in_file_index, out_file_index, in_file_index);
2140 ret = AVERROR(EINVAL);
2144 out_file = output_files[out_file_index];
2145 in_file = input_files[in_file_index];
2149 while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2150 av_metadata_set(&out_file->metadata, mtag->key, mtag->value);
2151 av_metadata_conv(out_file, out_file->oformat->metadata_conv,
2152 in_file->iformat->metadata_conv);
2155 /* open files and write file headers */
2156 for(i=0;i<nb_output_files;i++) {
2157 os = output_files[i];
2158 if (av_write_header(os) < 0) {
2159 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2160 ret = AVERROR(EINVAL);
2163 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2169 /* dump the file output parameters - cannot be done before in case
2171 for(i=0;i<nb_output_files;i++) {
2172 dump_format(output_files[i], i, output_files[i]->filename, 1);
2175 /* dump the stream mapping */
2177 fprintf(stderr, "Stream mapping:\n");
2178 for(i=0;i<nb_ostreams;i++) {
2180 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2181 ist_table[ost->source_index]->file_index,
2182 ist_table[ost->source_index]->index,
2185 if (ost->sync_ist != ist_table[ost->source_index])
2186 fprintf(stderr, " [sync #%d.%d]",
2187 ost->sync_ist->file_index,
2188 ost->sync_ist->index);
2189 fprintf(stderr, "\n");
2194 fprintf(stderr, "%s\n", error);
2199 print_sdp(output_files, nb_output_files);
2202 if (!using_stdin && verbose >= 0) {
2203 fprintf(stderr, "Press [q] to stop encoding\n");
2204 url_set_interrupt_cb(decode_interrupt_cb);
2208 timer_start = av_gettime();
2210 for(; received_sigterm == 0;) {
2211 int file_index, ist_index;
2219 /* if 'q' pressed, exits */
2223 /* read_key() returns 0 on EOF */
2229 /* select the stream that we must read now by looking at the
2230 smallest output pts */
2232 for(i=0;i<nb_ostreams;i++) {
2235 os = output_files[ost->file_index];
2236 ist = ist_table[ost->source_index];
2237 if(no_packet[ist->file_index])
2239 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2240 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2242 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2243 ipts = (double)ist->pts;
2244 if (!file_table[ist->file_index].eof_reached){
2245 if(ipts < ipts_min) {
2247 if(input_sync ) file_index = ist->file_index;
2249 if(opts < opts_min) {
2251 if(!input_sync) file_index = ist->file_index;
2254 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2259 /* if none, if is finished */
2260 if (file_index < 0) {
2261 if(no_packet_count){
2263 memset(no_packet, 0, sizeof(no_packet));
2270 /* finish if recording time exhausted */
2271 if (opts_min >= (recording_time / 1000000.0))
2274 /* finish if limit size exhausted */
2275 if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2278 /* read a frame from it and output it in the fifo */
2279 is = input_files[file_index];
2280 ret= av_read_frame(is, &pkt);
2281 if(ret == AVERROR(EAGAIN)){
2282 no_packet[file_index]=1;
2287 file_table[file_index].eof_reached = 1;
2295 memset(no_packet, 0, sizeof(no_packet));
2298 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2300 /* the following test is needed in case new streams appear
2301 dynamically in stream : we ignore them */
2302 if (pkt.stream_index >= file_table[file_index].nb_streams)
2303 goto discard_packet;
2304 ist_index = file_table[file_index].ist_index + pkt.stream_index;
2305 ist = ist_table[ist_index];
2307 goto discard_packet;
2309 if (pkt.dts != AV_NOPTS_VALUE)
2310 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2311 if (pkt.pts != AV_NOPTS_VALUE)
2312 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2314 if(input_files_ts_scale[file_index][pkt.stream_index]){
2315 if(pkt.pts != AV_NOPTS_VALUE)
2316 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2317 if(pkt.dts != AV_NOPTS_VALUE)
2318 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2321 // 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);
2322 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2323 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2324 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2325 int64_t delta= pkt_dts - ist->next_pts;
2326 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2327 input_files_ts_offset[ist->file_index]-= delta;
2329 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2330 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2331 if(pkt.pts != AV_NOPTS_VALUE)
2332 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2336 /* finish if recording time exhausted */
2337 if (pkt.pts * av_q2d(ist->st->time_base) >= (recording_time / 1000000.0))
2338 goto discard_packet;
2340 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2341 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2344 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2345 ist->file_index, ist->index);
2348 av_free_packet(&pkt);
2353 av_free_packet(&pkt);
2355 /* dump report by using the output first video and audio streams */
2356 print_report(output_files, ost_table, nb_ostreams, 0);
2359 /* at the end of stream, we must flush the decoder buffers */
2360 for(i=0;i<nb_istreams;i++) {
2362 if (ist->decoding_needed) {
2363 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2369 /* write the trailer if needed and close file */
2370 for(i=0;i<nb_output_files;i++) {
2371 os = output_files[i];
2372 av_write_trailer(os);
2375 /* dump report by using the first video and audio streams */
2376 print_report(output_files, ost_table, nb_ostreams, 1);
2378 /* close each encoder */
2379 for(i=0;i<nb_ostreams;i++) {
2381 if (ost->encoding_needed) {
2382 av_freep(&ost->st->codec->stats_in);
2383 avcodec_close(ost->st->codec);
2387 /* close each decoder */
2388 for(i=0;i<nb_istreams;i++) {
2390 if (ist->decoding_needed) {
2391 avcodec_close(ist->st->codec);
2399 av_freep(&bit_buffer);
2400 av_free(file_table);
2403 for(i=0;i<nb_istreams;i++) {
2410 for(i=0;i<nb_ostreams;i++) {
2414 fclose(ost->logfile);
2415 ost->logfile = NULL;
2417 av_fifo_free(ost->fifo); /* works even if fifo is not
2418 initialized but set to zero */
2419 av_free(ost->pict_tmp.data[0]);
2420 if (ost->video_resample)
2421 sws_freeContext(ost->img_resample_ctx);
2423 audio_resample_close(ost->resample);
2424 if (ost->reformat_ctx)
2425 av_audio_convert_free(ost->reformat_ctx);
2434 static void opt_format(const char *arg)
2436 /* compatibility stuff for pgmyuv */
2437 if (!strcmp(arg, "pgmyuv")) {
2438 pgmyuv_compatibility_hack=1;
2439 // opt_image_format(arg);
2441 fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2444 last_asked_format = arg;
2447 static void opt_video_rc_override_string(const char *arg)
2449 video_rc_override_string = arg;
2452 static int opt_me_threshold(const char *opt, const char *arg)
2454 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2458 static int opt_verbose(const char *opt, const char *arg)
2460 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2464 static int opt_frame_rate(const char *opt, const char *arg)
2466 if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2467 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2473 static int opt_bitrate(const char *opt, const char *arg)
2475 int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2477 opt_default(opt, arg);
2479 if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2480 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2485 static void opt_frame_crop_top(const char *arg)
2487 frame_topBand = atoi(arg);
2488 if (frame_topBand < 0) {
2489 fprintf(stderr, "Incorrect top crop size\n");
2492 if ((frame_topBand) >= frame_height){
2493 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2496 frame_height -= frame_topBand;
2499 static void opt_frame_crop_bottom(const char *arg)
2501 frame_bottomBand = atoi(arg);
2502 if (frame_bottomBand < 0) {
2503 fprintf(stderr, "Incorrect bottom crop size\n");
2506 if ((frame_bottomBand) >= frame_height){
2507 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2510 frame_height -= frame_bottomBand;
2513 static void opt_frame_crop_left(const char *arg)
2515 frame_leftBand = atoi(arg);
2516 if (frame_leftBand < 0) {
2517 fprintf(stderr, "Incorrect left crop size\n");
2520 if ((frame_leftBand) >= frame_width){
2521 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2524 frame_width -= frame_leftBand;
2527 static void opt_frame_crop_right(const char *arg)
2529 frame_rightBand = atoi(arg);
2530 if (frame_rightBand < 0) {
2531 fprintf(stderr, "Incorrect right crop size\n");
2534 if ((frame_rightBand) >= frame_width){
2535 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2538 frame_width -= frame_rightBand;
2541 static void opt_frame_size(const char *arg)
2543 if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2544 fprintf(stderr, "Incorrect frame size\n");
2549 static void opt_pad_color(const char *arg) {
2550 /* Input is expected to be six hex digits similar to
2551 how colors are expressed in html tags (but without the #) */
2552 int rgb = strtol(arg, NULL, 16);
2556 g = ((rgb >> 8) & 255);
2559 padcolor[0] = RGB_TO_Y(r,g,b);
2560 padcolor[1] = RGB_TO_U(r,g,b,0);
2561 padcolor[2] = RGB_TO_V(r,g,b,0);
2564 static void opt_frame_pad_top(const char *arg)
2566 frame_padtop = atoi(arg);
2567 if (frame_padtop < 0) {
2568 fprintf(stderr, "Incorrect top pad size\n");
2573 static void opt_frame_pad_bottom(const char *arg)
2575 frame_padbottom = atoi(arg);
2576 if (frame_padbottom < 0) {
2577 fprintf(stderr, "Incorrect bottom pad size\n");
2583 static void opt_frame_pad_left(const char *arg)
2585 frame_padleft = atoi(arg);
2586 if (frame_padleft < 0) {
2587 fprintf(stderr, "Incorrect left pad size\n");
2593 static void opt_frame_pad_right(const char *arg)
2595 frame_padright = atoi(arg);
2596 if (frame_padright < 0) {
2597 fprintf(stderr, "Incorrect right pad size\n");
2602 static void opt_frame_pix_fmt(const char *arg)
2604 if (strcmp(arg, "list")) {
2605 frame_pix_fmt = av_get_pix_fmt(arg);
2606 if (frame_pix_fmt == PIX_FMT_NONE) {
2607 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2611 list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2616 static void opt_frame_aspect_ratio(const char *arg)
2623 p = strchr(arg, ':');
2625 x = strtol(arg, &end, 10);
2627 y = strtol(end+1, &end, 10);
2629 ar = (double)x / (double)y;
2631 ar = strtod(arg, NULL);
2634 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2637 frame_aspect_ratio = ar;
2640 static int opt_metadata(const char *opt, const char *arg)
2642 char *mid= strchr(arg, '=');
2645 fprintf(stderr, "Missing =\n");
2651 metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2652 metadata[metadata_count-1].key = av_strdup(arg);
2653 metadata[metadata_count-1].value= av_strdup(mid);
2658 static void opt_qscale(const char *arg)
2660 video_qscale = atof(arg);
2661 if (video_qscale <= 0 ||
2662 video_qscale > 255) {
2663 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2668 static void opt_top_field_first(const char *arg)
2670 top_field_first= atoi(arg);
2673 static int opt_thread_count(const char *opt, const char *arg)
2675 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2678 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2683 static void opt_audio_sample_fmt(const char *arg)
2685 if (strcmp(arg, "list"))
2686 audio_sample_fmt = avcodec_get_sample_fmt(arg);
2688 list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2693 static int opt_audio_rate(const char *opt, const char *arg)
2695 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2699 static int opt_audio_channels(const char *opt, const char *arg)
2701 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2705 static void opt_video_channel(const char *arg)
2707 video_channel = strtol(arg, NULL, 0);
2710 static void opt_video_standard(const char *arg)
2712 video_standard = av_strdup(arg);
2715 static void opt_codec(int *pstream_copy, char **pcodec_name,
2716 int codec_type, const char *arg)
2718 av_freep(pcodec_name);
2719 if (!strcmp(arg, "copy")) {
2722 *pcodec_name = av_strdup(arg);
2726 static void opt_audio_codec(const char *arg)
2728 opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2731 static void opt_audio_tag(const char *arg)
2734 audio_codec_tag= strtol(arg, &tail, 0);
2737 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2740 static void opt_video_tag(const char *arg)
2743 video_codec_tag= strtol(arg, &tail, 0);
2746 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2749 static void opt_video_codec(const char *arg)
2751 opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2754 static void opt_subtitle_codec(const char *arg)
2756 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2759 static void opt_subtitle_tag(const char *arg)
2762 subtitle_codec_tag= strtol(arg, &tail, 0);
2765 subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2768 static void opt_map(const char *arg)
2773 m = &stream_maps[nb_stream_maps++];
2775 m->file_index = strtol(arg, &p, 0);
2779 m->stream_index = strtol(p, &p, 0);
2782 m->sync_file_index = strtol(p, &p, 0);
2785 m->sync_stream_index = strtol(p, &p, 0);
2787 m->sync_file_index = m->file_index;
2788 m->sync_stream_index = m->stream_index;
2792 static void opt_map_meta_data(const char *arg)
2797 m = &meta_data_maps[nb_meta_data_maps++];
2799 m->out_file = strtol(arg, &p, 0);
2803 m->in_file = strtol(p, &p, 0);
2806 static void opt_input_ts_scale(const char *arg)
2808 unsigned int stream;
2812 stream = strtol(arg, &p, 0);
2815 scale= strtod(p, &p);
2817 if(stream >= MAX_STREAMS)
2820 input_files_ts_scale[nb_input_files][stream]= scale;
2823 static int opt_recording_time(const char *opt, const char *arg)
2825 recording_time = parse_time_or_die(opt, arg, 1);
2829 static int opt_start_time(const char *opt, const char *arg)
2831 start_time = parse_time_or_die(opt, arg, 1);
2835 static int opt_rec_timestamp(const char *opt, const char *arg)
2837 rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2841 static int opt_input_ts_offset(const char *opt, const char *arg)
2843 input_ts_offset = parse_time_or_die(opt, arg, 1);
2847 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2849 const char *codec_string = encoder ? "encoder" : "decoder";
2853 return CODEC_ID_NONE;
2855 avcodec_find_encoder_by_name(name) :
2856 avcodec_find_decoder_by_name(name);
2858 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2861 if(codec->type != type) {
2862 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2868 static void opt_input_file(const char *filename)
2870 AVFormatContext *ic;
2871 AVFormatParameters params, *ap = ¶ms;
2872 AVInputFormat *file_iformat = NULL;
2873 int err, i, ret, rfps, rfps_base;
2876 if (last_asked_format) {
2877 file_iformat = av_find_input_format(last_asked_format);
2878 last_asked_format = NULL;
2881 if (!strcmp(filename, "-"))
2884 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2885 !strcmp(filename, "/dev/stdin");
2887 /* get default parameters from command line */
2888 ic = avformat_alloc_context();
2890 print_error(filename, AVERROR(ENOMEM));
2894 memset(ap, 0, sizeof(*ap));
2895 ap->prealloced_context = 1;
2896 ap->sample_rate = audio_sample_rate;
2897 ap->channels = audio_channels;
2898 ap->time_base.den = frame_rate.num;
2899 ap->time_base.num = frame_rate.den;
2900 ap->width = frame_width + frame_padleft + frame_padright;
2901 ap->height = frame_height + frame_padtop + frame_padbottom;
2902 ap->pix_fmt = frame_pix_fmt;
2903 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2904 ap->channel = video_channel;
2905 ap->standard = video_standard;
2907 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2909 ic->video_codec_id = find_codec_or_die(video_codec_name , CODEC_TYPE_VIDEO , 0);
2910 ic->audio_codec_id = find_codec_or_die(audio_codec_name , CODEC_TYPE_AUDIO , 0);
2911 ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2912 ic->flags |= AVFMT_FLAG_NONBLOCK;
2914 if(pgmyuv_compatibility_hack)
2915 ic->video_codec_id= CODEC_ID_PGMYUV;
2917 /* open the input file with generic libav function */
2918 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2920 print_error(filename, err);
2925 for(i=0; i<ic->nb_programs; i++)
2926 if(ic->programs[i]->id != opt_programid)
2927 ic->programs[i]->discard = AVDISCARD_ALL;
2930 ic->loop_input = loop_input;
2932 /* If not enough info to get the stream parameters, we decode the
2933 first frames to get it. (used in mpeg case for example) */
2934 ret = av_find_stream_info(ic);
2935 if (ret < 0 && verbose >= 0) {
2936 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2940 timestamp = start_time;
2941 /* add the stream start time */
2942 if (ic->start_time != AV_NOPTS_VALUE)
2943 timestamp += ic->start_time;
2945 /* if seeking requested, we execute it */
2946 if (start_time != 0) {
2947 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2949 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2950 filename, (double)timestamp / AV_TIME_BASE);
2952 /* reset seek info */
2956 /* update the current parameters so that they match the one of the input stream */
2957 for(i=0;i<ic->nb_streams;i++) {
2958 AVStream *st = ic->streams[i];
2959 AVCodecContext *enc = st->codec;
2960 avcodec_thread_init(enc, thread_count);
2961 switch(enc->codec_type) {
2962 case CODEC_TYPE_AUDIO:
2963 set_context_opts(enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2964 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2965 channel_layout = enc->channel_layout;
2966 audio_channels = enc->channels;
2967 audio_sample_rate = enc->sample_rate;
2968 audio_sample_fmt = enc->sample_fmt;
2969 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
2971 st->discard= AVDISCARD_ALL;
2973 case CODEC_TYPE_VIDEO:
2974 set_context_opts(enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2975 frame_height = enc->height;
2976 frame_width = enc->width;
2977 if(ic->streams[i]->sample_aspect_ratio.num)
2978 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
2980 frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
2981 frame_aspect_ratio *= (float) enc->width / enc->height;
2982 frame_pix_fmt = enc->pix_fmt;
2983 rfps = ic->streams[i]->r_frame_rate.num;
2984 rfps_base = ic->streams[i]->r_frame_rate.den;
2986 enc->flags |= CODEC_FLAG_EMU_EDGE;
2987 frame_height >>= enc->lowres;
2988 frame_width >>= enc->lowres;
2991 enc->debug |= FF_DEBUG_MV;
2993 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2996 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2997 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2999 (float)rfps / rfps_base, rfps, rfps_base);
3001 /* update the current frame rate to match the stream frame rate */
3002 frame_rate.num = rfps;
3003 frame_rate.den = rfps_base;
3005 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
3007 st->discard= AVDISCARD_ALL;
3008 else if(video_discard)
3009 st->discard= video_discard;
3011 case CODEC_TYPE_DATA:
3013 case CODEC_TYPE_SUBTITLE:
3014 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
3015 if(subtitle_disable)
3016 st->discard = AVDISCARD_ALL;
3018 case CODEC_TYPE_ATTACHMENT:
3019 case CODEC_TYPE_UNKNOWN:
3027 input_files[nb_input_files] = ic;
3028 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3029 /* dump the file content */
3031 dump_format(ic, nb_input_files, filename, 0);
3037 av_freep(&video_codec_name);
3038 av_freep(&audio_codec_name);
3039 av_freep(&subtitle_codec_name);
3042 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3043 int *has_subtitle_ptr)
3045 int has_video, has_audio, has_subtitle, i, j;
3046 AVFormatContext *ic;
3051 for(j=0;j<nb_input_files;j++) {
3052 ic = input_files[j];
3053 for(i=0;i<ic->nb_streams;i++) {
3054 AVCodecContext *enc = ic->streams[i]->codec;
3055 switch(enc->codec_type) {
3056 case CODEC_TYPE_AUDIO:
3059 case CODEC_TYPE_VIDEO:
3062 case CODEC_TYPE_SUBTITLE:
3065 case CODEC_TYPE_DATA:
3066 case CODEC_TYPE_ATTACHMENT:
3067 case CODEC_TYPE_UNKNOWN:
3074 *has_video_ptr = has_video;
3075 *has_audio_ptr = has_audio;
3076 *has_subtitle_ptr = has_subtitle;
3079 static void new_video_stream(AVFormatContext *oc)
3082 AVCodecContext *video_enc;
3083 enum CodecID codec_id;
3085 st = av_new_stream(oc, oc->nb_streams);
3087 fprintf(stderr, "Could not alloc stream\n");
3090 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
3091 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3092 video_bitstream_filters= NULL;
3094 avcodec_thread_init(st->codec, thread_count);
3096 video_enc = st->codec;
3099 video_enc->codec_tag= video_codec_tag;
3101 if( (video_global_header&1)
3102 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3103 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3104 avcodec_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3106 if(video_global_header&2){
3107 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3108 avcodec_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3111 if (video_stream_copy) {
3112 st->stream_copy = 1;
3113 video_enc->codec_type = CODEC_TYPE_VIDEO;
3114 video_enc->sample_aspect_ratio =
3115 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3120 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3122 if (video_codec_name) {
3123 codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3124 codec = avcodec_find_encoder_by_name(video_codec_name);
3125 output_codecs[nb_ocodecs] = codec;
3127 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3128 codec = avcodec_find_encoder(codec_id);
3131 video_enc->codec_id = codec_id;
3133 set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3135 if (codec && codec->supported_framerates && !force_fps)
3136 fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3137 video_enc->time_base.den = fps.num;
3138 video_enc->time_base.num = fps.den;
3140 video_enc->width = frame_width + frame_padright + frame_padleft;
3141 video_enc->height = frame_height + frame_padtop + frame_padbottom;
3142 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3143 video_enc->pix_fmt = frame_pix_fmt;
3144 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3146 if(codec && codec->pix_fmts){
3147 const enum PixelFormat *p= codec->pix_fmts;
3149 if(*p == video_enc->pix_fmt)
3153 video_enc->pix_fmt = codec->pix_fmts[0];
3157 video_enc->gop_size = 0;
3158 if (video_qscale || same_quality) {
3159 video_enc->flags |= CODEC_FLAG_QSCALE;
3160 video_enc->global_quality=
3161 st->quality = FF_QP2LAMBDA * video_qscale;
3165 video_enc->intra_matrix = intra_matrix;
3167 video_enc->inter_matrix = inter_matrix;
3169 p= video_rc_override_string;
3172 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3174 fprintf(stderr, "error parsing rc_override\n");
3177 video_enc->rc_override=
3178 av_realloc(video_enc->rc_override,
3179 sizeof(RcOverride)*(i+1));
3180 video_enc->rc_override[i].start_frame= start;
3181 video_enc->rc_override[i].end_frame = end;
3183 video_enc->rc_override[i].qscale= q;
3184 video_enc->rc_override[i].quality_factor= 1.0;
3187 video_enc->rc_override[i].qscale= 0;
3188 video_enc->rc_override[i].quality_factor= -q/100.0;
3193 video_enc->rc_override_count=i;
3194 if (!video_enc->rc_initial_buffer_occupancy)
3195 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3196 video_enc->me_threshold= me_threshold;
3197 video_enc->intra_dc_precision= intra_dc_precision - 8;
3200 video_enc->flags|= CODEC_FLAG_PSNR;
3205 video_enc->flags |= CODEC_FLAG_PASS1;
3207 video_enc->flags |= CODEC_FLAG_PASS2;
3212 if (video_language) {
3213 av_metadata_set(&st->metadata, "language", video_language);
3214 av_freep(&video_language);
3217 /* reset some key parameters */
3219 av_freep(&video_codec_name);
3220 video_stream_copy = 0;
3223 static void new_audio_stream(AVFormatContext *oc)
3226 AVCodecContext *audio_enc;
3227 enum CodecID codec_id;
3229 st = av_new_stream(oc, oc->nb_streams);
3231 fprintf(stderr, "Could not alloc stream\n");
3234 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3236 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3237 audio_bitstream_filters= NULL;
3239 avcodec_thread_init(st->codec, thread_count);
3241 audio_enc = st->codec;
3242 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3245 audio_enc->codec_tag= audio_codec_tag;
3247 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3248 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3249 avcodec_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3251 if (audio_stream_copy) {
3252 st->stream_copy = 1;
3253 audio_enc->channels = audio_channels;
3257 set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3259 if (audio_codec_name) {
3260 codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3261 codec = avcodec_find_encoder_by_name(audio_codec_name);
3262 output_codecs[nb_ocodecs] = codec;
3264 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3265 codec = avcodec_find_encoder(codec_id);
3267 audio_enc->codec_id = codec_id;
3269 if (audio_qscale > QSCALE_NONE) {
3270 audio_enc->flags |= CODEC_FLAG_QSCALE;
3271 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3273 audio_enc->channels = audio_channels;
3274 audio_enc->sample_fmt = audio_sample_fmt;
3275 audio_enc->channel_layout = channel_layout;
3276 if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3277 audio_enc->channel_layout = 0;
3279 if(codec && codec->sample_fmts){
3280 const enum SampleFormat *p= codec->sample_fmts;
3282 if(*p == audio_enc->sample_fmt)
3286 audio_enc->sample_fmt = codec->sample_fmts[0];
3290 audio_enc->sample_rate = audio_sample_rate;
3291 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3292 if (audio_language) {
3293 av_metadata_set(&st->metadata, "language", audio_language);
3294 av_freep(&audio_language);
3297 /* reset some key parameters */
3299 av_freep(&audio_codec_name);
3300 audio_stream_copy = 0;
3303 static void new_subtitle_stream(AVFormatContext *oc)
3306 AVCodecContext *subtitle_enc;
3308 st = av_new_stream(oc, oc->nb_streams);
3310 fprintf(stderr, "Could not alloc stream\n");
3313 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3315 bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3316 subtitle_bitstream_filters= NULL;
3318 subtitle_enc = st->codec;
3319 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3321 if(subtitle_codec_tag)
3322 subtitle_enc->codec_tag= subtitle_codec_tag;
3324 if (subtitle_stream_copy) {
3325 st->stream_copy = 1;
3327 set_context_opts(avcodec_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3328 subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3329 output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3333 if (subtitle_language) {
3334 av_metadata_set(&st->metadata, "language", subtitle_language);
3335 av_freep(&subtitle_language);
3338 subtitle_disable = 0;
3339 av_freep(&subtitle_codec_name);
3340 subtitle_stream_copy = 0;
3343 static void opt_new_audio_stream(void)
3345 AVFormatContext *oc;
3346 if (nb_output_files <= 0) {
3347 fprintf(stderr, "At least one output file must be specified\n");
3350 oc = output_files[nb_output_files - 1];
3351 new_audio_stream(oc);
3354 static void opt_new_video_stream(void)
3356 AVFormatContext *oc;
3357 if (nb_output_files <= 0) {
3358 fprintf(stderr, "At least one output file must be specified\n");
3361 oc = output_files[nb_output_files - 1];
3362 new_video_stream(oc);
3365 static void opt_new_subtitle_stream(void)
3367 AVFormatContext *oc;
3368 if (nb_output_files <= 0) {
3369 fprintf(stderr, "At least one output file must be specified\n");
3372 oc = output_files[nb_output_files - 1];
3373 new_subtitle_stream(oc);
3376 static void opt_output_file(const char *filename)
3378 AVFormatContext *oc;
3379 int use_video, use_audio, use_subtitle;
3380 int input_has_video, input_has_audio, input_has_subtitle;
3381 AVFormatParameters params, *ap = ¶ms;
3382 AVOutputFormat *file_oformat;
3384 if (!strcmp(filename, "-"))
3387 oc = avformat_alloc_context();
3389 print_error(filename, AVERROR(ENOMEM));
3393 if (last_asked_format) {
3394 file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3395 if (!file_oformat) {
3396 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3399 last_asked_format = NULL;
3401 file_oformat = av_guess_format(NULL, filename, NULL);
3402 if (!file_oformat) {
3403 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3409 oc->oformat = file_oformat;
3410 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3412 if (!strcmp(file_oformat->name, "ffm") &&
3413 av_strstart(filename, "http:", NULL)) {
3414 /* special case for files sent to ffserver: we get the stream
3415 parameters from ffserver */
3416 int err = read_ffserver_streams(oc, filename);
3418 print_error(filename, err);
3422 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3423 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3424 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3426 /* disable if no corresponding type found and at least one
3428 if (nb_input_files > 0) {
3429 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3430 &input_has_subtitle);
3431 if (!input_has_video)
3433 if (!input_has_audio)
3435 if (!input_has_subtitle)
3439 /* manual disable */
3440 if (audio_disable) {
3443 if (video_disable) {
3446 if (subtitle_disable) {
3451 new_video_stream(oc);
3455 new_audio_stream(oc);
3459 new_subtitle_stream(oc);
3462 oc->timestamp = rec_timestamp;
3464 for(; metadata_count>0; metadata_count--){
3465 av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3466 metadata[metadata_count-1].value);
3468 av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3471 output_files[nb_output_files++] = oc;
3473 /* check filename in case of an image number is expected */
3474 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3475 if (!av_filename_number_test(oc->filename)) {
3476 print_error(oc->filename, AVERROR_NUMEXPECTED);
3481 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3482 /* test if it already exists to avoid loosing precious files */
3483 if (!file_overwrite &&
3484 (strchr(filename, ':') == NULL ||
3485 filename[1] == ':' ||
3486 av_strstart(filename, "file:", NULL))) {
3487 if (url_exist(filename)) {
3489 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3491 if (!read_yesno()) {
3492 fprintf(stderr, "Not overwriting - exiting\n");
3497 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3504 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3505 fprintf(stderr, "Could not open '%s'\n", filename);
3510 memset(ap, 0, sizeof(*ap));
3511 if (av_set_parameters(oc, ap) < 0) {
3512 fprintf(stderr, "%s: Invalid encoding parameters\n",
3517 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3518 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3519 oc->loop_output = loop_output;
3520 oc->flags |= AVFMT_FLAG_NONBLOCK;
3522 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3525 /* same option as mencoder */
3526 static void opt_pass(const char *pass_str)
3529 pass = atoi(pass_str);
3530 if (pass != 1 && pass != 2) {
3531 fprintf(stderr, "pass number can be only 1 or 2\n");
3537 static int64_t getutime(void)
3540 struct rusage rusage;
3542 getrusage(RUSAGE_SELF, &rusage);
3543 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3544 #elif HAVE_GETPROCESSTIMES
3546 FILETIME c, e, k, u;
3547 proc = GetCurrentProcess();
3548 GetProcessTimes(proc, &c, &e, &k, &u);
3549 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3551 return av_gettime();
3555 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3558 const char *p = str;
3565 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3572 static void opt_inter_matrix(const char *arg)
3574 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3575 parse_matrix_coeffs(inter_matrix, arg);
3578 static void opt_intra_matrix(const char *arg)
3580 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3581 parse_matrix_coeffs(intra_matrix, arg);
3585 * Trivial log callback.
3586 * Only suitable for show_help and similar since it lacks prefix handling.
3588 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3590 vfprintf(stdout, fmt, vl);
3593 static void show_usage(void)
3595 printf("Hyper fast Audio and Video encoder\n");
3596 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3600 static void show_help(void)
3602 av_log_set_callback(log_callback_help);
3604 show_help_options(options, "Main options:\n",
3605 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3606 show_help_options(options, "\nAdvanced options:\n",
3607 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3609 show_help_options(options, "\nVideo options:\n",
3610 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3612 show_help_options(options, "\nAdvanced Video options:\n",
3613 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3614 OPT_VIDEO | OPT_EXPERT);
3615 show_help_options(options, "\nAudio options:\n",
3616 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3618 show_help_options(options, "\nAdvanced Audio options:\n",
3619 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3620 OPT_AUDIO | OPT_EXPERT);
3621 show_help_options(options, "\nSubtitle options:\n",
3622 OPT_SUBTITLE | OPT_GRAB,
3624 show_help_options(options, "\nAudio/Video grab options:\n",
3628 av_opt_show(avcodec_opts[0], NULL);
3630 av_opt_show(avformat_opts, NULL);
3632 av_opt_show(sws_opts, NULL);
3635 static void opt_target(const char *arg)
3637 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3638 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3640 if(!strncmp(arg, "pal-", 4)) {
3643 } else if(!strncmp(arg, "ntsc-", 5)) {
3646 } else if(!strncmp(arg, "film-", 5)) {
3651 /* Calculate FR via float to avoid int overflow */
3652 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3655 } else if((fr == 29970) || (fr == 23976)) {
3658 /* Try to determine PAL/NTSC by peeking in the input files */
3659 if(nb_input_files) {
3661 for(j = 0; j < nb_input_files; j++) {
3662 for(i = 0; i < input_files[j]->nb_streams; i++) {
3663 AVCodecContext *c = input_files[j]->streams[i]->codec;
3664 if(c->codec_type != CODEC_TYPE_VIDEO)
3666 fr = c->time_base.den * 1000 / c->time_base.num;
3670 } else if((fr == 29970) || (fr == 23976)) {
3680 if(verbose && norm != UNKNOWN)
3681 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3684 if(norm == UNKNOWN) {
3685 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3686 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3687 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3691 if(!strcmp(arg, "vcd")) {
3693 opt_video_codec("mpeg1video");
3694 opt_audio_codec("mp2");
3697 opt_frame_size(norm == PAL ? "352x288" : "352x240");
3698 opt_frame_rate(NULL, frame_rates[norm]);
3699 opt_default("g", norm == PAL ? "15" : "18");
3701 opt_default("b", "1150000");
3702 opt_default("maxrate", "1150000");
3703 opt_default("minrate", "1150000");
3704 opt_default("bufsize", "327680"); // 40*1024*8;
3706 opt_default("ab", "224000");
3707 audio_sample_rate = 44100;
3710 opt_default("packetsize", "2324");
3711 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3713 /* We have to offset the PTS, so that it is consistent with the SCR.
3714 SCR starts at 36000, but the first two packs contain only padding
3715 and the first pack from the other stream, respectively, may also have
3716 been written before.
3717 So the real data starts at SCR 36000+3*1200. */
3718 mux_preload= (36000+3*1200) / 90000.0; //0.44
3719 } else if(!strcmp(arg, "svcd")) {
3721 opt_video_codec("mpeg2video");
3722 opt_audio_codec("mp2");
3725 opt_frame_size(norm == PAL ? "480x576" : "480x480");
3726 opt_frame_rate(NULL, frame_rates[norm]);
3727 opt_default("g", norm == PAL ? "15" : "18");
3729 opt_default("b", "2040000");
3730 opt_default("maxrate", "2516000");
3731 opt_default("minrate", "0"); //1145000;
3732 opt_default("bufsize", "1835008"); //224*1024*8;
3733 opt_default("flags", "+scan_offset");
3736 opt_default("ab", "224000");
3737 audio_sample_rate = 44100;
3739 opt_default("packetsize", "2324");
3741 } else if(!strcmp(arg, "dvd")) {
3743 opt_video_codec("mpeg2video");
3744 opt_audio_codec("ac3");
3747 opt_frame_size(norm == PAL ? "720x576" : "720x480");
3748 opt_frame_rate(NULL, frame_rates[norm]);
3749 opt_default("g", norm == PAL ? "15" : "18");
3751 opt_default("b", "6000000");
3752 opt_default("maxrate", "9000000");
3753 opt_default("minrate", "0"); //1500000;
3754 opt_default("bufsize", "1835008"); //224*1024*8;
3756 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3757 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3759 opt_default("ab", "448000");
3760 audio_sample_rate = 48000;
3762 } else if(!strncmp(arg, "dv", 2)) {
3766 opt_frame_size(norm == PAL ? "720x576" : "720x480");
3767 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3768 (norm == PAL ? "yuv420p" : "yuv411p"));
3769 opt_frame_rate(NULL, frame_rates[norm]);
3771 audio_sample_rate = 48000;
3775 fprintf(stderr, "Unknown target: %s\n", arg);
3780 static void opt_vstats_file (const char *arg)
3782 av_free (vstats_filename);
3783 vstats_filename=av_strdup (arg);
3786 static void opt_vstats (void)
3789 time_t today2 = time(NULL);
3790 struct tm *today = localtime(&today2);
3792 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3794 opt_vstats_file(filename);
3797 static int opt_bsf(const char *opt, const char *arg)
3799 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3800 AVBitStreamFilterContext **bsfp;
3803 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3807 bsfp= *opt == 'v' ? &video_bitstream_filters :
3808 *opt == 'a' ? &audio_bitstream_filters :
3809 &subtitle_bitstream_filters;
3811 bsfp= &(*bsfp)->next;
3818 static int opt_preset(const char *opt, const char *arg)
3821 char filename[1000], tmp[1000], tmp2[1000], line[1000];
3823 const char *base[2]= { getenv("HOME"),
3828 for(i=!base[0]; i<2 && !f; i++){
3829 snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
3830 f= fopen(filename, "r");
3832 char *codec_name= *opt == 'v' ? video_codec_name :
3833 *opt == 'a' ? audio_codec_name :
3834 subtitle_codec_name;
3835 snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i], i ? "" : "/.ffmpeg", codec_name, arg);
3836 f= fopen(filename, "r");
3840 av_strlcpy(filename, arg, sizeof(filename));
3841 f= fopen(filename, "r");
3845 fprintf(stderr, "File for preset '%s' not found\n", arg);
3850 int e= fscanf(f, "%999[^\n]\n", line) - 1;
3851 if(line[0] == '#' && !e)
3853 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3855 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3858 if(!strcmp(tmp, "acodec")){
3859 opt_audio_codec(tmp2);
3860 }else if(!strcmp(tmp, "vcodec")){
3861 opt_video_codec(tmp2);
3862 }else if(!strcmp(tmp, "scodec")){
3863 opt_subtitle_codec(tmp2);
3864 }else if(opt_default(tmp, tmp2) < 0){
3865 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3875 static const OptionDef options[] = {
3877 #include "cmdutils_common_opts.h"
3878 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3879 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3880 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3881 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3882 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3883 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3884 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3885 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3886 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3887 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
3888 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_rec_timestamp}, "set the timestamp ('now' to set the current time)", "time" },
3889 { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
3890 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3891 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3892 "add timings for benchmarking" },
3893 { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
3894 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3895 "dump each input packet" },
3896 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3897 "when dumping packets, also dump the payload" },
3898 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3899 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3900 { "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)", "" },
3901 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
3902 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3903 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3904 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3905 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3906 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3907 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3908 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3909 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3910 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3911 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3912 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
3913 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
3916 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3917 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3918 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3919 { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3920 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3921 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3922 { "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" },
3923 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3924 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3925 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3926 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3927 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3928 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3929 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3930 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3931 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3932 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3933 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3934 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3935 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3936 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3937 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3938 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
3939 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3940 "use same video quality as source (implies VBR)" },
3941 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3942 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
3943 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3944 "deinterlace pictures" },
3945 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3946 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3947 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3948 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3949 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3950 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3951 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3952 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3953 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3954 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
3955 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3956 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
3959 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3960 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3961 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3962 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3963 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3964 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3965 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3966 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3967 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3968 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3969 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3970 { "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" },
3972 /* subtitle options */
3973 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3974 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3975 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3976 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3977 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
3980 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3981 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3982 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3985 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3986 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3988 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3989 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3990 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3992 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3993 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3994 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3995 { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
3997 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4001 int main(int argc, char **argv)
4006 avcodec_register_all();
4007 avdevice_register_all();
4011 if(isatty(STDIN_FILENO))
4012 url_set_interrupt_cb(decode_interrupt_cb);
4015 for(i=0; i<CODEC_TYPE_NB; i++){
4016 avcodec_opts[i]= avcodec_alloc_context2(i);
4018 avformat_opts = avformat_alloc_context();
4019 sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
4024 parse_options(argc, argv, options, opt_output_file);
4026 if(nb_output_files <= 0 && nb_input_files == 0) {
4028 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4032 /* file converter / grab */
4033 if (nb_output_files <= 0) {
4034 fprintf(stderr, "At least one output file must be specified\n");
4038 if (nb_input_files == 0) {
4039 fprintf(stderr, "At least one input file must be specified\n");
4044 if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
4045 stream_maps, nb_stream_maps) < 0)
4047 ti = getutime() - ti;
4049 printf("bench: utime=%0.3fs\n", ti / 1000000.0);