3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 /* needed for usleep() */
23 #define _XOPEN_SOURCE 600
34 #include "libavformat/avformat.h"
35 #include "libavdevice/avdevice.h"
36 #include "libswscale/swscale.h"
37 #include "libavcodec/opt.h"
38 #include "libavcodec/audioconvert.h"
39 #include "libavcodec/colorspace.h"
40 #include "libavutil/fifo.h"
41 #include "libavutil/avstring.h"
42 #include "libavformat/os_support.h"
44 #if HAVE_SYS_RESOURCE_H
45 #include <sys/types.h>
46 #include <sys/resource.h>
47 #elif HAVE_GETPROCESSTIMES
52 #include <sys/select.h>
57 #include <sys/ioctl.h>
63 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
73 const char program_name[] = "FFmpeg";
74 const int program_birth_year = 2000;
76 /* select an input stream for an output stream */
77 typedef struct AVStreamMap {
81 int sync_stream_index;
84 /** select an input file for an output file */
85 typedef struct AVMetaDataMap {
90 static const OptionDef options[];
94 static const char *last_asked_format = NULL;
95 static AVFormatContext *input_files[MAX_FILES];
96 static int64_t input_files_ts_offset[MAX_FILES];
97 static double input_files_ts_scale[MAX_FILES][MAX_STREAMS];
98 static AVCodec *input_codecs[MAX_FILES*MAX_STREAMS];
99 static int nb_input_files = 0;
100 static int nb_icodecs;
102 static AVFormatContext *output_files[MAX_FILES];
103 static AVCodec *output_codecs[MAX_FILES*MAX_STREAMS];
104 static int nb_output_files = 0;
105 static int nb_ocodecs;
107 static AVStreamMap stream_maps[MAX_FILES*MAX_STREAMS];
108 static int nb_stream_maps;
110 static AVMetaDataMap meta_data_maps[MAX_FILES];
111 static int nb_meta_data_maps;
113 static int frame_width = 0;
114 static int frame_height = 0;
115 static float frame_aspect_ratio = 0;
116 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
117 static enum SampleFormat audio_sample_fmt = SAMPLE_FMT_NONE;
118 static int frame_padtop = 0;
119 static int frame_padbottom = 0;
120 static int frame_padleft = 0;
121 static int frame_padright = 0;
122 static int padcolor[3] = {16,128,128}; /* default to black */
123 static int frame_topBand = 0;
124 static int frame_bottomBand = 0;
125 static int frame_leftBand = 0;
126 static int frame_rightBand = 0;
127 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
128 static AVRational frame_rate;
129 static float video_qscale = 0;
130 static uint16_t *intra_matrix = NULL;
131 static uint16_t *inter_matrix = NULL;
132 static const char *video_rc_override_string=NULL;
133 static int video_disable = 0;
134 static int video_discard = 0;
135 static char *video_codec_name = NULL;
136 static int video_codec_tag = 0;
137 static char *video_language = NULL;
138 static int same_quality = 0;
139 static int do_deinterlace = 0;
140 static int top_field_first = -1;
141 static int me_threshold = 0;
142 static int intra_dc_precision = 8;
143 static int loop_input = 0;
144 static int loop_output = AVFMT_NOOUTPUTLOOP;
145 static int qp_hist = 0;
147 static int intra_only = 0;
148 static int audio_sample_rate = 44100;
149 static int64_t channel_layout = 0;
150 #define QSCALE_NONE -99999
151 static float audio_qscale = QSCALE_NONE;
152 static int audio_disable = 0;
153 static int audio_channels = 1;
154 static char *audio_codec_name = NULL;
155 static int audio_codec_tag = 0;
156 static char *audio_language = NULL;
158 static int subtitle_disable = 0;
159 static char *subtitle_codec_name = NULL;
160 static char *subtitle_language = NULL;
161 static int subtitle_codec_tag = 0;
163 static float mux_preload= 0.5;
164 static float mux_max_delay= 0.7;
166 static int64_t recording_time = INT64_MAX;
167 static int64_t start_time = 0;
168 static int64_t rec_timestamp = 0;
169 static int64_t input_ts_offset = 0;
170 static int file_overwrite = 0;
171 static int metadata_count;
172 static AVMetadataTag *metadata;
173 static int do_benchmark = 0;
174 static int do_hex_dump = 0;
175 static int do_pkt_dump = 0;
176 static int do_psnr = 0;
177 static int do_pass = 0;
178 static char *pass_logfilename_prefix = NULL;
179 static int audio_stream_copy = 0;
180 static int video_stream_copy = 0;
181 static int subtitle_stream_copy = 0;
182 static int video_sync_method= -1;
183 static int audio_sync_method= 0;
184 static float audio_drift_threshold= 0.1;
185 static int copy_ts= 0;
186 static int opt_shortest = 0;
187 static int video_global_header = 0;
188 static char *vstats_filename;
189 static FILE *vstats_file;
190 static int opt_programid = 0;
191 static int copy_initial_nonkeyframes = 0;
193 static int rate_emu = 0;
195 static int video_channel = 0;
196 static char *video_standard;
198 static int audio_volume = 256;
200 static int exit_on_error = 0;
201 static int using_stdin = 0;
202 static int verbose = 1;
203 static int thread_count= 1;
204 static int q_pressed = 0;
205 static int64_t video_size = 0;
206 static int64_t audio_size = 0;
207 static int64_t extra_size = 0;
208 static int nb_frames_dup = 0;
209 static int nb_frames_drop = 0;
210 static int input_sync;
211 static uint64_t limit_filesize = 0;
212 static int force_fps = 0;
214 static int pgmyuv_compatibility_hack=0;
215 static float dts_delta_threshold = 10;
217 static unsigned int sws_flags = SWS_BICUBIC;
219 static int64_t timer_start;
221 static uint8_t *audio_buf;
222 static uint8_t *audio_out;
223 unsigned int allocated_audio_out_size, allocated_audio_buf_size;
225 static short *samples;
227 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
228 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
229 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
230 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
232 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
234 struct AVInputStream;
236 typedef struct AVOutputStream {
237 int file_index; /* file index */
238 int index; /* stream index in the output file */
239 int source_index; /* AVInputStream index */
240 AVStream *st; /* stream in the output file */
241 int encoding_needed; /* true if encoding needed for this stream */
243 /* input pts and corresponding output pts
245 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
246 struct AVInputStream *sync_ist; /* input stream to sync against */
247 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
250 AVFrame pict_tmp; /* temporary image for resampling */
251 struct SwsContext *img_resample_ctx; /* for image resampling */
254 int resample_pix_fmt;
256 /* full frame size of first frame */
260 /* cropping area sizes */
267 /* cropping area of first frame */
268 int original_topBand;
269 int original_bottomBand;
270 int original_leftBand;
271 int original_rightBand;
273 /* padding area sizes */
282 ReSampleContext *resample; /* for audio resampling */
284 AVAudioConvert *reformat_ctx;
285 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
289 typedef struct AVInputStream {
293 int discard; /* true if stream data should be discarded */
294 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
295 int64_t sample_index; /* current sample */
297 int64_t start; /* time when read started */
298 int64_t next_pts; /* synthetic pts for cases where pkt.pts
300 int64_t pts; /* current pts */
301 int is_start; /* is 1 at the start and after a discontinuity */
304 typedef struct AVInputFile {
305 int eof_reached; /* true if eof reached */
306 int ist_index; /* index of first stream in ist_table */
307 int buffer_size; /* current total buffer size */
308 int nb_streams; /* nb streams we are aware of */
313 /* init terminal so that we can grab keys */
314 static struct termios oldtty;
317 static void term_exit(void)
320 tcsetattr (0, TCSANOW, &oldtty);
324 static volatile int received_sigterm = 0;
327 sigterm_handler(int sig)
329 received_sigterm = sig;
333 static void term_init(void)
341 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
342 |INLCR|IGNCR|ICRNL|IXON);
343 tty.c_oflag |= OPOST;
344 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
345 tty.c_cflag &= ~(CSIZE|PARENB);
350 tcsetattr (0, TCSANOW, &tty);
351 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
354 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
355 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
357 signal(SIGXCPU, sigterm_handler);
361 register a function to be called at normal program termination
364 #if CONFIG_BEOS_NETSERVER
365 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
369 /* read a key without blocking */
370 static int read_key(void)
375 #if !CONFIG_BEOS_NETSERVER
383 n = select(1, &rfds, NULL, NULL, &tv);
399 static int decode_interrupt_cb(void)
401 return q_pressed || (q_pressed = read_key() == 'q');
404 static int av_exit(int ret)
409 for(i=0;i<nb_output_files;i++) {
410 /* maybe av_close_output_file ??? */
411 AVFormatContext *s = output_files[i];
413 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
415 for(j=0;j<s->nb_streams;j++) {
416 av_metadata_free(&s->streams[j]->metadata);
417 av_free(s->streams[j]->codec);
418 av_free(s->streams[j]);
420 for(j=0;j<s->nb_programs;j++) {
421 av_metadata_free(&s->programs[j]->metadata);
423 for(j=0;j<s->nb_chapters;j++) {
424 av_metadata_free(&s->chapters[j]->metadata);
426 av_metadata_free(&s->metadata);
429 for(i=0;i<nb_input_files;i++)
430 av_close_input_file(input_files[i]);
432 av_free(intra_matrix);
433 av_free(inter_matrix);
437 av_free(vstats_filename);
441 av_free(video_codec_name);
442 av_free(audio_codec_name);
443 av_free(subtitle_codec_name);
445 av_free(video_standard);
447 #if CONFIG_POWERPC_PERF
448 void powerpc_display_perf_report(void);
449 powerpc_display_perf_report();
450 #endif /* CONFIG_POWERPC_PERF */
452 for (i=0;i<CODEC_TYPE_NB;i++)
453 av_free(avcodec_opts[i]);
454 av_free(avformat_opts);
458 allocated_audio_buf_size= allocated_audio_out_size= 0;
461 if (received_sigterm) {
463 "Received signal %d: terminating.\n",
464 (int) received_sigterm);
468 exit(ret); /* not all OS-es handle main() return value */
472 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
478 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
481 /* copy stream format */
482 s->nb_streams = ic->nb_streams;
483 for(i=0;i<ic->nb_streams;i++) {
486 // FIXME: a more elegant solution is needed
487 st = av_mallocz(sizeof(AVStream));
488 memcpy(st, ic->streams[i], sizeof(AVStream));
489 st->codec = avcodec_alloc_context();
491 print_error(filename, AVERROR(ENOMEM));
494 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
497 if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
499 else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
502 if(!st->codec->thread_count)
503 st->codec->thread_count = 1;
504 if(st->codec->thread_count>1)
505 avcodec_thread_init(st->codec, st->codec->thread_count);
507 if(st->codec->flags & CODEC_FLAG_BITEXACT)
512 s->timestamp = av_gettime();
514 av_close_input_file(ic);
519 get_sync_ipts(const AVOutputStream *ost)
521 const AVInputStream *ist = ost->sync_ist;
522 return (double)(ist->pts - start_time)/AV_TIME_BASE;
525 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
529 AVPacket new_pkt= *pkt;
530 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
531 &new_pkt.data, &new_pkt.size,
532 pkt->data, pkt->size,
533 pkt->flags & PKT_FLAG_KEY);
536 new_pkt.destruct= av_destruct_packet;
538 fprintf(stderr, "%s failed for stream %d, codec %s",
539 bsfc->filter->name, pkt->stream_index,
540 avctx->codec ? avctx->codec->name : "copy");
550 ret= av_interleaved_write_frame(s, pkt);
552 print_error("av_interleaved_write_frame()", ret);
557 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
559 static void do_audio_out(AVFormatContext *s,
562 unsigned char *buf, int size)
565 int64_t audio_out_size, audio_buf_size;
566 int64_t allocated_for_size= size;
568 int size_out, frame_bytes, ret;
569 AVCodecContext *enc= ost->st->codec;
570 AVCodecContext *dec= ist->st->codec;
571 int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
572 int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
573 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
576 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
577 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
578 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
579 audio_buf_size*= osize*enc->channels;
581 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
582 if(coded_bps > 8*osize)
583 audio_out_size= audio_out_size * coded_bps / (8*osize);
584 audio_out_size += FF_MIN_BUFFER_SIZE;
586 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
587 fprintf(stderr, "Buffer sizes too large\n");
591 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
592 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
593 if (!audio_buf || !audio_out){
594 fprintf(stderr, "Out of memory in do_audio_out\n");
598 if (enc->channels != dec->channels)
599 ost->audio_resample = 1;
601 if (ost->audio_resample && !ost->resample) {
602 if (dec->sample_fmt != SAMPLE_FMT_S16)
603 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
604 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
605 enc->sample_rate, dec->sample_rate,
606 enc->sample_fmt, dec->sample_fmt,
608 if (!ost->resample) {
609 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
610 dec->channels, dec->sample_rate,
611 enc->channels, enc->sample_rate);
616 #define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
617 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
618 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
619 if (ost->reformat_ctx)
620 av_audio_convert_free(ost->reformat_ctx);
621 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
622 dec->sample_fmt, 1, NULL, 0);
623 if (!ost->reformat_ctx) {
624 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
625 avcodec_get_sample_fmt_name(dec->sample_fmt),
626 avcodec_get_sample_fmt_name(enc->sample_fmt));
629 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
632 if(audio_sync_method){
633 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
634 - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2);
635 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
636 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
638 //FIXME resample delay
639 if(fabs(delta) > 50){
640 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
642 byte_delta= FFMAX(byte_delta, -size);
646 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
651 static uint8_t *input_tmp= NULL;
652 input_tmp= av_realloc(input_tmp, byte_delta + size);
654 if(byte_delta > allocated_for_size - size){
655 allocated_for_size= byte_delta + (int64_t)size;
660 memset(input_tmp, 0, byte_delta);
661 memcpy(input_tmp + byte_delta, buf, size);
665 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
667 }else if(audio_sync_method>1){
668 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
669 assert(ost->audio_resample);
671 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
672 // 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));
673 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
677 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
678 - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
680 if (ost->audio_resample) {
682 size_out = audio_resample(ost->resample,
683 (short *)buftmp, (short *)buf,
684 size / (ist->st->codec->channels * isize));
685 size_out = size_out * enc->channels * osize;
691 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
692 const void *ibuf[6]= {buftmp};
693 void *obuf[6]= {audio_buf};
694 int istride[6]= {isize};
695 int ostride[6]= {osize};
696 int len= size_out/istride[0];
697 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
698 printf("av_audio_convert() failed\n");
704 size_out = len*osize;
707 /* now encode as many frames as possible */
708 if (enc->frame_size > 1) {
709 /* output resampled raw samples */
710 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
711 fprintf(stderr, "av_fifo_realloc2() failed\n");
714 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
716 frame_bytes = enc->frame_size * osize * enc->channels;
718 while (av_fifo_size(ost->fifo) >= frame_bytes) {
720 av_init_packet(&pkt);
722 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
724 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
726 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
729 fprintf(stderr, "Audio encoding failed\n");
733 pkt.stream_index= ost->index;
736 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
737 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
738 pkt.flags |= PKT_FLAG_KEY;
739 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
741 ost->sync_opts += enc->frame_size;
745 av_init_packet(&pkt);
747 ost->sync_opts += size_out / (osize * enc->channels);
749 /* output a pcm frame */
750 /* determine the size of the coded buffer */
753 size_out = size_out*coded_bps/8;
755 if(size_out > audio_out_size){
756 fprintf(stderr, "Internal error, buffer size too small\n");
760 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
761 ret = avcodec_encode_audio(enc, audio_out, size_out,
764 fprintf(stderr, "Audio encoding failed\n");
768 pkt.stream_index= ost->index;
771 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
772 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
773 pkt.flags |= PKT_FLAG_KEY;
774 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
778 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
782 AVPicture picture_tmp;
785 dec = ist->st->codec;
787 /* deinterlace : must be done before any resize */
788 if (do_deinterlace) {
791 /* create temporary picture */
792 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
793 buf = av_malloc(size);
797 picture2 = &picture_tmp;
798 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
800 if(avpicture_deinterlace(picture2, picture,
801 dec->pix_fmt, dec->width, dec->height) < 0) {
802 /* if error, do not deinterlace */
803 fprintf(stderr, "Deinterlacing failed\n");
812 if (picture != picture2)
813 *picture = *picture2;
817 /* we begin to correct av delay at this threshold */
818 #define AV_DELAY_MAX 0.100
820 static void do_subtitle_out(AVFormatContext *s,
826 static uint8_t *subtitle_out = NULL;
827 int subtitle_out_max_size = 1024 * 1024;
828 int subtitle_out_size, nb, i;
832 if (pts == AV_NOPTS_VALUE) {
833 fprintf(stderr, "Subtitle packets must have a pts\n");
839 enc = ost->st->codec;
842 subtitle_out = av_malloc(subtitle_out_max_size);
845 /* Note: DVB subtitle need one packet to draw them and one other
846 packet to clear them */
847 /* XXX: signal it in the codec context ? */
848 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
853 for(i = 0; i < nb; i++) {
854 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
855 // start_display_time is required to be 0
856 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
857 sub->end_display_time -= sub->start_display_time;
858 sub->start_display_time = 0;
859 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
860 subtitle_out_max_size, sub);
861 if (subtitle_out_size < 0) {
862 fprintf(stderr, "Subtitle encoding failed\n");
866 av_init_packet(&pkt);
867 pkt.stream_index = ost->index;
868 pkt.data = subtitle_out;
869 pkt.size = subtitle_out_size;
870 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
871 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
872 /* XXX: the pts correction is handled here. Maybe handling
873 it in the codec would be better */
875 pkt.pts += 90 * sub->start_display_time;
877 pkt.pts += 90 * sub->end_display_time;
879 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
883 static int bit_buffer_size= 1024*256;
884 static uint8_t *bit_buffer= NULL;
886 static void do_video_out(AVFormatContext *s,
892 int nb_frames, i, ret;
893 int64_t topBand, bottomBand, leftBand, rightBand;
894 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
895 AVFrame picture_crop_temp, picture_pad_temp;
896 AVCodecContext *enc, *dec;
898 avcodec_get_frame_defaults(&picture_crop_temp);
899 avcodec_get_frame_defaults(&picture_pad_temp);
901 enc = ost->st->codec;
902 dec = ist->st->codec;
904 /* by default, we output a single frame */
909 if(video_sync_method){
911 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
912 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
915 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
919 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
920 }else if (vdelta > 1.1)
921 nb_frames = lrintf(vdelta);
922 //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);
926 fprintf(stderr, "*** drop!\n");
927 }else if (nb_frames > 1) {
928 nb_frames_dup += nb_frames - 1;
930 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
933 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
935 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
939 if (ost->video_crop) {
940 if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
941 fprintf(stderr, "error cropping picture\n");
946 formatted_picture = &picture_crop_temp;
948 formatted_picture = in_picture;
951 final_picture = formatted_picture;
952 padding_src = formatted_picture;
953 resampling_dst = &ost->pict_tmp;
954 if (ost->video_pad) {
955 final_picture = &ost->pict_tmp;
956 if (ost->video_resample) {
957 if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
958 fprintf(stderr, "error padding picture\n");
963 resampling_dst = &picture_pad_temp;
967 if( (ost->resample_height != (ist->st->codec->height - (ost->topBand + ost->bottomBand)))
968 || (ost->resample_width != (ist->st->codec->width - (ost->leftBand + ost->rightBand)))
969 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
971 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));
972 if(!ost->video_resample)
976 if (ost->video_resample) {
978 final_picture = &ost->pict_tmp;
979 if( (ost->resample_height != (ist->st->codec->height - (ost->topBand + ost->bottomBand)))
980 || (ost->resample_width != (ist->st->codec->width - (ost->leftBand + ost->rightBand)))
981 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
983 /* keep bands proportional to the frame size */
984 topBand = ((int64_t)ist->st->codec->height * ost->original_topBand / ost->original_height) & ~1;
985 bottomBand = ((int64_t)ist->st->codec->height * ost->original_bottomBand / ost->original_height) & ~1;
986 leftBand = ((int64_t)ist->st->codec->width * ost->original_leftBand / ost->original_width) & ~1;
987 rightBand = ((int64_t)ist->st->codec->width * ost->original_rightBand / ost->original_width) & ~1;
989 /* sanity check to ensure no bad band sizes sneak in */
990 assert(topBand <= INT_MAX && topBand >= 0);
991 assert(bottomBand <= INT_MAX && bottomBand >= 0);
992 assert(leftBand <= INT_MAX && leftBand >= 0);
993 assert(rightBand <= INT_MAX && rightBand >= 0);
995 ost->topBand = topBand;
996 ost->bottomBand = bottomBand;
997 ost->leftBand = leftBand;
998 ost->rightBand = rightBand;
1000 ost->resample_height = ist->st->codec->height - (ost->topBand + ost->bottomBand);
1001 ost->resample_width = ist->st->codec->width - (ost->leftBand + ost->rightBand);
1002 ost->resample_pix_fmt= ist->st->codec->pix_fmt;
1004 /* initialize a new scaler context */
1005 sws_freeContext(ost->img_resample_ctx);
1006 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1007 ost->img_resample_ctx = sws_getContext(
1008 ist->st->codec->width - (ost->leftBand + ost->rightBand),
1009 ist->st->codec->height - (ost->topBand + ost->bottomBand),
1010 ist->st->codec->pix_fmt,
1011 ost->st->codec->width - (ost->padleft + ost->padright),
1012 ost->st->codec->height - (ost->padtop + ost->padbottom),
1013 ost->st->codec->pix_fmt,
1014 sws_flags, NULL, NULL, NULL);
1015 if (ost->img_resample_ctx == NULL) {
1016 fprintf(stderr, "Cannot get resampling context\n");
1020 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1021 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1024 if (ost->video_pad) {
1025 av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
1026 enc->height, enc->width, enc->pix_fmt,
1027 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
1030 /* duplicates frame if needed */
1031 for(i=0;i<nb_frames;i++) {
1033 av_init_packet(&pkt);
1034 pkt.stream_index= ost->index;
1036 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1037 /* raw pictures are written as AVPicture structure to
1038 avoid any copies. We support temorarily the older
1040 AVFrame* old_frame = enc->coded_frame;
1041 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1042 pkt.data= (uint8_t *)final_picture;
1043 pkt.size= sizeof(AVPicture);
1044 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1045 pkt.flags |= PKT_FLAG_KEY;
1047 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1048 enc->coded_frame = old_frame;
1050 AVFrame big_picture;
1052 big_picture= *final_picture;
1053 /* better than nothing: use input picture interlaced
1055 big_picture.interlaced_frame = in_picture->interlaced_frame;
1056 if(avcodec_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1057 if(top_field_first == -1)
1058 big_picture.top_field_first = in_picture->top_field_first;
1060 big_picture.top_field_first = top_field_first;
1063 /* handles sameq here. This is not correct because it may
1064 not be a global option */
1066 big_picture.quality = ist->st->quality;
1068 big_picture.quality = ost->st->quality;
1070 big_picture.pict_type = 0;
1071 // big_picture.pts = AV_NOPTS_VALUE;
1072 big_picture.pts= ost->sync_opts;
1073 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1074 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1075 ret = avcodec_encode_video(enc,
1076 bit_buffer, bit_buffer_size,
1079 fprintf(stderr, "Video encoding failed\n");
1084 pkt.data= bit_buffer;
1086 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1087 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1088 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1089 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1090 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1092 if(enc->coded_frame->key_frame)
1093 pkt.flags |= PKT_FLAG_KEY;
1094 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1097 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1098 // enc->frame_number-1, ret, enc->pict_type);
1099 /* if two pass, output log */
1100 if (ost->logfile && enc->stats_out) {
1101 fprintf(ost->logfile, "%s", enc->stats_out);
1106 ost->frame_number++;
1110 static double psnr(double d){
1111 return -10.0*log(d)/log(10.0);
1114 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1117 AVCodecContext *enc;
1119 double ti1, bitrate, avg_bitrate;
1121 /* this is executed just the first time do_video_stats is called */
1123 vstats_file = fopen(vstats_filename, "w");
1130 enc = ost->st->codec;
1131 if (enc->codec_type == CODEC_TYPE_VIDEO) {
1132 frame_number = ost->frame_number;
1133 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1134 if (enc->flags&CODEC_FLAG_PSNR)
1135 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1137 fprintf(vstats_file,"f_size= %6d ", frame_size);
1138 /* compute pts value */
1139 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1143 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1144 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1145 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1146 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1147 fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1151 static void print_report(AVFormatContext **output_files,
1152 AVOutputStream **ost_table, int nb_ostreams,
1156 AVOutputStream *ost;
1157 AVFormatContext *oc;
1159 AVCodecContext *enc;
1160 int frame_number, vid, i;
1161 double bitrate, ti1, pts;
1162 static int64_t last_time = -1;
1163 static int qp_histogram[52];
1165 if (!is_last_report) {
1167 /* display the report every 0.5 seconds */
1168 cur_time = av_gettime();
1169 if (last_time == -1) {
1170 last_time = cur_time;
1173 if ((cur_time - last_time) < 500000)
1175 last_time = cur_time;
1179 oc = output_files[0];
1181 total_size = url_fsize(oc->pb);
1182 if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1183 total_size= url_ftell(oc->pb);
1188 for(i=0;i<nb_ostreams;i++) {
1190 enc = ost->st->codec;
1191 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1192 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1193 !ost->st->stream_copy ?
1194 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1196 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1197 float t = (av_gettime()-timer_start) / 1000000.0;
1199 frame_number = ost->frame_number;
1200 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1201 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1202 !ost->st->stream_copy ?
1203 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1205 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1208 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1209 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1212 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1214 if (enc->flags&CODEC_FLAG_PSNR){
1216 double error, error_sum=0;
1217 double scale, scale_sum=0;
1218 char type[3]= {'Y','U','V'};
1219 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1222 error= enc->error[j];
1223 scale= enc->width*enc->height*255.0*255.0*frame_number;
1225 error= enc->coded_frame->error[j];
1226 scale= enc->width*enc->height*255.0*255.0;
1231 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1233 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1237 /* compute min output value */
1238 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1239 if ((pts < ti1) && (pts > 0))
1245 if (verbose || is_last_report) {
1246 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1248 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1249 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1250 (double)total_size / 1024, ti1, bitrate);
1252 if (nb_frames_dup || nb_frames_drop)
1253 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1254 nb_frames_dup, nb_frames_drop);
1257 fprintf(stderr, "%s \r", buf);
1262 if (is_last_report && verbose >= 0){
1263 int64_t raw= audio_size + video_size + extra_size;
1264 fprintf(stderr, "\n");
1265 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1269 100.0*(total_size - raw)/raw
1274 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1275 static int output_packet(AVInputStream *ist, int ist_index,
1276 AVOutputStream **ost_table, int nb_ostreams,
1277 const AVPacket *pkt)
1279 AVFormatContext *os;
1280 AVOutputStream *ost;
1284 void *buffer_to_free;
1285 static unsigned int samples_size= 0;
1286 AVSubtitle subtitle, *subtitle_to_free;
1289 int bps = av_get_bits_per_sample_format(ist->st->codec->sample_fmt)>>3;
1291 if(ist->next_pts == AV_NOPTS_VALUE)
1292 ist->next_pts= ist->pts;
1296 av_init_packet(&avpkt);
1304 if(pkt->dts != AV_NOPTS_VALUE)
1305 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1307 //while we have more to decode or while the decoder did output something on EOF
1308 while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1309 uint8_t *data_buf, *decoded_data_buf;
1310 int data_size, decoded_data_size;
1312 ist->pts= ist->next_pts;
1314 if(avpkt.size && avpkt.size != pkt->size &&
1315 !(ist->st->codec->codec->capabilities & CODEC_CAP_SUBFRAMES) && verbose>0)
1316 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1318 /* decode the packet if needed */
1319 decoded_data_buf = NULL; /* fail safe */
1320 decoded_data_size= 0;
1321 data_buf = avpkt.data;
1322 data_size = avpkt.size;
1323 subtitle_to_free = NULL;
1324 if (ist->decoding_needed) {
1325 switch(ist->st->codec->codec_type) {
1326 case CODEC_TYPE_AUDIO:{
1327 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1328 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1330 samples= av_malloc(samples_size);
1332 decoded_data_size= samples_size;
1333 /* XXX: could avoid copy if PCM 16 bits with same
1334 endianness as CPU */
1335 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1342 /* Some bug in mpeg audio decoder gives */
1343 /* decoded_data_size < 0, it seems they are overflows */
1344 if (decoded_data_size <= 0) {
1345 /* no audio frame */
1348 decoded_data_buf = (uint8_t *)samples;
1349 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1350 (ist->st->codec->sample_rate * ist->st->codec->channels);
1352 case CODEC_TYPE_VIDEO:
1353 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1354 /* XXX: allocate picture correctly */
1355 avcodec_get_frame_defaults(&picture);
1357 ret = avcodec_decode_video2(ist->st->codec,
1358 &picture, &got_picture, &avpkt);
1359 ist->st->quality= picture.quality;
1363 /* no picture yet */
1364 goto discard_packet;
1366 if (ist->st->codec->time_base.num != 0) {
1367 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1368 ist->next_pts += ((int64_t)AV_TIME_BASE *
1369 ist->st->codec->time_base.num * ticks) /
1370 ist->st->codec->time_base.den;
1374 case CODEC_TYPE_SUBTITLE:
1375 ret = avcodec_decode_subtitle2(ist->st->codec,
1376 &subtitle, &got_subtitle, &avpkt);
1379 if (!got_subtitle) {
1380 goto discard_packet;
1382 subtitle_to_free = &subtitle;
1389 switch(ist->st->codec->codec_type) {
1390 case CODEC_TYPE_AUDIO:
1391 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1392 ist->st->codec->sample_rate;
1394 case CODEC_TYPE_VIDEO:
1395 if (ist->st->codec->time_base.num != 0) {
1396 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1397 ist->next_pts += ((int64_t)AV_TIME_BASE *
1398 ist->st->codec->time_base.num * ticks) /
1399 ist->st->codec->time_base.den;
1407 buffer_to_free = NULL;
1408 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1409 pre_process_video_frame(ist, (AVPicture *)&picture,
1413 // preprocess audio (volume)
1414 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1415 if (audio_volume != 256) {
1418 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1419 int v = ((*volp) * audio_volume + 128) >> 8;
1420 if (v < -32768) v = -32768;
1421 if (v > 32767) v = 32767;
1427 /* frame rate emulation */
1429 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1430 int64_t now = av_gettime() - ist->start;
1435 /* if output time reached then transcode raw format,
1436 encode packets and output them */
1437 if (start_time == 0 || ist->pts >= start_time)
1438 for(i=0;i<nb_ostreams;i++) {
1442 if (ost->source_index == ist_index) {
1443 os = output_files[ost->file_index];
1445 /* set the input output pts pairs */
1446 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1448 if (ost->encoding_needed) {
1449 assert(ist->decoding_needed);
1450 switch(ost->st->codec->codec_type) {
1451 case CODEC_TYPE_AUDIO:
1452 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1454 case CODEC_TYPE_VIDEO:
1455 do_video_out(os, ost, ist, &picture, &frame_size);
1456 if (vstats_filename && frame_size)
1457 do_video_stats(os, ost, frame_size);
1459 case CODEC_TYPE_SUBTITLE:
1460 do_subtitle_out(os, ost, ist, &subtitle,
1467 AVFrame avframe; //FIXME/XXX remove this
1469 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1471 av_init_packet(&opkt);
1473 if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1476 /* no reencoding needed : output the packet directly */
1477 /* force the input stream PTS */
1479 avcodec_get_frame_defaults(&avframe);
1480 ost->st->codec->coded_frame= &avframe;
1481 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1483 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1484 audio_size += data_size;
1485 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1486 video_size += data_size;
1490 opkt.stream_index= ost->index;
1491 if(pkt->pts != AV_NOPTS_VALUE)
1492 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1494 opkt.pts= AV_NOPTS_VALUE;
1496 if (pkt->dts == AV_NOPTS_VALUE)
1497 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1499 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1500 opkt.dts -= ost_tb_start_time;
1502 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1503 opkt.flags= pkt->flags;
1505 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1506 if(ost->st->codec->codec_id != CODEC_ID_H264) {
1507 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1508 opkt.destruct= av_destruct_packet;
1510 opkt.data = data_buf;
1511 opkt.size = data_size;
1514 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1515 ost->st->codec->frame_number++;
1516 ost->frame_number++;
1517 av_free_packet(&opkt);
1521 av_free(buffer_to_free);
1522 /* XXX: allocate the subtitles in the codec ? */
1523 if (subtitle_to_free) {
1524 if (subtitle_to_free->rects != NULL) {
1525 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1526 av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1527 av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1528 av_freep(&subtitle_to_free->rects[i]);
1530 av_freep(&subtitle_to_free->rects);
1532 subtitle_to_free->num_rects = 0;
1533 subtitle_to_free = NULL;
1540 for(i=0;i<nb_ostreams;i++) {
1542 if (ost->source_index == ist_index) {
1543 AVCodecContext *enc= ost->st->codec;
1544 os = output_files[ost->file_index];
1546 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1548 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1551 if (ost->encoding_needed) {
1555 av_init_packet(&pkt);
1556 pkt.stream_index= ost->index;
1558 switch(ost->st->codec->codec_type) {
1559 case CODEC_TYPE_AUDIO:
1560 fifo_bytes = av_fifo_size(ost->fifo);
1562 /* encode any samples remaining in fifo */
1563 if (fifo_bytes > 0) {
1564 int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
1565 int fs_tmp = enc->frame_size;
1567 av_fifo_generic_read(ost->fifo, samples, fifo_bytes, NULL);
1568 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1569 enc->frame_size = fifo_bytes / (osize * enc->channels);
1571 int frame_bytes = enc->frame_size*osize*enc->channels;
1572 if (samples_size < frame_bytes)
1574 memset((uint8_t*)samples+fifo_bytes, 0, frame_bytes - fifo_bytes);
1577 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1578 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1579 ost->st->time_base.num, enc->sample_rate);
1580 enc->frame_size = fs_tmp;
1583 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1586 fprintf(stderr, "Audio encoding failed\n");
1590 pkt.flags |= PKT_FLAG_KEY;
1592 case CODEC_TYPE_VIDEO:
1593 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1595 fprintf(stderr, "Video encoding failed\n");
1599 if(enc->coded_frame && enc->coded_frame->key_frame)
1600 pkt.flags |= PKT_FLAG_KEY;
1601 if (ost->logfile && enc->stats_out) {
1602 fprintf(ost->logfile, "%s", enc->stats_out);
1611 pkt.data= bit_buffer;
1613 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1614 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1615 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1627 static void print_sdp(AVFormatContext **avc, int n)
1631 avf_sdp_create(avc, n, sdp, sizeof(sdp));
1632 printf("SDP:\n%s\n", sdp);
1636 static int stream_index_from_inputs(AVFormatContext **input_files,
1638 AVInputFile *file_table,
1639 AVInputStream **ist_table,
1640 enum CodecType type,
1644 for(z=0; z<nb_input_files; z++) {
1645 AVFormatContext *ic = input_files[z];
1646 for(p=0; p<ic->nb_programs; p++) {
1647 AVProgram *program = ic->programs[p];
1648 if(program->id != programid)
1650 for(q=0; q<program->nb_stream_indexes; q++) {
1651 int sidx = program->stream_index[q];
1652 int ris = file_table[z].ist_index + sidx;
1653 if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1663 * The following code is the main loop of the file converter
1665 static int av_encode(AVFormatContext **output_files,
1666 int nb_output_files,
1667 AVFormatContext **input_files,
1669 AVStreamMap *stream_maps, int nb_stream_maps)
1671 int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1672 AVFormatContext *is, *os;
1673 AVCodecContext *codec, *icodec;
1674 AVOutputStream *ost, **ost_table = NULL;
1675 AVInputStream *ist, **ist_table = NULL;
1676 AVInputFile *file_table;
1680 uint8_t no_packet[MAX_FILES]={0};
1681 int no_packet_count=0;
1683 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1687 /* input stream init */
1689 for(i=0;i<nb_input_files;i++) {
1690 is = input_files[i];
1691 file_table[i].ist_index = j;
1692 file_table[i].nb_streams = is->nb_streams;
1693 j += is->nb_streams;
1697 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1701 for(i=0;i<nb_istreams;i++) {
1702 ist = av_mallocz(sizeof(AVInputStream));
1708 for(i=0;i<nb_input_files;i++) {
1709 is = input_files[i];
1710 for(k=0;k<is->nb_streams;k++) {
1711 ist = ist_table[j++];
1712 ist->st = is->streams[k];
1713 ist->file_index = i;
1715 ist->discard = 1; /* the stream is discarded by default
1719 ist->start = av_gettime();
1724 /* output stream init */
1726 for(i=0;i<nb_output_files;i++) {
1727 os = output_files[i];
1728 if (!os->nb_streams) {
1729 dump_format(output_files[i], i, output_files[i]->filename, 1);
1730 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1733 nb_ostreams += os->nb_streams;
1735 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1736 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1740 /* Sanity check the mapping args -- do the input files & streams exist? */
1741 for(i=0;i<nb_stream_maps;i++) {
1742 int fi = stream_maps[i].file_index;
1743 int si = stream_maps[i].stream_index;
1745 if (fi < 0 || fi > nb_input_files - 1 ||
1746 si < 0 || si > file_table[fi].nb_streams - 1) {
1747 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1750 fi = stream_maps[i].sync_file_index;
1751 si = stream_maps[i].sync_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 sync stream #%d.%d\n", fi, si);
1759 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1762 for(i=0;i<nb_ostreams;i++) {
1763 ost = av_mallocz(sizeof(AVOutputStream));
1770 for(k=0;k<nb_output_files;k++) {
1771 os = output_files[k];
1772 for(i=0;i<os->nb_streams;i++,n++) {
1775 ost->file_index = k;
1777 ost->st = os->streams[i];
1778 if (nb_stream_maps > 0) {
1779 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1780 stream_maps[n].stream_index;
1782 /* Sanity check that the stream types match */
1783 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1784 int i= ost->file_index;
1785 dump_format(output_files[i], i, output_files[i]->filename, 1);
1786 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1787 stream_maps[n].file_index, stream_maps[n].stream_index,
1788 ost->file_index, ost->index);
1795 j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1797 ost->source_index = j;
1801 /* get corresponding input stream index : we select the first one with the right type */
1803 for(j=0;j<nb_istreams;j++) {
1806 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1807 ost->source_index = j;
1815 if(! opt_programid) {
1816 /* try again and reuse existing stream */
1817 for(j=0;j<nb_istreams;j++) {
1819 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1820 ost->source_index = j;
1826 int i= ost->file_index;
1827 dump_format(output_files[i], i, output_files[i]->filename, 1);
1828 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1829 ost->file_index, ost->index);
1834 ist = ist_table[ost->source_index];
1836 ost->sync_ist = (nb_stream_maps > 0) ?
1837 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
1838 stream_maps[n].sync_stream_index] : ist;
1842 /* for each output stream, we compute the right encoding parameters */
1843 for(i=0;i<nb_ostreams;i++) {
1844 AVMetadataTag *lang;
1846 os = output_files[ost->file_index];
1847 ist = ist_table[ost->source_index];
1849 codec = ost->st->codec;
1850 icodec = ist->st->codec;
1852 if ((lang=av_metadata_get(ist->st->metadata, "language", NULL, 0))
1853 && !av_metadata_get(ost->st->metadata, "language", NULL, 0))
1854 av_metadata_set(&ost->st->metadata, "language", lang->value);
1856 ost->st->disposition = ist->st->disposition;
1857 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1858 codec->chroma_sample_location = icodec->chroma_sample_location;
1860 if (ost->st->stream_copy) {
1861 /* if stream_copy is selected, no need to decode or encode */
1862 codec->codec_id = icodec->codec_id;
1863 codec->codec_type = icodec->codec_type;
1865 if(!codec->codec_tag){
1866 if( !os->oformat->codec_tag
1867 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
1868 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1869 codec->codec_tag = icodec->codec_tag;
1872 codec->bit_rate = icodec->bit_rate;
1873 codec->extradata= icodec->extradata;
1874 codec->extradata_size= icodec->extradata_size;
1875 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){
1876 codec->time_base = icodec->time_base;
1877 codec->time_base.num *= icodec->ticks_per_frame;
1879 codec->time_base = ist->st->time_base;
1880 switch(codec->codec_type) {
1881 case CODEC_TYPE_AUDIO:
1882 if(audio_volume != 256) {
1883 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1886 codec->channel_layout = icodec->channel_layout;
1887 codec->sample_rate = icodec->sample_rate;
1888 codec->channels = icodec->channels;
1889 codec->frame_size = icodec->frame_size;
1890 codec->block_align= icodec->block_align;
1891 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1892 codec->block_align= 0;
1893 if(codec->codec_id == CODEC_ID_AC3)
1894 codec->block_align= 0;
1896 case CODEC_TYPE_VIDEO:
1897 codec->pix_fmt = icodec->pix_fmt;
1898 codec->width = icodec->width;
1899 codec->height = icodec->height;
1900 codec->has_b_frames = icodec->has_b_frames;
1902 case CODEC_TYPE_SUBTITLE:
1903 codec->width = icodec->width;
1904 codec->height = icodec->height;
1910 switch(codec->codec_type) {
1911 case CODEC_TYPE_AUDIO:
1912 ost->fifo= av_fifo_alloc(1024);
1915 ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
1916 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1917 icodec->request_channels = codec->channels;
1918 ist->decoding_needed = 1;
1919 ost->encoding_needed = 1;
1921 case CODEC_TYPE_VIDEO:
1922 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
1923 fprintf(stderr, "Video pixel format is unknown, stream cannot be decoded\n");
1926 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1927 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1928 ost->video_resample = ((codec->width != icodec->width -
1929 (frame_leftBand + frame_rightBand) +
1930 (frame_padleft + frame_padright)) ||
1931 (codec->height != icodec->height -
1932 (frame_topBand + frame_bottomBand) +
1933 (frame_padtop + frame_padbottom)) ||
1934 (codec->pix_fmt != icodec->pix_fmt));
1935 if (ost->video_crop) {
1936 ost->topBand = ost->original_topBand = frame_topBand;
1937 ost->bottomBand = ost->original_bottomBand = frame_bottomBand;
1938 ost->leftBand = ost->original_leftBand = frame_leftBand;
1939 ost->rightBand = ost->original_rightBand = frame_rightBand;
1941 if (ost->video_pad) {
1942 ost->padtop = frame_padtop;
1943 ost->padleft = frame_padleft;
1944 ost->padbottom = frame_padbottom;
1945 ost->padright = frame_padright;
1946 if (!ost->video_resample) {
1947 avcodec_get_frame_defaults(&ost->pict_tmp);
1948 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1949 codec->width, codec->height))
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)) {
1957 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1960 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1961 ost->img_resample_ctx = sws_getContext(
1962 icodec->width - (frame_leftBand + frame_rightBand),
1963 icodec->height - (frame_topBand + frame_bottomBand),
1965 codec->width - (frame_padleft + frame_padright),
1966 codec->height - (frame_padtop + frame_padbottom),
1968 sws_flags, NULL, NULL, NULL);
1969 if (ost->img_resample_ctx == NULL) {
1970 fprintf(stderr, "Cannot get resampling context\n");
1974 ost->original_height = icodec->height;
1975 ost->original_width = icodec->width;
1977 codec->bits_per_raw_sample= 0;
1979 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1980 ost->resample_width = icodec->width - (frame_leftBand + frame_rightBand);
1981 ost->resample_pix_fmt= icodec->pix_fmt;
1982 ost->encoding_needed = 1;
1983 ist->decoding_needed = 1;
1985 case CODEC_TYPE_SUBTITLE:
1986 ost->encoding_needed = 1;
1987 ist->decoding_needed = 1;
1994 if (ost->encoding_needed &&
1995 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1996 char logfilename[1024];
2001 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2002 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2004 if (codec->flags & CODEC_FLAG_PASS1) {
2005 f = fopen(logfilename, "w");
2007 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2012 /* read the log file */
2013 f = fopen(logfilename, "r");
2015 fprintf(stderr, "Cannot read log file '%s' for pass-2 encoding: %s\n", logfilename, strerror(errno));
2018 fseek(f, 0, SEEK_END);
2020 fseek(f, 0, SEEK_SET);
2021 logbuffer = av_malloc(size + 1);
2023 fprintf(stderr, "Could not allocate log buffer\n");
2026 size = fread(logbuffer, 1, size, f);
2028 logbuffer[size] = '\0';
2029 codec->stats_in = logbuffer;
2033 if(codec->codec_type == CODEC_TYPE_VIDEO){
2034 int size= codec->width * codec->height;
2035 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2040 bit_buffer = av_malloc(bit_buffer_size);
2042 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2044 ret = AVERROR(ENOMEM);
2048 /* open each encoder */
2049 for(i=0;i<nb_ostreams;i++) {
2051 if (ost->encoding_needed) {
2052 AVCodec *codec = output_codecs[i];
2054 codec = avcodec_find_encoder(ost->st->codec->codec_id);
2056 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2057 ost->st->codec->codec_id, ost->file_index, ost->index);
2058 ret = AVERROR(EINVAL);
2061 if (avcodec_open(ost->st->codec, codec) < 0) {
2062 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2063 ost->file_index, ost->index);
2064 ret = AVERROR(EINVAL);
2067 extra_size += ost->st->codec->extradata_size;
2071 /* open each decoder */
2072 for(i=0;i<nb_istreams;i++) {
2074 if (ist->decoding_needed) {
2075 AVCodec *codec = input_codecs[i];
2077 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2079 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2080 ist->st->codec->codec_id, ist->file_index, ist->index);
2081 ret = AVERROR(EINVAL);
2084 if (avcodec_open(ist->st->codec, codec) < 0) {
2085 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2086 ist->file_index, ist->index);
2087 ret = AVERROR(EINVAL);
2090 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
2091 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2096 for(i=0;i<nb_istreams;i++) {
2099 ist->next_pts = AV_NOPTS_VALUE;
2103 /* set meta data information from input file if required */
2104 for (i=0;i<nb_meta_data_maps;i++) {
2105 AVFormatContext *out_file;
2106 AVFormatContext *in_file;
2107 AVMetadataTag *mtag;
2109 int out_file_index = meta_data_maps[i].out_file;
2110 int in_file_index = meta_data_maps[i].in_file;
2111 if (out_file_index < 0 || out_file_index >= nb_output_files) {
2112 snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
2113 out_file_index, out_file_index, in_file_index);
2114 ret = AVERROR(EINVAL);
2117 if (in_file_index < 0 || in_file_index >= nb_input_files) {
2118 snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
2119 in_file_index, out_file_index, in_file_index);
2120 ret = AVERROR(EINVAL);
2124 out_file = output_files[out_file_index];
2125 in_file = input_files[in_file_index];
2129 while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2130 av_metadata_set(&out_file->metadata, mtag->key, mtag->value);
2131 av_metadata_conv(out_file, out_file->oformat->metadata_conv,
2132 in_file->iformat->metadata_conv);
2135 /* open files and write file headers */
2136 for(i=0;i<nb_output_files;i++) {
2137 os = output_files[i];
2138 if (av_write_header(os) < 0) {
2139 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2140 ret = AVERROR(EINVAL);
2143 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2149 /* dump the file output parameters - cannot be done before in case
2151 for(i=0;i<nb_output_files;i++) {
2152 dump_format(output_files[i], i, output_files[i]->filename, 1);
2155 /* dump the stream mapping */
2157 fprintf(stderr, "Stream mapping:\n");
2158 for(i=0;i<nb_ostreams;i++) {
2160 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2161 ist_table[ost->source_index]->file_index,
2162 ist_table[ost->source_index]->index,
2165 if (ost->sync_ist != ist_table[ost->source_index])
2166 fprintf(stderr, " [sync #%d.%d]",
2167 ost->sync_ist->file_index,
2168 ost->sync_ist->index);
2169 fprintf(stderr, "\n");
2174 fprintf(stderr, "%s\n", error);
2179 print_sdp(output_files, nb_output_files);
2182 if (!using_stdin && verbose >= 0) {
2183 fprintf(stderr, "Press [q] to stop encoding\n");
2184 url_set_interrupt_cb(decode_interrupt_cb);
2188 timer_start = av_gettime();
2190 for(; received_sigterm == 0;) {
2191 int file_index, ist_index;
2199 /* if 'q' pressed, exits */
2203 /* read_key() returns 0 on EOF */
2209 /* select the stream that we must read now by looking at the
2210 smallest output pts */
2212 for(i=0;i<nb_ostreams;i++) {
2215 os = output_files[ost->file_index];
2216 ist = ist_table[ost->source_index];
2217 if(no_packet[ist->file_index])
2219 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2220 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2222 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2223 ipts = (double)ist->pts;
2224 if (!file_table[ist->file_index].eof_reached){
2225 if(ipts < ipts_min) {
2227 if(input_sync ) file_index = ist->file_index;
2229 if(opts < opts_min) {
2231 if(!input_sync) file_index = ist->file_index;
2234 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2239 /* if none, if is finished */
2240 if (file_index < 0) {
2241 if(no_packet_count){
2243 memset(no_packet, 0, sizeof(no_packet));
2250 /* finish if recording time exhausted */
2251 if (opts_min >= (recording_time / 1000000.0))
2254 /* finish if limit size exhausted */
2255 if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2258 /* read a frame from it and output it in the fifo */
2259 is = input_files[file_index];
2260 ret= av_read_frame(is, &pkt);
2261 if(ret == AVERROR(EAGAIN)){
2262 no_packet[file_index]=1;
2267 file_table[file_index].eof_reached = 1;
2275 memset(no_packet, 0, sizeof(no_packet));
2278 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2280 /* the following test is needed in case new streams appear
2281 dynamically in stream : we ignore them */
2282 if (pkt.stream_index >= file_table[file_index].nb_streams)
2283 goto discard_packet;
2284 ist_index = file_table[file_index].ist_index + pkt.stream_index;
2285 ist = ist_table[ist_index];
2287 goto discard_packet;
2289 if (pkt.dts != AV_NOPTS_VALUE)
2290 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2291 if (pkt.pts != AV_NOPTS_VALUE)
2292 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2294 if(input_files_ts_scale[file_index][pkt.stream_index]){
2295 if(pkt.pts != AV_NOPTS_VALUE)
2296 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2297 if(pkt.dts != AV_NOPTS_VALUE)
2298 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2301 // 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);
2302 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2303 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2304 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2305 int64_t delta= pkt_dts - ist->next_pts;
2306 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2307 input_files_ts_offset[ist->file_index]-= delta;
2309 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2310 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2311 if(pkt.pts != AV_NOPTS_VALUE)
2312 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2316 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2317 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2320 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2321 ist->file_index, ist->index);
2324 av_free_packet(&pkt);
2329 av_free_packet(&pkt);
2331 /* dump report by using the output first video and audio streams */
2332 print_report(output_files, ost_table, nb_ostreams, 0);
2335 /* at the end of stream, we must flush the decoder buffers */
2336 for(i=0;i<nb_istreams;i++) {
2338 if (ist->decoding_needed) {
2339 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2345 /* write the trailer if needed and close file */
2346 for(i=0;i<nb_output_files;i++) {
2347 os = output_files[i];
2348 av_write_trailer(os);
2351 /* dump report by using the first video and audio streams */
2352 print_report(output_files, ost_table, nb_ostreams, 1);
2354 /* close each encoder */
2355 for(i=0;i<nb_ostreams;i++) {
2357 if (ost->encoding_needed) {
2358 av_freep(&ost->st->codec->stats_in);
2359 avcodec_close(ost->st->codec);
2363 /* close each decoder */
2364 for(i=0;i<nb_istreams;i++) {
2366 if (ist->decoding_needed) {
2367 avcodec_close(ist->st->codec);
2375 av_freep(&bit_buffer);
2376 av_free(file_table);
2379 for(i=0;i<nb_istreams;i++) {
2386 for(i=0;i<nb_ostreams;i++) {
2390 fclose(ost->logfile);
2391 ost->logfile = NULL;
2393 av_fifo_free(ost->fifo); /* works even if fifo is not
2394 initialized but set to zero */
2395 av_free(ost->pict_tmp.data[0]);
2396 if (ost->video_resample)
2397 sws_freeContext(ost->img_resample_ctx);
2399 audio_resample_close(ost->resample);
2400 if (ost->reformat_ctx)
2401 av_audio_convert_free(ost->reformat_ctx);
2410 static void opt_format(const char *arg)
2412 /* compatibility stuff for pgmyuv */
2413 if (!strcmp(arg, "pgmyuv")) {
2414 pgmyuv_compatibility_hack=1;
2415 // opt_image_format(arg);
2417 fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2420 last_asked_format = arg;
2423 static void opt_video_rc_override_string(const char *arg)
2425 video_rc_override_string = arg;
2428 static int opt_me_threshold(const char *opt, const char *arg)
2430 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2434 static int opt_verbose(const char *opt, const char *arg)
2436 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2440 static int opt_frame_rate(const char *opt, const char *arg)
2442 if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2443 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2449 static int opt_bitrate(const char *opt, const char *arg)
2451 int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2453 opt_default(opt, arg);
2455 if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2456 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2461 static void opt_frame_crop_top(const char *arg)
2463 frame_topBand = atoi(arg);
2464 if (frame_topBand < 0) {
2465 fprintf(stderr, "Incorrect top crop size\n");
2468 if ((frame_topBand) >= frame_height){
2469 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2472 frame_height -= frame_topBand;
2475 static void opt_frame_crop_bottom(const char *arg)
2477 frame_bottomBand = atoi(arg);
2478 if (frame_bottomBand < 0) {
2479 fprintf(stderr, "Incorrect bottom crop size\n");
2482 if ((frame_bottomBand) >= frame_height){
2483 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2486 frame_height -= frame_bottomBand;
2489 static void opt_frame_crop_left(const char *arg)
2491 frame_leftBand = atoi(arg);
2492 if (frame_leftBand < 0) {
2493 fprintf(stderr, "Incorrect left crop size\n");
2496 if ((frame_leftBand) >= frame_width){
2497 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2500 frame_width -= frame_leftBand;
2503 static void opt_frame_crop_right(const char *arg)
2505 frame_rightBand = atoi(arg);
2506 if (frame_rightBand < 0) {
2507 fprintf(stderr, "Incorrect right crop size\n");
2510 if ((frame_rightBand) >= frame_width){
2511 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2514 frame_width -= frame_rightBand;
2517 static void opt_frame_size(const char *arg)
2519 if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2520 fprintf(stderr, "Incorrect frame size\n");
2525 static void opt_pad_color(const char *arg) {
2526 /* Input is expected to be six hex digits similar to
2527 how colors are expressed in html tags (but without the #) */
2528 int rgb = strtol(arg, NULL, 16);
2532 g = ((rgb >> 8) & 255);
2535 padcolor[0] = RGB_TO_Y(r,g,b);
2536 padcolor[1] = RGB_TO_U(r,g,b,0);
2537 padcolor[2] = RGB_TO_V(r,g,b,0);
2540 static void opt_frame_pad_top(const char *arg)
2542 frame_padtop = atoi(arg);
2543 if (frame_padtop < 0) {
2544 fprintf(stderr, "Incorrect top pad size\n");
2549 static void opt_frame_pad_bottom(const char *arg)
2551 frame_padbottom = atoi(arg);
2552 if (frame_padbottom < 0) {
2553 fprintf(stderr, "Incorrect bottom pad size\n");
2559 static void opt_frame_pad_left(const char *arg)
2561 frame_padleft = atoi(arg);
2562 if (frame_padleft < 0) {
2563 fprintf(stderr, "Incorrect left pad size\n");
2569 static void opt_frame_pad_right(const char *arg)
2571 frame_padright = atoi(arg);
2572 if (frame_padright < 0) {
2573 fprintf(stderr, "Incorrect right pad size\n");
2578 static void opt_frame_pix_fmt(const char *arg)
2580 if (strcmp(arg, "list")) {
2581 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2582 if (frame_pix_fmt == PIX_FMT_NONE) {
2583 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2587 list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2592 static void opt_frame_aspect_ratio(const char *arg)
2599 p = strchr(arg, ':');
2601 x = strtol(arg, &end, 10);
2603 y = strtol(end+1, &end, 10);
2605 ar = (double)x / (double)y;
2607 ar = strtod(arg, NULL);
2610 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2613 frame_aspect_ratio = ar;
2616 static int opt_metadata(const char *opt, const char *arg)
2618 char *mid= strchr(arg, '=');
2621 fprintf(stderr, "Missing =\n");
2627 metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2628 metadata[metadata_count-1].key = av_strdup(arg);
2629 metadata[metadata_count-1].value= av_strdup(mid);
2634 static void opt_qscale(const char *arg)
2636 video_qscale = atof(arg);
2637 if (video_qscale <= 0 ||
2638 video_qscale > 255) {
2639 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2644 static void opt_top_field_first(const char *arg)
2646 top_field_first= atoi(arg);
2649 static int opt_thread_count(const char *opt, const char *arg)
2651 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2654 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2659 static void opt_audio_sample_fmt(const char *arg)
2661 if (strcmp(arg, "list"))
2662 audio_sample_fmt = avcodec_get_sample_fmt(arg);
2664 list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2669 static int opt_audio_rate(const char *opt, const char *arg)
2671 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2675 static int opt_audio_channels(const char *opt, const char *arg)
2677 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2681 static void opt_video_channel(const char *arg)
2683 video_channel = strtol(arg, NULL, 0);
2686 static void opt_video_standard(const char *arg)
2688 video_standard = av_strdup(arg);
2691 static void opt_codec(int *pstream_copy, char **pcodec_name,
2692 int codec_type, const char *arg)
2694 av_freep(pcodec_name);
2695 if (!strcmp(arg, "copy")) {
2698 *pcodec_name = av_strdup(arg);
2702 static void opt_audio_codec(const char *arg)
2704 opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2707 static void opt_audio_tag(const char *arg)
2710 audio_codec_tag= strtol(arg, &tail, 0);
2713 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2716 static void opt_video_tag(const char *arg)
2719 video_codec_tag= strtol(arg, &tail, 0);
2722 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2725 static void opt_video_codec(const char *arg)
2727 opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2730 static void opt_subtitle_codec(const char *arg)
2732 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2735 static void opt_subtitle_tag(const char *arg)
2738 subtitle_codec_tag= strtol(arg, &tail, 0);
2741 subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2744 static void opt_map(const char *arg)
2749 m = &stream_maps[nb_stream_maps++];
2751 m->file_index = strtol(arg, &p, 0);
2755 m->stream_index = strtol(p, &p, 0);
2758 m->sync_file_index = strtol(p, &p, 0);
2761 m->sync_stream_index = strtol(p, &p, 0);
2763 m->sync_file_index = m->file_index;
2764 m->sync_stream_index = m->stream_index;
2768 static void opt_map_meta_data(const char *arg)
2773 m = &meta_data_maps[nb_meta_data_maps++];
2775 m->out_file = strtol(arg, &p, 0);
2779 m->in_file = strtol(p, &p, 0);
2782 static void opt_input_ts_scale(const char *arg)
2784 unsigned int stream;
2788 stream = strtol(arg, &p, 0);
2791 scale= strtod(p, &p);
2793 if(stream >= MAX_STREAMS)
2796 input_files_ts_scale[nb_input_files][stream]= scale;
2799 static int opt_recording_time(const char *opt, const char *arg)
2801 recording_time = parse_time_or_die(opt, arg, 1);
2805 static int opt_start_time(const char *opt, const char *arg)
2807 start_time = parse_time_or_die(opt, arg, 1);
2811 static int opt_rec_timestamp(const char *opt, const char *arg)
2813 rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2817 static int opt_input_ts_offset(const char *opt, const char *arg)
2819 input_ts_offset = parse_time_or_die(opt, arg, 1);
2823 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2825 const char *codec_string = encoder ? "encoder" : "decoder";
2829 return CODEC_ID_NONE;
2831 avcodec_find_encoder_by_name(name) :
2832 avcodec_find_decoder_by_name(name);
2834 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2837 if(codec->type != type) {
2838 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2844 static void opt_input_file(const char *filename)
2846 AVFormatContext *ic;
2847 AVFormatParameters params, *ap = ¶ms;
2848 AVInputFormat *file_iformat = NULL;
2849 int err, i, ret, rfps, rfps_base;
2852 if (last_asked_format) {
2853 file_iformat = av_find_input_format(last_asked_format);
2854 last_asked_format = NULL;
2857 if (!strcmp(filename, "-"))
2860 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2861 !strcmp(filename, "/dev/stdin");
2863 /* get default parameters from command line */
2864 ic = avformat_alloc_context();
2866 print_error(filename, AVERROR(ENOMEM));
2870 memset(ap, 0, sizeof(*ap));
2871 ap->prealloced_context = 1;
2872 ap->sample_rate = audio_sample_rate;
2873 ap->channels = audio_channels;
2874 ap->time_base.den = frame_rate.num;
2875 ap->time_base.num = frame_rate.den;
2876 ap->width = frame_width + frame_padleft + frame_padright;
2877 ap->height = frame_height + frame_padtop + frame_padbottom;
2878 ap->pix_fmt = frame_pix_fmt;
2879 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2880 ap->channel = video_channel;
2881 ap->standard = video_standard;
2882 ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2883 ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2884 if(pgmyuv_compatibility_hack)
2885 ap->video_codec_id= CODEC_ID_PGMYUV;
2887 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2889 ic->video_codec_id = find_codec_or_die(video_codec_name , CODEC_TYPE_VIDEO , 0);
2890 ic->audio_codec_id = find_codec_or_die(audio_codec_name , CODEC_TYPE_AUDIO , 0);
2891 ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2892 ic->flags |= AVFMT_FLAG_NONBLOCK;
2894 /* open the input file with generic libav function */
2895 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2897 print_error(filename, err);
2902 for(i=0; i<ic->nb_programs; i++)
2903 if(ic->programs[i]->id != opt_programid)
2904 ic->programs[i]->discard = AVDISCARD_ALL;
2907 ic->loop_input = loop_input;
2909 /* If not enough info to get the stream parameters, we decode the
2910 first frames to get it. (used in mpeg case for example) */
2911 ret = av_find_stream_info(ic);
2912 if (ret < 0 && verbose >= 0) {
2913 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2917 timestamp = start_time;
2918 /* add the stream start time */
2919 if (ic->start_time != AV_NOPTS_VALUE)
2920 timestamp += ic->start_time;
2922 /* if seeking requested, we execute it */
2923 if (start_time != 0) {
2924 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2926 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2927 filename, (double)timestamp / AV_TIME_BASE);
2929 /* reset seek info */
2933 /* update the current parameters so that they match the one of the input stream */
2934 for(i=0;i<ic->nb_streams;i++) {
2935 AVStream *st = ic->streams[i];
2936 AVCodecContext *enc = st->codec;
2937 avcodec_thread_init(enc, thread_count);
2938 switch(enc->codec_type) {
2939 case CODEC_TYPE_AUDIO:
2940 set_context_opts(enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2941 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2942 channel_layout = enc->channel_layout;
2943 audio_channels = enc->channels;
2944 audio_sample_rate = enc->sample_rate;
2945 audio_sample_fmt = enc->sample_fmt;
2946 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
2948 st->discard= AVDISCARD_ALL;
2950 case CODEC_TYPE_VIDEO:
2951 set_context_opts(enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2952 frame_height = enc->height;
2953 frame_width = enc->width;
2954 if(ic->streams[i]->sample_aspect_ratio.num)
2955 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
2957 frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
2958 frame_aspect_ratio *= (float) enc->width / enc->height;
2959 frame_pix_fmt = enc->pix_fmt;
2960 rfps = ic->streams[i]->r_frame_rate.num;
2961 rfps_base = ic->streams[i]->r_frame_rate.den;
2963 enc->flags |= CODEC_FLAG_EMU_EDGE;
2964 frame_height >>= enc->lowres;
2965 frame_width >>= enc->lowres;
2968 enc->debug |= FF_DEBUG_MV;
2970 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2973 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2974 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2976 (float)rfps / rfps_base, rfps, rfps_base);
2978 /* update the current frame rate to match the stream frame rate */
2979 frame_rate.num = rfps;
2980 frame_rate.den = rfps_base;
2982 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2984 st->discard= AVDISCARD_ALL;
2985 else if(video_discard)
2986 st->discard= video_discard;
2988 case CODEC_TYPE_DATA:
2990 case CODEC_TYPE_SUBTITLE:
2991 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
2992 if(subtitle_disable)
2993 st->discard = AVDISCARD_ALL;
2995 case CODEC_TYPE_ATTACHMENT:
2996 case CODEC_TYPE_UNKNOWN:
3004 input_files[nb_input_files] = ic;
3005 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3006 /* dump the file content */
3008 dump_format(ic, nb_input_files, filename, 0);
3014 av_freep(&video_codec_name);
3015 av_freep(&audio_codec_name);
3016 av_freep(&subtitle_codec_name);
3019 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3020 int *has_subtitle_ptr)
3022 int has_video, has_audio, has_subtitle, i, j;
3023 AVFormatContext *ic;
3028 for(j=0;j<nb_input_files;j++) {
3029 ic = input_files[j];
3030 for(i=0;i<ic->nb_streams;i++) {
3031 AVCodecContext *enc = ic->streams[i]->codec;
3032 switch(enc->codec_type) {
3033 case CODEC_TYPE_AUDIO:
3036 case CODEC_TYPE_VIDEO:
3039 case CODEC_TYPE_SUBTITLE:
3042 case CODEC_TYPE_DATA:
3043 case CODEC_TYPE_ATTACHMENT:
3044 case CODEC_TYPE_UNKNOWN:
3051 *has_video_ptr = has_video;
3052 *has_audio_ptr = has_audio;
3053 *has_subtitle_ptr = has_subtitle;
3056 static void new_video_stream(AVFormatContext *oc)
3059 AVCodecContext *video_enc;
3060 enum CodecID codec_id;
3062 st = av_new_stream(oc, oc->nb_streams);
3064 fprintf(stderr, "Could not alloc stream\n");
3067 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
3068 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3069 video_bitstream_filters= NULL;
3071 avcodec_thread_init(st->codec, thread_count);
3073 video_enc = st->codec;
3076 video_enc->codec_tag= video_codec_tag;
3078 if( (video_global_header&1)
3079 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3080 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3081 avcodec_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3083 if(video_global_header&2){
3084 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3085 avcodec_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3088 if (video_stream_copy) {
3089 st->stream_copy = 1;
3090 video_enc->codec_type = CODEC_TYPE_VIDEO;
3091 video_enc->sample_aspect_ratio =
3092 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3097 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3099 if (video_codec_name) {
3100 codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3101 codec = avcodec_find_encoder_by_name(video_codec_name);
3102 output_codecs[nb_ocodecs] = codec;
3104 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3105 codec = avcodec_find_encoder(codec_id);
3108 video_enc->codec_id = codec_id;
3110 set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3112 if (codec && codec->supported_framerates && !force_fps)
3113 fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3114 video_enc->time_base.den = fps.num;
3115 video_enc->time_base.num = fps.den;
3117 video_enc->width = frame_width + frame_padright + frame_padleft;
3118 video_enc->height = frame_height + frame_padtop + frame_padbottom;
3119 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3120 video_enc->pix_fmt = frame_pix_fmt;
3121 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3123 if(codec && codec->pix_fmts){
3124 const enum PixelFormat *p= codec->pix_fmts;
3126 if(*p == video_enc->pix_fmt)
3130 video_enc->pix_fmt = codec->pix_fmts[0];
3134 video_enc->gop_size = 0;
3135 if (video_qscale || same_quality) {
3136 video_enc->flags |= CODEC_FLAG_QSCALE;
3137 video_enc->global_quality=
3138 st->quality = FF_QP2LAMBDA * video_qscale;
3142 video_enc->intra_matrix = intra_matrix;
3144 video_enc->inter_matrix = inter_matrix;
3146 p= video_rc_override_string;
3149 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3151 fprintf(stderr, "error parsing rc_override\n");
3154 video_enc->rc_override=
3155 av_realloc(video_enc->rc_override,
3156 sizeof(RcOverride)*(i+1));
3157 video_enc->rc_override[i].start_frame= start;
3158 video_enc->rc_override[i].end_frame = end;
3160 video_enc->rc_override[i].qscale= q;
3161 video_enc->rc_override[i].quality_factor= 1.0;
3164 video_enc->rc_override[i].qscale= 0;
3165 video_enc->rc_override[i].quality_factor= -q/100.0;
3170 video_enc->rc_override_count=i;
3171 if (!video_enc->rc_initial_buffer_occupancy)
3172 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3173 video_enc->me_threshold= me_threshold;
3174 video_enc->intra_dc_precision= intra_dc_precision - 8;
3177 video_enc->flags|= CODEC_FLAG_PSNR;
3182 video_enc->flags |= CODEC_FLAG_PASS1;
3184 video_enc->flags |= CODEC_FLAG_PASS2;
3189 if (video_language) {
3190 av_metadata_set(&st->metadata, "language", video_language);
3191 av_freep(&video_language);
3194 /* reset some key parameters */
3196 av_freep(&video_codec_name);
3197 video_stream_copy = 0;
3200 static void new_audio_stream(AVFormatContext *oc)
3203 AVCodecContext *audio_enc;
3204 enum CodecID codec_id;
3206 st = av_new_stream(oc, oc->nb_streams);
3208 fprintf(stderr, "Could not alloc stream\n");
3211 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3213 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3214 audio_bitstream_filters= NULL;
3216 avcodec_thread_init(st->codec, thread_count);
3218 audio_enc = st->codec;
3219 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3222 audio_enc->codec_tag= audio_codec_tag;
3224 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3225 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3226 avcodec_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3228 if (audio_stream_copy) {
3229 st->stream_copy = 1;
3230 audio_enc->channels = audio_channels;
3234 set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3236 if (audio_codec_name) {
3237 codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3238 codec = avcodec_find_encoder_by_name(audio_codec_name);
3239 output_codecs[nb_ocodecs] = codec;
3241 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3242 codec = avcodec_find_encoder(codec_id);
3244 audio_enc->codec_id = codec_id;
3246 if (audio_qscale > QSCALE_NONE) {
3247 audio_enc->flags |= CODEC_FLAG_QSCALE;
3248 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3250 audio_enc->channels = audio_channels;
3251 audio_enc->sample_fmt = audio_sample_fmt;
3252 audio_enc->channel_layout = channel_layout;
3253 if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3254 audio_enc->channel_layout = 0;
3256 if(codec && codec->sample_fmts){
3257 const enum SampleFormat *p= codec->sample_fmts;
3259 if(*p == audio_enc->sample_fmt)
3263 audio_enc->sample_fmt = codec->sample_fmts[0];
3267 audio_enc->sample_rate = audio_sample_rate;
3268 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3269 if (audio_language) {
3270 av_metadata_set(&st->metadata, "language", audio_language);
3271 av_freep(&audio_language);
3274 /* reset some key parameters */
3276 av_freep(&audio_codec_name);
3277 audio_stream_copy = 0;
3280 static void new_subtitle_stream(AVFormatContext *oc)
3283 AVCodecContext *subtitle_enc;
3285 st = av_new_stream(oc, oc->nb_streams);
3287 fprintf(stderr, "Could not alloc stream\n");
3290 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3292 bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3293 subtitle_bitstream_filters= NULL;
3295 subtitle_enc = st->codec;
3296 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3298 if(subtitle_codec_tag)
3299 subtitle_enc->codec_tag= subtitle_codec_tag;
3301 if (subtitle_stream_copy) {
3302 st->stream_copy = 1;
3304 set_context_opts(avcodec_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3305 subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3306 output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3310 if (subtitle_language) {
3311 av_metadata_set(&st->metadata, "language", subtitle_language);
3312 av_freep(&subtitle_language);
3315 subtitle_disable = 0;
3316 av_freep(&subtitle_codec_name);
3317 subtitle_stream_copy = 0;
3320 static void opt_new_audio_stream(void)
3322 AVFormatContext *oc;
3323 if (nb_output_files <= 0) {
3324 fprintf(stderr, "At least one output file must be specified\n");
3327 oc = output_files[nb_output_files - 1];
3328 new_audio_stream(oc);
3331 static void opt_new_video_stream(void)
3333 AVFormatContext *oc;
3334 if (nb_output_files <= 0) {
3335 fprintf(stderr, "At least one output file must be specified\n");
3338 oc = output_files[nb_output_files - 1];
3339 new_video_stream(oc);
3342 static void opt_new_subtitle_stream(void)
3344 AVFormatContext *oc;
3345 if (nb_output_files <= 0) {
3346 fprintf(stderr, "At least one output file must be specified\n");
3349 oc = output_files[nb_output_files - 1];
3350 new_subtitle_stream(oc);
3353 static void opt_output_file(const char *filename)
3355 AVFormatContext *oc;
3356 int use_video, use_audio, use_subtitle;
3357 int input_has_video, input_has_audio, input_has_subtitle;
3358 AVFormatParameters params, *ap = ¶ms;
3359 AVOutputFormat *file_oformat;
3361 if (!strcmp(filename, "-"))
3364 oc = avformat_alloc_context();
3366 print_error(filename, AVERROR(ENOMEM));
3370 if (last_asked_format) {
3371 file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3372 if (!file_oformat) {
3373 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3376 last_asked_format = NULL;
3378 file_oformat = av_guess_format(NULL, filename, NULL);
3379 if (!file_oformat) {
3380 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3386 oc->oformat = file_oformat;
3387 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3389 if (!strcmp(file_oformat->name, "ffm") &&
3390 av_strstart(filename, "http:", NULL)) {
3391 /* special case for files sent to ffserver: we get the stream
3392 parameters from ffserver */
3393 int err = read_ffserver_streams(oc, filename);
3395 print_error(filename, err);
3399 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3400 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3401 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3403 /* disable if no corresponding type found and at least one
3405 if (nb_input_files > 0) {
3406 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3407 &input_has_subtitle);
3408 if (!input_has_video)
3410 if (!input_has_audio)
3412 if (!input_has_subtitle)
3416 /* manual disable */
3417 if (audio_disable) {
3420 if (video_disable) {
3423 if (subtitle_disable) {
3428 new_video_stream(oc);
3432 new_audio_stream(oc);
3436 new_subtitle_stream(oc);
3439 oc->timestamp = rec_timestamp;
3441 for(; metadata_count>0; metadata_count--){
3442 av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3443 metadata[metadata_count-1].value);
3445 av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3448 output_files[nb_output_files++] = oc;
3450 /* check filename in case of an image number is expected */
3451 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3452 if (!av_filename_number_test(oc->filename)) {
3453 print_error(oc->filename, AVERROR_NUMEXPECTED);
3458 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3459 /* test if it already exists to avoid loosing precious files */
3460 if (!file_overwrite &&
3461 (strchr(filename, ':') == NULL ||
3462 filename[1] == ':' ||
3463 av_strstart(filename, "file:", NULL))) {
3464 if (url_exist(filename)) {
3466 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3468 if (!read_yesno()) {
3469 fprintf(stderr, "Not overwriting - exiting\n");
3474 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3481 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3482 fprintf(stderr, "Could not open '%s'\n", filename);
3487 memset(ap, 0, sizeof(*ap));
3488 if (av_set_parameters(oc, ap) < 0) {
3489 fprintf(stderr, "%s: Invalid encoding parameters\n",
3494 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3495 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3496 oc->loop_output = loop_output;
3497 oc->flags |= AVFMT_FLAG_NONBLOCK;
3499 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3502 /* same option as mencoder */
3503 static void opt_pass(const char *pass_str)
3506 pass = atoi(pass_str);
3507 if (pass != 1 && pass != 2) {
3508 fprintf(stderr, "pass number can be only 1 or 2\n");
3514 static int64_t getutime(void)
3517 struct rusage rusage;
3519 getrusage(RUSAGE_SELF, &rusage);
3520 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3521 #elif HAVE_GETPROCESSTIMES
3523 FILETIME c, e, k, u;
3524 proc = GetCurrentProcess();
3525 GetProcessTimes(proc, &c, &e, &k, &u);
3526 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3528 return av_gettime();
3532 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3535 const char *p = str;
3542 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3549 static void opt_inter_matrix(const char *arg)
3551 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3552 parse_matrix_coeffs(inter_matrix, arg);
3555 static void opt_intra_matrix(const char *arg)
3557 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3558 parse_matrix_coeffs(intra_matrix, arg);
3562 * Trivial log callback.
3563 * Only suitable for show_help and similar since it lacks prefix handling.
3565 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3567 vfprintf(stdout, fmt, vl);
3570 static void show_usage(void)
3572 printf("Hyper fast Audio and Video encoder\n");
3573 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3577 static void show_help(void)
3579 av_log_set_callback(log_callback_help);
3581 show_help_options(options, "Main options:\n",
3582 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3583 show_help_options(options, "\nAdvanced options:\n",
3584 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3586 show_help_options(options, "\nVideo options:\n",
3587 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3589 show_help_options(options, "\nAdvanced Video options:\n",
3590 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3591 OPT_VIDEO | OPT_EXPERT);
3592 show_help_options(options, "\nAudio options:\n",
3593 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3595 show_help_options(options, "\nAdvanced Audio options:\n",
3596 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3597 OPT_AUDIO | OPT_EXPERT);
3598 show_help_options(options, "\nSubtitle options:\n",
3599 OPT_SUBTITLE | OPT_GRAB,
3601 show_help_options(options, "\nAudio/Video grab options:\n",
3605 av_opt_show(avcodec_opts[0], NULL);
3607 av_opt_show(avformat_opts, NULL);
3609 av_opt_show(sws_opts, NULL);
3612 static void opt_target(const char *arg)
3614 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3615 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3617 if(!strncmp(arg, "pal-", 4)) {
3620 } else if(!strncmp(arg, "ntsc-", 5)) {
3623 } else if(!strncmp(arg, "film-", 5)) {
3628 /* Calculate FR via float to avoid int overflow */
3629 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3632 } else if((fr == 29970) || (fr == 23976)) {
3635 /* Try to determine PAL/NTSC by peeking in the input files */
3636 if(nb_input_files) {
3638 for(j = 0; j < nb_input_files; j++) {
3639 for(i = 0; i < input_files[j]->nb_streams; i++) {
3640 AVCodecContext *c = input_files[j]->streams[i]->codec;
3641 if(c->codec_type != CODEC_TYPE_VIDEO)
3643 fr = c->time_base.den * 1000 / c->time_base.num;
3647 } else if((fr == 29970) || (fr == 23976)) {
3657 if(verbose && norm != UNKNOWN)
3658 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3661 if(norm == UNKNOWN) {
3662 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3663 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3664 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3668 if(!strcmp(arg, "vcd")) {
3670 opt_video_codec("mpeg1video");
3671 opt_audio_codec("mp2");
3674 opt_frame_size(norm == PAL ? "352x288" : "352x240");
3675 opt_frame_rate(NULL, frame_rates[norm]);
3676 opt_default("g", norm == PAL ? "15" : "18");
3678 opt_default("b", "1150000");
3679 opt_default("maxrate", "1150000");
3680 opt_default("minrate", "1150000");
3681 opt_default("bufsize", "327680"); // 40*1024*8;
3683 opt_default("ab", "224000");
3684 audio_sample_rate = 44100;
3687 opt_default("packetsize", "2324");
3688 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3690 /* We have to offset the PTS, so that it is consistent with the SCR.
3691 SCR starts at 36000, but the first two packs contain only padding
3692 and the first pack from the other stream, respectively, may also have
3693 been written before.
3694 So the real data starts at SCR 36000+3*1200. */
3695 mux_preload= (36000+3*1200) / 90000.0; //0.44
3696 } else if(!strcmp(arg, "svcd")) {
3698 opt_video_codec("mpeg2video");
3699 opt_audio_codec("mp2");
3702 opt_frame_size(norm == PAL ? "480x576" : "480x480");
3703 opt_frame_rate(NULL, frame_rates[norm]);
3704 opt_default("g", norm == PAL ? "15" : "18");
3706 opt_default("b", "2040000");
3707 opt_default("maxrate", "2516000");
3708 opt_default("minrate", "0"); //1145000;
3709 opt_default("bufsize", "1835008"); //224*1024*8;
3710 opt_default("flags", "+scan_offset");
3713 opt_default("ab", "224000");
3714 audio_sample_rate = 44100;
3716 opt_default("packetsize", "2324");
3718 } else if(!strcmp(arg, "dvd")) {
3720 opt_video_codec("mpeg2video");
3721 opt_audio_codec("ac3");
3724 opt_frame_size(norm == PAL ? "720x576" : "720x480");
3725 opt_frame_rate(NULL, frame_rates[norm]);
3726 opt_default("g", norm == PAL ? "15" : "18");
3728 opt_default("b", "6000000");
3729 opt_default("maxrate", "9000000");
3730 opt_default("minrate", "0"); //1500000;
3731 opt_default("bufsize", "1835008"); //224*1024*8;
3733 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3734 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3736 opt_default("ab", "448000");
3737 audio_sample_rate = 48000;
3739 } else if(!strncmp(arg, "dv", 2)) {
3743 opt_frame_size(norm == PAL ? "720x576" : "720x480");
3744 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3745 (norm == PAL ? "yuv420p" : "yuv411p"));
3746 opt_frame_rate(NULL, frame_rates[norm]);
3748 audio_sample_rate = 48000;
3752 fprintf(stderr, "Unknown target: %s\n", arg);
3757 static void opt_vstats_file (const char *arg)
3759 av_free (vstats_filename);
3760 vstats_filename=av_strdup (arg);
3763 static void opt_vstats (void)
3766 time_t today2 = time(NULL);
3767 struct tm *today = localtime(&today2);
3769 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3771 opt_vstats_file(filename);
3774 static int opt_bsf(const char *opt, const char *arg)
3776 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3777 AVBitStreamFilterContext **bsfp;
3780 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3784 bsfp= *opt == 'v' ? &video_bitstream_filters :
3785 *opt == 'a' ? &audio_bitstream_filters :
3786 &subtitle_bitstream_filters;
3788 bsfp= &(*bsfp)->next;
3795 static int opt_preset(const char *opt, const char *arg)
3798 char filename[1000], tmp[1000], tmp2[1000], line[1000];
3800 const char *base[2]= { getenv("HOME"),
3805 for(i=!base[0]; i<2 && !f; i++){
3806 snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
3807 f= fopen(filename, "r");
3809 char *codec_name= *opt == 'v' ? video_codec_name :
3810 *opt == 'a' ? audio_codec_name :
3811 subtitle_codec_name;
3812 snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i], i ? "" : "/.ffmpeg", codec_name, arg);
3813 f= fopen(filename, "r");
3817 av_strlcpy(filename, arg, sizeof(filename));
3818 f= fopen(filename, "r");
3822 fprintf(stderr, "File for preset '%s' not found\n", arg);
3827 int e= fscanf(f, "%999[^\n]\n", line) - 1;
3828 if(line[0] == '#' && !e)
3830 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3832 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3835 if(!strcmp(tmp, "acodec")){
3836 opt_audio_codec(tmp2);
3837 }else if(!strcmp(tmp, "vcodec")){
3838 opt_video_codec(tmp2);
3839 }else if(!strcmp(tmp, "scodec")){
3840 opt_subtitle_codec(tmp2);
3841 }else if(opt_default(tmp, tmp2) < 0){
3842 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3852 static const OptionDef options[] = {
3854 #include "cmdutils_common_opts.h"
3855 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3856 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3857 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3858 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3859 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3860 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3861 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3862 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3863 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3864 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
3865 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_rec_timestamp}, "set the timestamp ('now' to set the current time)", "time" },
3866 { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
3867 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3868 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3869 "add timings for benchmarking" },
3870 { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
3871 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3872 "dump each input packet" },
3873 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3874 "when dumping packets, also dump the payload" },
3875 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3876 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3877 { "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)", "" },
3878 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
3879 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3880 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3881 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3882 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3883 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3884 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3885 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3886 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3887 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3888 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3889 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
3890 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
3893 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3894 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3895 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3896 { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3897 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3898 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3899 { "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" },
3900 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3901 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3902 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3903 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3904 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3905 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3906 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3907 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3908 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3909 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3910 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3911 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3912 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3913 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3914 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3915 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
3916 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3917 "use same video quality as source (implies VBR)" },
3918 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3919 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
3920 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3921 "deinterlace pictures" },
3922 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3923 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3924 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3925 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3926 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3927 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3928 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3929 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3930 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3931 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
3932 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3933 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
3936 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3937 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3938 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3939 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3940 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3941 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3942 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3943 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3944 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3945 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3946 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3947 { "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" },
3949 /* subtitle options */
3950 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3951 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3952 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3953 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3954 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
3957 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3958 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3959 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3962 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3963 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3965 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3966 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3967 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3969 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3970 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3971 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3972 { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
3974 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3978 int main(int argc, char **argv)
3983 avcodec_register_all();
3984 avdevice_register_all();
3988 if(isatty(STDIN_FILENO))
3989 url_set_interrupt_cb(decode_interrupt_cb);
3992 for(i=0; i<CODEC_TYPE_NB; i++){
3993 avcodec_opts[i]= avcodec_alloc_context2(i);
3995 avformat_opts = avformat_alloc_context();
3996 sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
4001 parse_options(argc, argv, options, opt_output_file);
4003 if(nb_output_files <= 0 && nb_input_files == 0) {
4005 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4009 /* file converter / grab */
4010 if (nb_output_files <= 0) {
4011 fprintf(stderr, "At least one output file must be specified\n");
4015 if (nb_input_files == 0) {
4016 fprintf(stderr, "At least one input file must be specified\n");
4021 if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
4022 stream_maps, nb_stream_maps) < 0)
4024 ti = getutime() - ti;
4026 printf("bench: utime=%0.3fs\n", ti / 1000000.0);