3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 /* needed for usleep() */
23 #define _XOPEN_SOURCE 600
34 #include "libavformat/avformat.h"
35 #include "libavdevice/avdevice.h"
36 #include "libswscale/swscale.h"
37 #include "libavcodec/opt.h"
38 #include "libavcodec/audioconvert.h"
39 #include "libavcodec/colorspace.h"
40 #include "libavutil/fifo.h"
41 #include "libavutil/pixdesc.h"
42 #include "libavutil/avstring.h"
43 #include "libavformat/os_support.h"
45 #if HAVE_SYS_RESOURCE_H
46 #include <sys/types.h>
48 #include <sys/resource.h>
49 #elif HAVE_GETPROCESSTIMES
52 #if HAVE_GETPROCESSMEMORYINFO
58 #include <sys/select.h>
63 #include <sys/ioctl.h>
69 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
79 const char program_name[] = "FFmpeg";
80 const int program_birth_year = 2000;
82 /* select an input stream for an output stream */
83 typedef struct AVStreamMap {
87 int sync_stream_index;
90 /** select an input file for an output file */
91 typedef struct AVMetaDataMap {
96 static const OptionDef options[];
100 static const char *last_asked_format = NULL;
101 static AVFormatContext *input_files[MAX_FILES];
102 static int64_t input_files_ts_offset[MAX_FILES];
103 static double input_files_ts_scale[MAX_FILES][MAX_STREAMS];
104 static AVCodec *input_codecs[MAX_FILES*MAX_STREAMS];
105 static int nb_input_files = 0;
106 static int nb_icodecs;
108 static AVFormatContext *output_files[MAX_FILES];
109 static AVCodec *output_codecs[MAX_FILES*MAX_STREAMS];
110 static int nb_output_files = 0;
111 static int nb_ocodecs;
113 static AVStreamMap stream_maps[MAX_FILES*MAX_STREAMS];
114 static int nb_stream_maps;
116 static AVMetaDataMap meta_data_maps[MAX_FILES];
117 static int nb_meta_data_maps;
119 static int frame_width = 0;
120 static int frame_height = 0;
121 static float frame_aspect_ratio = 0;
122 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
123 static enum SampleFormat audio_sample_fmt = SAMPLE_FMT_NONE;
124 static int frame_padtop = 0;
125 static int frame_padbottom = 0;
126 static int frame_padleft = 0;
127 static int frame_padright = 0;
128 static int padcolor[3] = {16,128,128}; /* default to black */
129 static int frame_topBand = 0;
130 static int frame_bottomBand = 0;
131 static int frame_leftBand = 0;
132 static int frame_rightBand = 0;
133 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
134 static AVRational frame_rate;
135 static float video_qscale = 0;
136 static uint16_t *intra_matrix = NULL;
137 static uint16_t *inter_matrix = NULL;
138 static const char *video_rc_override_string=NULL;
139 static int video_disable = 0;
140 static int video_discard = 0;
141 static char *video_codec_name = NULL;
142 static int video_codec_tag = 0;
143 static char *video_language = NULL;
144 static int same_quality = 0;
145 static int do_deinterlace = 0;
146 static int top_field_first = -1;
147 static int me_threshold = 0;
148 static int intra_dc_precision = 8;
149 static int loop_input = 0;
150 static int loop_output = AVFMT_NOOUTPUTLOOP;
151 static int qp_hist = 0;
153 static int intra_only = 0;
154 static int audio_sample_rate = 44100;
155 static int64_t channel_layout = 0;
156 #define QSCALE_NONE -99999
157 static float audio_qscale = QSCALE_NONE;
158 static int audio_disable = 0;
159 static int audio_channels = 1;
160 static char *audio_codec_name = NULL;
161 static int audio_codec_tag = 0;
162 static char *audio_language = NULL;
164 static int subtitle_disable = 0;
165 static char *subtitle_codec_name = NULL;
166 static char *subtitle_language = NULL;
167 static int subtitle_codec_tag = 0;
169 static float mux_preload= 0.5;
170 static float mux_max_delay= 0.7;
172 static int64_t recording_time = INT64_MAX;
173 static int64_t start_time = 0;
174 static int64_t rec_timestamp = 0;
175 static int64_t input_ts_offset = 0;
176 static int file_overwrite = 0;
177 static int metadata_count;
178 static AVMetadataTag *metadata;
179 static int do_benchmark = 0;
180 static int do_hex_dump = 0;
181 static int do_pkt_dump = 0;
182 static int do_psnr = 0;
183 static int do_pass = 0;
184 static char *pass_logfilename_prefix = NULL;
185 static int audio_stream_copy = 0;
186 static int video_stream_copy = 0;
187 static int subtitle_stream_copy = 0;
188 static int video_sync_method= -1;
189 static int audio_sync_method= 0;
190 static float audio_drift_threshold= 0.1;
191 static int copy_ts= 0;
192 static int opt_shortest = 0;
193 static int video_global_header = 0;
194 static char *vstats_filename;
195 static FILE *vstats_file;
196 static int opt_programid = 0;
197 static int copy_initial_nonkeyframes = 0;
199 static int rate_emu = 0;
201 static int video_channel = 0;
202 static char *video_standard;
204 static int audio_volume = 256;
206 static int exit_on_error = 0;
207 static int using_stdin = 0;
208 static int verbose = 1;
209 static int thread_count= 1;
210 static int q_pressed = 0;
211 static int64_t video_size = 0;
212 static int64_t audio_size = 0;
213 static int64_t extra_size = 0;
214 static int nb_frames_dup = 0;
215 static int nb_frames_drop = 0;
216 static int input_sync;
217 static uint64_t limit_filesize = 0;
218 static int force_fps = 0;
220 static int pgmyuv_compatibility_hack=0;
221 static float dts_delta_threshold = 10;
223 static unsigned int sws_flags = SWS_BICUBIC;
225 static int64_t timer_start;
227 static uint8_t *audio_buf;
228 static uint8_t *audio_out;
229 unsigned int allocated_audio_out_size, allocated_audio_buf_size;
231 static short *samples;
233 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
234 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
235 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
236 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
238 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
240 struct AVInputStream;
242 typedef struct AVOutputStream {
243 int file_index; /* file index */
244 int index; /* stream index in the output file */
245 int source_index; /* AVInputStream index */
246 AVStream *st; /* stream in the output file */
247 int encoding_needed; /* true if encoding needed for this stream */
249 /* input pts and corresponding output pts
251 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
252 struct AVInputStream *sync_ist; /* input stream to sync against */
253 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
256 AVFrame pict_tmp; /* temporary image for resampling */
257 struct SwsContext *img_resample_ctx; /* for image resampling */
260 int resample_pix_fmt;
262 /* full frame size of first frame */
266 /* cropping area sizes */
273 /* cropping area of first frame */
274 int original_topBand;
275 int original_bottomBand;
276 int original_leftBand;
277 int original_rightBand;
279 /* padding area sizes */
288 ReSampleContext *resample; /* for audio resampling */
290 AVAudioConvert *reformat_ctx;
291 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
295 typedef struct AVInputStream {
299 int discard; /* true if stream data should be discarded */
300 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
301 int64_t sample_index; /* current sample */
303 int64_t start; /* time when read started */
304 int64_t next_pts; /* synthetic pts for cases where pkt.pts
306 int64_t pts; /* current pts */
307 int is_start; /* is 1 at the start and after a discontinuity */
308 int showed_multi_packet_warning;
309 int is_past_recording_time;
312 typedef struct AVInputFile {
313 int eof_reached; /* true if eof reached */
314 int ist_index; /* index of first stream in ist_table */
315 int buffer_size; /* current total buffer size */
316 int nb_streams; /* nb streams we are aware of */
321 /* init terminal so that we can grab keys */
322 static struct termios oldtty;
325 static void term_exit(void)
328 tcsetattr (0, TCSANOW, &oldtty);
332 static volatile int received_sigterm = 0;
335 sigterm_handler(int sig)
337 received_sigterm = sig;
341 static void term_init(void)
349 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
350 |INLCR|IGNCR|ICRNL|IXON);
351 tty.c_oflag |= OPOST;
352 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
353 tty.c_cflag &= ~(CSIZE|PARENB);
358 tcsetattr (0, TCSANOW, &tty);
359 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
362 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
363 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
365 signal(SIGXCPU, sigterm_handler);
369 register a function to be called at normal program termination
372 #if CONFIG_BEOS_NETSERVER
373 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
377 /* read a key without blocking */
378 static int read_key(void)
383 #if !CONFIG_BEOS_NETSERVER
391 n = select(1, &rfds, NULL, NULL, &tv);
407 static int decode_interrupt_cb(void)
409 return q_pressed || (q_pressed = read_key() == 'q');
412 static int av_exit(int ret)
417 for(i=0;i<nb_output_files;i++) {
418 /* maybe av_close_output_file ??? */
419 AVFormatContext *s = output_files[i];
421 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
423 for(j=0;j<s->nb_streams;j++) {
424 av_metadata_free(&s->streams[j]->metadata);
425 av_free(s->streams[j]->codec);
426 av_free(s->streams[j]);
428 for(j=0;j<s->nb_programs;j++) {
429 av_metadata_free(&s->programs[j]->metadata);
431 for(j=0;j<s->nb_chapters;j++) {
432 av_metadata_free(&s->chapters[j]->metadata);
434 av_metadata_free(&s->metadata);
437 for(i=0;i<nb_input_files;i++)
438 av_close_input_file(input_files[i]);
440 av_free(intra_matrix);
441 av_free(inter_matrix);
445 av_free(vstats_filename);
449 av_free(video_codec_name);
450 av_free(audio_codec_name);
451 av_free(subtitle_codec_name);
453 av_free(video_standard);
455 #if CONFIG_POWERPC_PERF
456 void powerpc_display_perf_report(void);
457 powerpc_display_perf_report();
458 #endif /* CONFIG_POWERPC_PERF */
460 for (i=0;i<CODEC_TYPE_NB;i++)
461 av_free(avcodec_opts[i]);
462 av_free(avformat_opts);
466 allocated_audio_buf_size= allocated_audio_out_size= 0;
469 if (received_sigterm) {
471 "Received signal %d: terminating.\n",
472 (int) received_sigterm);
476 exit(ret); /* not all OS-es handle main() return value */
480 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
486 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
489 /* copy stream format */
490 s->nb_streams = ic->nb_streams;
491 for(i=0;i<ic->nb_streams;i++) {
494 // FIXME: a more elegant solution is needed
495 st = av_mallocz(sizeof(AVStream));
496 memcpy(st, ic->streams[i], sizeof(AVStream));
497 st->codec = avcodec_alloc_context();
499 print_error(filename, AVERROR(ENOMEM));
502 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
505 if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
507 else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
510 if(!st->codec->thread_count)
511 st->codec->thread_count = 1;
512 if(st->codec->thread_count>1)
513 avcodec_thread_init(st->codec, st->codec->thread_count);
515 if(st->codec->flags & CODEC_FLAG_BITEXACT)
520 s->timestamp = av_gettime();
522 av_close_input_file(ic);
527 get_sync_ipts(const AVOutputStream *ost)
529 const AVInputStream *ist = ost->sync_ist;
530 return (double)(ist->pts - start_time)/AV_TIME_BASE;
533 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
537 AVPacket new_pkt= *pkt;
538 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
539 &new_pkt.data, &new_pkt.size,
540 pkt->data, pkt->size,
541 pkt->flags & PKT_FLAG_KEY);
544 new_pkt.destruct= av_destruct_packet;
546 fprintf(stderr, "%s failed for stream %d, codec %s",
547 bsfc->filter->name, pkt->stream_index,
548 avctx->codec ? avctx->codec->name : "copy");
558 ret= av_interleaved_write_frame(s, pkt);
560 print_error("av_interleaved_write_frame()", ret);
565 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
567 static void do_audio_out(AVFormatContext *s,
570 unsigned char *buf, int size)
573 int64_t audio_out_size, audio_buf_size;
574 int64_t allocated_for_size= size;
576 int size_out, frame_bytes, ret;
577 AVCodecContext *enc= ost->st->codec;
578 AVCodecContext *dec= ist->st->codec;
579 int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
580 int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
581 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
584 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
585 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
586 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
587 audio_buf_size*= osize*enc->channels;
589 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
590 if(coded_bps > 8*osize)
591 audio_out_size= audio_out_size * coded_bps / (8*osize);
592 audio_out_size += FF_MIN_BUFFER_SIZE;
594 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
595 fprintf(stderr, "Buffer sizes too large\n");
599 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
600 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
601 if (!audio_buf || !audio_out){
602 fprintf(stderr, "Out of memory in do_audio_out\n");
606 if (enc->channels != dec->channels)
607 ost->audio_resample = 1;
609 if (ost->audio_resample && !ost->resample) {
610 if (dec->sample_fmt != SAMPLE_FMT_S16)
611 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
612 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
613 enc->sample_rate, dec->sample_rate,
614 enc->sample_fmt, dec->sample_fmt,
616 if (!ost->resample) {
617 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
618 dec->channels, dec->sample_rate,
619 enc->channels, enc->sample_rate);
624 #define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
625 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
626 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
627 if (ost->reformat_ctx)
628 av_audio_convert_free(ost->reformat_ctx);
629 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
630 dec->sample_fmt, 1, NULL, 0);
631 if (!ost->reformat_ctx) {
632 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
633 avcodec_get_sample_fmt_name(dec->sample_fmt),
634 avcodec_get_sample_fmt_name(enc->sample_fmt));
637 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
640 if(audio_sync_method){
641 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
642 - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2);
643 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
644 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
646 //FIXME resample delay
647 if(fabs(delta) > 50){
648 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
650 byte_delta= FFMAX(byte_delta, -size);
654 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
659 static uint8_t *input_tmp= NULL;
660 input_tmp= av_realloc(input_tmp, byte_delta + size);
662 if(byte_delta > allocated_for_size - size){
663 allocated_for_size= byte_delta + (int64_t)size;
668 memset(input_tmp, 0, byte_delta);
669 memcpy(input_tmp + byte_delta, buf, size);
673 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
675 }else if(audio_sync_method>1){
676 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
677 assert(ost->audio_resample);
679 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
680 // 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));
681 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
685 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
686 - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
688 if (ost->audio_resample) {
690 size_out = audio_resample(ost->resample,
691 (short *)buftmp, (short *)buf,
692 size / (ist->st->codec->channels * isize));
693 size_out = size_out * enc->channels * osize;
699 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
700 const void *ibuf[6]= {buftmp};
701 void *obuf[6]= {audio_buf};
702 int istride[6]= {isize};
703 int ostride[6]= {osize};
704 int len= size_out/istride[0];
705 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
706 printf("av_audio_convert() failed\n");
712 size_out = len*osize;
715 /* now encode as many frames as possible */
716 if (enc->frame_size > 1) {
717 /* output resampled raw samples */
718 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
719 fprintf(stderr, "av_fifo_realloc2() failed\n");
722 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
724 frame_bytes = enc->frame_size * osize * enc->channels;
726 while (av_fifo_size(ost->fifo) >= frame_bytes) {
728 av_init_packet(&pkt);
730 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
732 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
734 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
737 fprintf(stderr, "Audio encoding failed\n");
741 pkt.stream_index= ost->index;
744 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
745 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
746 pkt.flags |= PKT_FLAG_KEY;
747 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
749 ost->sync_opts += enc->frame_size;
753 av_init_packet(&pkt);
755 ost->sync_opts += size_out / (osize * enc->channels);
757 /* output a pcm frame */
758 /* determine the size of the coded buffer */
761 size_out = size_out*coded_bps/8;
763 if(size_out > audio_out_size){
764 fprintf(stderr, "Internal error, buffer size too small\n");
768 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
769 ret = avcodec_encode_audio(enc, audio_out, size_out,
772 fprintf(stderr, "Audio encoding failed\n");
776 pkt.stream_index= ost->index;
779 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
780 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
781 pkt.flags |= PKT_FLAG_KEY;
782 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
786 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
790 AVPicture picture_tmp;
793 dec = ist->st->codec;
795 /* deinterlace : must be done before any resize */
796 if (do_deinterlace) {
799 /* create temporary picture */
800 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
801 buf = av_malloc(size);
805 picture2 = &picture_tmp;
806 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
808 if(avpicture_deinterlace(picture2, picture,
809 dec->pix_fmt, dec->width, dec->height) < 0) {
810 /* if error, do not deinterlace */
811 fprintf(stderr, "Deinterlacing failed\n");
820 if (picture != picture2)
821 *picture = *picture2;
825 /* we begin to correct av delay at this threshold */
826 #define AV_DELAY_MAX 0.100
828 static void do_subtitle_out(AVFormatContext *s,
834 static uint8_t *subtitle_out = NULL;
835 int subtitle_out_max_size = 1024 * 1024;
836 int subtitle_out_size, nb, i;
840 if (pts == AV_NOPTS_VALUE) {
841 fprintf(stderr, "Subtitle packets must have a pts\n");
847 enc = ost->st->codec;
850 subtitle_out = av_malloc(subtitle_out_max_size);
853 /* Note: DVB subtitle need one packet to draw them and one other
854 packet to clear them */
855 /* XXX: signal it in the codec context ? */
856 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
861 for(i = 0; i < nb; i++) {
862 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
863 // start_display_time is required to be 0
864 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
865 sub->end_display_time -= sub->start_display_time;
866 sub->start_display_time = 0;
867 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
868 subtitle_out_max_size, sub);
869 if (subtitle_out_size < 0) {
870 fprintf(stderr, "Subtitle encoding failed\n");
874 av_init_packet(&pkt);
875 pkt.stream_index = ost->index;
876 pkt.data = subtitle_out;
877 pkt.size = subtitle_out_size;
878 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
879 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
880 /* XXX: the pts correction is handled here. Maybe handling
881 it in the codec would be better */
883 pkt.pts += 90 * sub->start_display_time;
885 pkt.pts += 90 * sub->end_display_time;
887 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
891 static int bit_buffer_size= 1024*256;
892 static uint8_t *bit_buffer= NULL;
894 static void do_video_out(AVFormatContext *s,
900 int nb_frames, i, ret;
901 int64_t topBand, bottomBand, leftBand, rightBand;
902 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
903 AVFrame picture_crop_temp, picture_pad_temp;
904 AVCodecContext *enc, *dec;
906 avcodec_get_frame_defaults(&picture_crop_temp);
907 avcodec_get_frame_defaults(&picture_pad_temp);
909 enc = ost->st->codec;
910 dec = ist->st->codec;
912 /* by default, we output a single frame */
917 if(video_sync_method){
919 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
920 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
923 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
927 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
928 }else if (vdelta > 1.1)
929 nb_frames = lrintf(vdelta);
930 //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);
934 fprintf(stderr, "*** drop!\n");
935 }else if (nb_frames > 1) {
936 nb_frames_dup += nb_frames - 1;
938 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
941 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
943 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
947 if (ost->video_crop) {
948 if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
949 fprintf(stderr, "error cropping picture\n");
954 formatted_picture = &picture_crop_temp;
956 formatted_picture = in_picture;
959 final_picture = formatted_picture;
960 padding_src = formatted_picture;
961 resampling_dst = &ost->pict_tmp;
962 if (ost->video_pad) {
963 final_picture = &ost->pict_tmp;
964 if (ost->video_resample) {
965 if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
966 fprintf(stderr, "error padding picture\n");
971 resampling_dst = &picture_pad_temp;
975 if( (ost->resample_height != (ist->st->codec->height - (ost->topBand + ost->bottomBand)))
976 || (ost->resample_width != (ist->st->codec->width - (ost->leftBand + ost->rightBand)))
977 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
979 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));
980 if(!ost->video_resample)
984 if (ost->video_resample) {
986 final_picture = &ost->pict_tmp;
987 if( (ost->resample_height != (ist->st->codec->height - (ost->topBand + ost->bottomBand)))
988 || (ost->resample_width != (ist->st->codec->width - (ost->leftBand + ost->rightBand)))
989 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
991 /* keep bands proportional to the frame size */
992 topBand = ((int64_t)ist->st->codec->height * ost->original_topBand / ost->original_height) & ~1;
993 bottomBand = ((int64_t)ist->st->codec->height * ost->original_bottomBand / ost->original_height) & ~1;
994 leftBand = ((int64_t)ist->st->codec->width * ost->original_leftBand / ost->original_width) & ~1;
995 rightBand = ((int64_t)ist->st->codec->width * ost->original_rightBand / ost->original_width) & ~1;
997 /* sanity check to ensure no bad band sizes sneak in */
998 assert(topBand <= INT_MAX && topBand >= 0);
999 assert(bottomBand <= INT_MAX && bottomBand >= 0);
1000 assert(leftBand <= INT_MAX && leftBand >= 0);
1001 assert(rightBand <= INT_MAX && rightBand >= 0);
1003 ost->topBand = topBand;
1004 ost->bottomBand = bottomBand;
1005 ost->leftBand = leftBand;
1006 ost->rightBand = rightBand;
1008 ost->resample_height = ist->st->codec->height - (ost->topBand + ost->bottomBand);
1009 ost->resample_width = ist->st->codec->width - (ost->leftBand + ost->rightBand);
1010 ost->resample_pix_fmt= ist->st->codec->pix_fmt;
1012 /* initialize a new scaler context */
1013 sws_freeContext(ost->img_resample_ctx);
1014 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1015 ost->img_resample_ctx = sws_getContext(
1016 ist->st->codec->width - (ost->leftBand + ost->rightBand),
1017 ist->st->codec->height - (ost->topBand + ost->bottomBand),
1018 ist->st->codec->pix_fmt,
1019 ost->st->codec->width - (ost->padleft + ost->padright),
1020 ost->st->codec->height - (ost->padtop + ost->padbottom),
1021 ost->st->codec->pix_fmt,
1022 sws_flags, NULL, NULL, NULL);
1023 if (ost->img_resample_ctx == NULL) {
1024 fprintf(stderr, "Cannot get resampling context\n");
1028 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1029 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1032 if (ost->video_pad) {
1033 av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
1034 enc->height, enc->width, enc->pix_fmt,
1035 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
1038 /* duplicates frame if needed */
1039 for(i=0;i<nb_frames;i++) {
1041 av_init_packet(&pkt);
1042 pkt.stream_index= ost->index;
1044 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1045 /* raw pictures are written as AVPicture structure to
1046 avoid any copies. We support temorarily the older
1048 AVFrame* old_frame = enc->coded_frame;
1049 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1050 pkt.data= (uint8_t *)final_picture;
1051 pkt.size= sizeof(AVPicture);
1052 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1053 pkt.flags |= PKT_FLAG_KEY;
1055 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1056 enc->coded_frame = old_frame;
1058 AVFrame big_picture;
1060 big_picture= *final_picture;
1061 /* better than nothing: use input picture interlaced
1063 big_picture.interlaced_frame = in_picture->interlaced_frame;
1064 if(avcodec_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1065 if(top_field_first == -1)
1066 big_picture.top_field_first = in_picture->top_field_first;
1068 big_picture.top_field_first = top_field_first;
1071 /* handles sameq here. This is not correct because it may
1072 not be a global option */
1074 big_picture.quality = ist->st->quality;
1076 big_picture.quality = ost->st->quality;
1078 big_picture.pict_type = 0;
1079 // big_picture.pts = AV_NOPTS_VALUE;
1080 big_picture.pts= ost->sync_opts;
1081 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1082 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1083 ret = avcodec_encode_video(enc,
1084 bit_buffer, bit_buffer_size,
1087 fprintf(stderr, "Video encoding failed\n");
1092 pkt.data= bit_buffer;
1094 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1095 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1096 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1097 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1098 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1100 if(enc->coded_frame->key_frame)
1101 pkt.flags |= PKT_FLAG_KEY;
1102 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1105 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1106 // enc->frame_number-1, ret, enc->pict_type);
1107 /* if two pass, output log */
1108 if (ost->logfile && enc->stats_out) {
1109 fprintf(ost->logfile, "%s", enc->stats_out);
1114 ost->frame_number++;
1118 static double psnr(double d){
1119 return -10.0*log(d)/log(10.0);
1122 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1125 AVCodecContext *enc;
1127 double ti1, bitrate, avg_bitrate;
1129 /* this is executed just the first time do_video_stats is called */
1131 vstats_file = fopen(vstats_filename, "w");
1138 enc = ost->st->codec;
1139 if (enc->codec_type == CODEC_TYPE_VIDEO) {
1140 frame_number = ost->frame_number;
1141 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1142 if (enc->flags&CODEC_FLAG_PSNR)
1143 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1145 fprintf(vstats_file,"f_size= %6d ", frame_size);
1146 /* compute pts value */
1147 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1151 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1152 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1153 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1154 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1155 fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1159 static void print_report(AVFormatContext **output_files,
1160 AVOutputStream **ost_table, int nb_ostreams,
1164 AVOutputStream *ost;
1165 AVFormatContext *oc;
1167 AVCodecContext *enc;
1168 int frame_number, vid, i;
1169 double bitrate, ti1, pts;
1170 static int64_t last_time = -1;
1171 static int qp_histogram[52];
1173 if (!is_last_report) {
1175 /* display the report every 0.5 seconds */
1176 cur_time = av_gettime();
1177 if (last_time == -1) {
1178 last_time = cur_time;
1181 if ((cur_time - last_time) < 500000)
1183 last_time = cur_time;
1187 oc = output_files[0];
1189 total_size = url_fsize(oc->pb);
1190 if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1191 total_size= url_ftell(oc->pb);
1196 for(i=0;i<nb_ostreams;i++) {
1198 enc = ost->st->codec;
1199 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1200 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1201 !ost->st->stream_copy ?
1202 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1204 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1205 float t = (av_gettime()-timer_start) / 1000000.0;
1207 frame_number = ost->frame_number;
1208 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1209 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1210 !ost->st->stream_copy ?
1211 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1213 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1216 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1217 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1220 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1222 if (enc->flags&CODEC_FLAG_PSNR){
1224 double error, error_sum=0;
1225 double scale, scale_sum=0;
1226 char type[3]= {'Y','U','V'};
1227 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1230 error= enc->error[j];
1231 scale= enc->width*enc->height*255.0*255.0*frame_number;
1233 error= enc->coded_frame->error[j];
1234 scale= enc->width*enc->height*255.0*255.0;
1239 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1241 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1245 /* compute min output value */
1246 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1247 if ((pts < ti1) && (pts > 0))
1253 if (verbose || is_last_report) {
1254 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1256 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1257 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1258 (double)total_size / 1024, ti1, bitrate);
1260 if (nb_frames_dup || nb_frames_drop)
1261 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1262 nb_frames_dup, nb_frames_drop);
1265 fprintf(stderr, "%s \r", buf);
1270 if (is_last_report && verbose >= 0){
1271 int64_t raw= audio_size + video_size + extra_size;
1272 fprintf(stderr, "\n");
1273 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1277 100.0*(total_size - raw)/raw
1282 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1283 static int output_packet(AVInputStream *ist, int ist_index,
1284 AVOutputStream **ost_table, int nb_ostreams,
1285 const AVPacket *pkt)
1287 AVFormatContext *os;
1288 AVOutputStream *ost;
1292 void *buffer_to_free;
1293 static unsigned int samples_size= 0;
1294 AVSubtitle subtitle, *subtitle_to_free;
1297 int bps = av_get_bits_per_sample_format(ist->st->codec->sample_fmt)>>3;
1299 if(ist->next_pts == AV_NOPTS_VALUE)
1300 ist->next_pts= ist->pts;
1304 av_init_packet(&avpkt);
1312 if(pkt->dts != AV_NOPTS_VALUE)
1313 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1315 //while we have more to decode or while the decoder did output something on EOF
1316 while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1317 uint8_t *data_buf, *decoded_data_buf;
1318 int data_size, decoded_data_size;
1320 ist->pts= ist->next_pts;
1322 if(avpkt.size && avpkt.size != pkt->size &&
1323 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1324 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1325 ist->showed_multi_packet_warning=1;
1328 /* decode the packet if needed */
1329 decoded_data_buf = NULL; /* fail safe */
1330 decoded_data_size= 0;
1331 data_buf = avpkt.data;
1332 data_size = avpkt.size;
1333 subtitle_to_free = NULL;
1334 if (ist->decoding_needed) {
1335 switch(ist->st->codec->codec_type) {
1336 case CODEC_TYPE_AUDIO:{
1337 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1338 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1340 samples= av_malloc(samples_size);
1342 decoded_data_size= samples_size;
1343 /* XXX: could avoid copy if PCM 16 bits with same
1344 endianness as CPU */
1345 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1352 /* Some bug in mpeg audio decoder gives */
1353 /* decoded_data_size < 0, it seems they are overflows */
1354 if (decoded_data_size <= 0) {
1355 /* no audio frame */
1358 decoded_data_buf = (uint8_t *)samples;
1359 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1360 (ist->st->codec->sample_rate * ist->st->codec->channels);
1362 case CODEC_TYPE_VIDEO:
1363 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1364 /* XXX: allocate picture correctly */
1365 avcodec_get_frame_defaults(&picture);
1367 ret = avcodec_decode_video2(ist->st->codec,
1368 &picture, &got_picture, &avpkt);
1369 ist->st->quality= picture.quality;
1373 /* no picture yet */
1374 goto discard_packet;
1376 if (ist->st->codec->time_base.num != 0) {
1377 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1378 ist->next_pts += ((int64_t)AV_TIME_BASE *
1379 ist->st->codec->time_base.num * ticks) /
1380 ist->st->codec->time_base.den;
1384 case CODEC_TYPE_SUBTITLE:
1385 ret = avcodec_decode_subtitle2(ist->st->codec,
1386 &subtitle, &got_subtitle, &avpkt);
1389 if (!got_subtitle) {
1390 goto discard_packet;
1392 subtitle_to_free = &subtitle;
1399 switch(ist->st->codec->codec_type) {
1400 case CODEC_TYPE_AUDIO:
1401 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1402 ist->st->codec->sample_rate;
1404 case CODEC_TYPE_VIDEO:
1405 if (ist->st->codec->time_base.num != 0) {
1406 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1407 ist->next_pts += ((int64_t)AV_TIME_BASE *
1408 ist->st->codec->time_base.num * ticks) /
1409 ist->st->codec->time_base.den;
1417 buffer_to_free = NULL;
1418 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1419 pre_process_video_frame(ist, (AVPicture *)&picture,
1423 // preprocess audio (volume)
1424 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1425 if (audio_volume != 256) {
1428 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1429 int v = ((*volp) * audio_volume + 128) >> 8;
1430 if (v < -32768) v = -32768;
1431 if (v > 32767) v = 32767;
1437 /* frame rate emulation */
1439 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1440 int64_t now = av_gettime() - ist->start;
1445 /* if output time reached then transcode raw format,
1446 encode packets and output them */
1447 if (start_time == 0 || ist->pts >= start_time)
1448 for(i=0;i<nb_ostreams;i++) {
1452 if (ost->source_index == ist_index) {
1453 os = output_files[ost->file_index];
1455 /* set the input output pts pairs */
1456 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1458 if (ost->encoding_needed) {
1459 assert(ist->decoding_needed);
1460 switch(ost->st->codec->codec_type) {
1461 case CODEC_TYPE_AUDIO:
1462 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1464 case CODEC_TYPE_VIDEO:
1465 do_video_out(os, ost, ist, &picture, &frame_size);
1466 if (vstats_filename && frame_size)
1467 do_video_stats(os, ost, frame_size);
1469 case CODEC_TYPE_SUBTITLE:
1470 do_subtitle_out(os, ost, ist, &subtitle,
1477 AVFrame avframe; //FIXME/XXX remove this
1479 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1481 av_init_packet(&opkt);
1483 if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1486 /* no reencoding needed : output the packet directly */
1487 /* force the input stream PTS */
1489 avcodec_get_frame_defaults(&avframe);
1490 ost->st->codec->coded_frame= &avframe;
1491 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1493 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1494 audio_size += data_size;
1495 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1496 video_size += data_size;
1500 opkt.stream_index= ost->index;
1501 if(pkt->pts != AV_NOPTS_VALUE)
1502 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1504 opkt.pts= AV_NOPTS_VALUE;
1506 if (pkt->dts == AV_NOPTS_VALUE)
1507 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1509 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1510 opkt.dts -= ost_tb_start_time;
1512 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1513 opkt.flags= pkt->flags;
1515 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1516 if( ost->st->codec->codec_id != CODEC_ID_H264
1517 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1518 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1520 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1521 opkt.destruct= av_destruct_packet;
1523 opkt.data = data_buf;
1524 opkt.size = data_size;
1527 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1528 ost->st->codec->frame_number++;
1529 ost->frame_number++;
1530 av_free_packet(&opkt);
1534 av_free(buffer_to_free);
1535 /* XXX: allocate the subtitles in the codec ? */
1536 if (subtitle_to_free) {
1537 if (subtitle_to_free->rects != NULL) {
1538 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1539 av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1540 av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1541 av_freep(&subtitle_to_free->rects[i]);
1543 av_freep(&subtitle_to_free->rects);
1545 subtitle_to_free->num_rects = 0;
1546 subtitle_to_free = NULL;
1553 for(i=0;i<nb_ostreams;i++) {
1555 if (ost->source_index == ist_index) {
1556 AVCodecContext *enc= ost->st->codec;
1557 os = output_files[ost->file_index];
1559 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1561 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1564 if (ost->encoding_needed) {
1568 av_init_packet(&pkt);
1569 pkt.stream_index= ost->index;
1571 switch(ost->st->codec->codec_type) {
1572 case CODEC_TYPE_AUDIO:
1573 fifo_bytes = av_fifo_size(ost->fifo);
1575 /* encode any samples remaining in fifo */
1576 if (fifo_bytes > 0) {
1577 int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
1578 int fs_tmp = enc->frame_size;
1580 av_fifo_generic_read(ost->fifo, samples, fifo_bytes, NULL);
1581 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1582 enc->frame_size = fifo_bytes / (osize * enc->channels);
1584 int frame_bytes = enc->frame_size*osize*enc->channels;
1585 if (samples_size < frame_bytes)
1587 memset((uint8_t*)samples+fifo_bytes, 0, frame_bytes - fifo_bytes);
1590 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1591 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1592 ost->st->time_base.num, enc->sample_rate);
1593 enc->frame_size = fs_tmp;
1596 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1599 fprintf(stderr, "Audio encoding failed\n");
1603 pkt.flags |= PKT_FLAG_KEY;
1605 case CODEC_TYPE_VIDEO:
1606 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1608 fprintf(stderr, "Video encoding failed\n");
1612 if(enc->coded_frame && enc->coded_frame->key_frame)
1613 pkt.flags |= PKT_FLAG_KEY;
1614 if (ost->logfile && enc->stats_out) {
1615 fprintf(ost->logfile, "%s", enc->stats_out);
1624 pkt.data= bit_buffer;
1626 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1627 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1628 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1640 static void print_sdp(AVFormatContext **avc, int n)
1644 avf_sdp_create(avc, n, sdp, sizeof(sdp));
1645 printf("SDP:\n%s\n", sdp);
1649 static int stream_index_from_inputs(AVFormatContext **input_files,
1651 AVInputFile *file_table,
1652 AVInputStream **ist_table,
1653 enum CodecType type,
1657 for(z=0; z<nb_input_files; z++) {
1658 AVFormatContext *ic = input_files[z];
1659 for(p=0; p<ic->nb_programs; p++) {
1660 AVProgram *program = ic->programs[p];
1661 if(program->id != programid)
1663 for(q=0; q<program->nb_stream_indexes; q++) {
1664 int sidx = program->stream_index[q];
1665 int ris = file_table[z].ist_index + sidx;
1666 if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1676 * The following code is the main loop of the file converter
1678 static int av_encode(AVFormatContext **output_files,
1679 int nb_output_files,
1680 AVFormatContext **input_files,
1682 AVStreamMap *stream_maps, int nb_stream_maps)
1684 int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1685 AVFormatContext *is, *os;
1686 AVCodecContext *codec, *icodec;
1687 AVOutputStream *ost, **ost_table = NULL;
1688 AVInputStream *ist, **ist_table = NULL;
1689 AVInputFile *file_table;
1693 uint8_t no_packet[MAX_FILES]={0};
1694 int no_packet_count=0;
1696 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1700 /* input stream init */
1702 for(i=0;i<nb_input_files;i++) {
1703 is = input_files[i];
1704 file_table[i].ist_index = j;
1705 file_table[i].nb_streams = is->nb_streams;
1706 j += is->nb_streams;
1710 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1714 for(i=0;i<nb_istreams;i++) {
1715 ist = av_mallocz(sizeof(AVInputStream));
1721 for(i=0;i<nb_input_files;i++) {
1722 is = input_files[i];
1723 for(k=0;k<is->nb_streams;k++) {
1724 ist = ist_table[j++];
1725 ist->st = is->streams[k];
1726 ist->file_index = i;
1728 ist->discard = 1; /* the stream is discarded by default
1732 ist->start = av_gettime();
1737 /* output stream init */
1739 for(i=0;i<nb_output_files;i++) {
1740 os = output_files[i];
1741 if (!os->nb_streams) {
1742 dump_format(output_files[i], i, output_files[i]->filename, 1);
1743 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1746 nb_ostreams += os->nb_streams;
1748 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1749 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1753 /* Sanity check the mapping args -- do the input files & streams exist? */
1754 for(i=0;i<nb_stream_maps;i++) {
1755 int fi = stream_maps[i].file_index;
1756 int si = stream_maps[i].stream_index;
1758 if (fi < 0 || fi > nb_input_files - 1 ||
1759 si < 0 || si > file_table[fi].nb_streams - 1) {
1760 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1763 fi = stream_maps[i].sync_file_index;
1764 si = stream_maps[i].sync_stream_index;
1765 if (fi < 0 || fi > nb_input_files - 1 ||
1766 si < 0 || si > file_table[fi].nb_streams - 1) {
1767 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1772 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1775 for(i=0;i<nb_ostreams;i++) {
1776 ost = av_mallocz(sizeof(AVOutputStream));
1783 for(k=0;k<nb_output_files;k++) {
1784 os = output_files[k];
1785 for(i=0;i<os->nb_streams;i++,n++) {
1788 ost->file_index = k;
1790 ost->st = os->streams[i];
1791 if (nb_stream_maps > 0) {
1792 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1793 stream_maps[n].stream_index;
1795 /* Sanity check that the stream types match */
1796 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1797 int i= ost->file_index;
1798 dump_format(output_files[i], i, output_files[i]->filename, 1);
1799 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1800 stream_maps[n].file_index, stream_maps[n].stream_index,
1801 ost->file_index, ost->index);
1808 j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1810 ost->source_index = j;
1814 /* get corresponding input stream index : we select the first one with the right type */
1816 for(j=0;j<nb_istreams;j++) {
1819 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1820 ost->source_index = j;
1828 if(! opt_programid) {
1829 /* try again and reuse existing stream */
1830 for(j=0;j<nb_istreams;j++) {
1832 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1833 ost->source_index = j;
1839 int i= ost->file_index;
1840 dump_format(output_files[i], i, output_files[i]->filename, 1);
1841 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1842 ost->file_index, ost->index);
1847 ist = ist_table[ost->source_index];
1849 ost->sync_ist = (nb_stream_maps > 0) ?
1850 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
1851 stream_maps[n].sync_stream_index] : ist;
1855 /* for each output stream, we compute the right encoding parameters */
1856 for(i=0;i<nb_ostreams;i++) {
1857 AVMetadataTag *lang;
1859 os = output_files[ost->file_index];
1860 ist = ist_table[ost->source_index];
1862 codec = ost->st->codec;
1863 icodec = ist->st->codec;
1865 if ((lang=av_metadata_get(ist->st->metadata, "language", NULL, 0))
1866 && !av_metadata_get(ost->st->metadata, "language", NULL, 0))
1867 av_metadata_set(&ost->st->metadata, "language", lang->value);
1869 ost->st->disposition = ist->st->disposition;
1870 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1871 codec->chroma_sample_location = icodec->chroma_sample_location;
1873 if (ost->st->stream_copy) {
1874 /* if stream_copy is selected, no need to decode or encode */
1875 codec->codec_id = icodec->codec_id;
1876 codec->codec_type = icodec->codec_type;
1878 if(!codec->codec_tag){
1879 if( !os->oformat->codec_tag
1880 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
1881 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1882 codec->codec_tag = icodec->codec_tag;
1885 codec->bit_rate = icodec->bit_rate;
1886 codec->extradata= icodec->extradata;
1887 codec->extradata_size= icodec->extradata_size;
1888 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){
1889 codec->time_base = icodec->time_base;
1890 codec->time_base.num *= icodec->ticks_per_frame;
1892 codec->time_base = ist->st->time_base;
1893 switch(codec->codec_type) {
1894 case CODEC_TYPE_AUDIO:
1895 if(audio_volume != 256) {
1896 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1899 codec->channel_layout = icodec->channel_layout;
1900 codec->sample_rate = icodec->sample_rate;
1901 codec->channels = icodec->channels;
1902 codec->frame_size = icodec->frame_size;
1903 codec->block_align= icodec->block_align;
1904 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1905 codec->block_align= 0;
1906 if(codec->codec_id == CODEC_ID_AC3)
1907 codec->block_align= 0;
1909 case CODEC_TYPE_VIDEO:
1910 codec->pix_fmt = icodec->pix_fmt;
1911 codec->width = icodec->width;
1912 codec->height = icodec->height;
1913 codec->has_b_frames = icodec->has_b_frames;
1915 case CODEC_TYPE_SUBTITLE:
1916 codec->width = icodec->width;
1917 codec->height = icodec->height;
1923 switch(codec->codec_type) {
1924 case CODEC_TYPE_AUDIO:
1925 ost->fifo= av_fifo_alloc(1024);
1928 ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
1929 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1930 icodec->request_channels = codec->channels;
1931 ist->decoding_needed = 1;
1932 ost->encoding_needed = 1;
1934 case CODEC_TYPE_VIDEO:
1935 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
1936 fprintf(stderr, "Video pixel format is unknown, stream cannot be decoded\n");
1939 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1940 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1941 ost->video_resample = ((codec->width != icodec->width -
1942 (frame_leftBand + frame_rightBand) +
1943 (frame_padleft + frame_padright)) ||
1944 (codec->height != icodec->height -
1945 (frame_topBand + frame_bottomBand) +
1946 (frame_padtop + frame_padbottom)) ||
1947 (codec->pix_fmt != icodec->pix_fmt));
1948 if (ost->video_crop) {
1949 ost->topBand = ost->original_topBand = frame_topBand;
1950 ost->bottomBand = ost->original_bottomBand = frame_bottomBand;
1951 ost->leftBand = ost->original_leftBand = frame_leftBand;
1952 ost->rightBand = ost->original_rightBand = frame_rightBand;
1954 if (ost->video_pad) {
1955 ost->padtop = frame_padtop;
1956 ost->padleft = frame_padleft;
1957 ost->padbottom = frame_padbottom;
1958 ost->padright = frame_padright;
1959 if (!ost->video_resample) {
1960 avcodec_get_frame_defaults(&ost->pict_tmp);
1961 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1962 codec->width, codec->height))
1966 if (ost->video_resample) {
1967 avcodec_get_frame_defaults(&ost->pict_tmp);
1968 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1969 codec->width, codec->height)) {
1970 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1973 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1974 ost->img_resample_ctx = sws_getContext(
1975 icodec->width - (frame_leftBand + frame_rightBand),
1976 icodec->height - (frame_topBand + frame_bottomBand),
1978 codec->width - (frame_padleft + frame_padright),
1979 codec->height - (frame_padtop + frame_padbottom),
1981 sws_flags, NULL, NULL, NULL);
1982 if (ost->img_resample_ctx == NULL) {
1983 fprintf(stderr, "Cannot get resampling context\n");
1987 ost->original_height = icodec->height;
1988 ost->original_width = icodec->width;
1990 codec->bits_per_raw_sample= 0;
1992 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1993 ost->resample_width = icodec->width - (frame_leftBand + frame_rightBand);
1994 ost->resample_pix_fmt= icodec->pix_fmt;
1995 ost->encoding_needed = 1;
1996 ist->decoding_needed = 1;
1998 case CODEC_TYPE_SUBTITLE:
1999 ost->encoding_needed = 1;
2000 ist->decoding_needed = 1;
2007 if (ost->encoding_needed &&
2008 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2009 char logfilename[1024];
2014 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2015 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2017 if (codec->flags & CODEC_FLAG_PASS1) {
2018 f = fopen(logfilename, "w");
2020 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2025 /* read the log file */
2026 f = fopen(logfilename, "r");
2028 fprintf(stderr, "Cannot read log file '%s' for pass-2 encoding: %s\n", logfilename, strerror(errno));
2031 fseek(f, 0, SEEK_END);
2033 fseek(f, 0, SEEK_SET);
2034 logbuffer = av_malloc(size + 1);
2036 fprintf(stderr, "Could not allocate log buffer\n");
2039 size = fread(logbuffer, 1, size, f);
2041 logbuffer[size] = '\0';
2042 codec->stats_in = logbuffer;
2046 if(codec->codec_type == CODEC_TYPE_VIDEO){
2047 int size= codec->width * codec->height;
2048 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2053 bit_buffer = av_malloc(bit_buffer_size);
2055 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2057 ret = AVERROR(ENOMEM);
2061 /* open each encoder */
2062 for(i=0;i<nb_ostreams;i++) {
2064 if (ost->encoding_needed) {
2065 AVCodec *codec = output_codecs[i];
2067 codec = avcodec_find_encoder(ost->st->codec->codec_id);
2069 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2070 ost->st->codec->codec_id, ost->file_index, ost->index);
2071 ret = AVERROR(EINVAL);
2074 if (avcodec_open(ost->st->codec, codec) < 0) {
2075 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2076 ost->file_index, ost->index);
2077 ret = AVERROR(EINVAL);
2080 extra_size += ost->st->codec->extradata_size;
2084 /* open each decoder */
2085 for(i=0;i<nb_istreams;i++) {
2087 if (ist->decoding_needed) {
2088 AVCodec *codec = input_codecs[i];
2090 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2092 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2093 ist->st->codec->codec_id, ist->file_index, ist->index);
2094 ret = AVERROR(EINVAL);
2097 if (avcodec_open(ist->st->codec, codec) < 0) {
2098 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2099 ist->file_index, ist->index);
2100 ret = AVERROR(EINVAL);
2103 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
2104 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2109 for(i=0;i<nb_istreams;i++) {
2112 ist->next_pts = AV_NOPTS_VALUE;
2116 /* set meta data information from input file if required */
2117 for (i=0;i<nb_meta_data_maps;i++) {
2118 AVFormatContext *out_file;
2119 AVFormatContext *in_file;
2120 AVMetadataTag *mtag;
2122 int out_file_index = meta_data_maps[i].out_file;
2123 int in_file_index = meta_data_maps[i].in_file;
2124 if (out_file_index < 0 || out_file_index >= nb_output_files) {
2125 snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
2126 out_file_index, out_file_index, in_file_index);
2127 ret = AVERROR(EINVAL);
2130 if (in_file_index < 0 || in_file_index >= nb_input_files) {
2131 snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
2132 in_file_index, out_file_index, in_file_index);
2133 ret = AVERROR(EINVAL);
2137 out_file = output_files[out_file_index];
2138 in_file = input_files[in_file_index];
2142 while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2143 av_metadata_set(&out_file->metadata, mtag->key, mtag->value);
2144 av_metadata_conv(out_file, out_file->oformat->metadata_conv,
2145 in_file->iformat->metadata_conv);
2148 /* open files and write file headers */
2149 for(i=0;i<nb_output_files;i++) {
2150 os = output_files[i];
2151 if (av_write_header(os) < 0) {
2152 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2153 ret = AVERROR(EINVAL);
2156 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2162 /* dump the file output parameters - cannot be done before in case
2164 for(i=0;i<nb_output_files;i++) {
2165 dump_format(output_files[i], i, output_files[i]->filename, 1);
2168 /* dump the stream mapping */
2170 fprintf(stderr, "Stream mapping:\n");
2171 for(i=0;i<nb_ostreams;i++) {
2173 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2174 ist_table[ost->source_index]->file_index,
2175 ist_table[ost->source_index]->index,
2178 if (ost->sync_ist != ist_table[ost->source_index])
2179 fprintf(stderr, " [sync #%d.%d]",
2180 ost->sync_ist->file_index,
2181 ost->sync_ist->index);
2182 fprintf(stderr, "\n");
2187 fprintf(stderr, "%s\n", error);
2192 print_sdp(output_files, nb_output_files);
2195 if (!using_stdin && verbose >= 0) {
2196 fprintf(stderr, "Press [q] to stop encoding\n");
2197 url_set_interrupt_cb(decode_interrupt_cb);
2201 timer_start = av_gettime();
2203 for(; received_sigterm == 0;) {
2204 int file_index, ist_index;
2212 /* if 'q' pressed, exits */
2216 /* read_key() returns 0 on EOF */
2222 /* select the stream that we must read now by looking at the
2223 smallest output pts */
2225 for(i=0;i<nb_ostreams;i++) {
2228 os = output_files[ost->file_index];
2229 ist = ist_table[ost->source_index];
2230 if(ist->is_past_recording_time || no_packet[ist->file_index])
2232 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2233 ipts = (double)ist->pts;
2234 if (!file_table[ist->file_index].eof_reached){
2235 if(ipts < ipts_min) {
2237 if(input_sync ) file_index = ist->file_index;
2239 if(opts < opts_min) {
2241 if(!input_sync) file_index = ist->file_index;
2244 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2249 /* if none, if is finished */
2250 if (file_index < 0) {
2251 if(no_packet_count){
2253 memset(no_packet, 0, sizeof(no_packet));
2260 /* finish if limit size exhausted */
2261 if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2264 /* read a frame from it and output it in the fifo */
2265 is = input_files[file_index];
2266 ret= av_read_frame(is, &pkt);
2267 if(ret == AVERROR(EAGAIN)){
2268 no_packet[file_index]=1;
2273 file_table[file_index].eof_reached = 1;
2281 memset(no_packet, 0, sizeof(no_packet));
2284 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2286 /* the following test is needed in case new streams appear
2287 dynamically in stream : we ignore them */
2288 if (pkt.stream_index >= file_table[file_index].nb_streams)
2289 goto discard_packet;
2290 ist_index = file_table[file_index].ist_index + pkt.stream_index;
2291 ist = ist_table[ist_index];
2293 goto discard_packet;
2295 if (pkt.dts != AV_NOPTS_VALUE)
2296 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2297 if (pkt.pts != AV_NOPTS_VALUE)
2298 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2300 if(input_files_ts_scale[file_index][pkt.stream_index]){
2301 if(pkt.pts != AV_NOPTS_VALUE)
2302 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2303 if(pkt.dts != AV_NOPTS_VALUE)
2304 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2307 // 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);
2308 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2309 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2310 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2311 int64_t delta= pkt_dts - ist->next_pts;
2312 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2313 input_files_ts_offset[ist->file_index]-= delta;
2315 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2316 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2317 if(pkt.pts != AV_NOPTS_VALUE)
2318 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2322 /* finish if recording time exhausted */
2323 if (av_compare_ts(pkt.pts, ist->st->time_base, recording_time, (AVRational){1, 1000000}) >= 0) {
2324 ist->is_past_recording_time = 1;
2325 goto discard_packet;
2328 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2329 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2332 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2333 ist->file_index, ist->index);
2336 av_free_packet(&pkt);
2341 av_free_packet(&pkt);
2343 /* dump report by using the output first video and audio streams */
2344 print_report(output_files, ost_table, nb_ostreams, 0);
2347 /* at the end of stream, we must flush the decoder buffers */
2348 for(i=0;i<nb_istreams;i++) {
2350 if (ist->decoding_needed) {
2351 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2357 /* write the trailer if needed and close file */
2358 for(i=0;i<nb_output_files;i++) {
2359 os = output_files[i];
2360 av_write_trailer(os);
2363 /* dump report by using the first video and audio streams */
2364 print_report(output_files, ost_table, nb_ostreams, 1);
2366 /* close each encoder */
2367 for(i=0;i<nb_ostreams;i++) {
2369 if (ost->encoding_needed) {
2370 av_freep(&ost->st->codec->stats_in);
2371 avcodec_close(ost->st->codec);
2375 /* close each decoder */
2376 for(i=0;i<nb_istreams;i++) {
2378 if (ist->decoding_needed) {
2379 avcodec_close(ist->st->codec);
2387 av_freep(&bit_buffer);
2388 av_free(file_table);
2391 for(i=0;i<nb_istreams;i++) {
2398 for(i=0;i<nb_ostreams;i++) {
2402 fclose(ost->logfile);
2403 ost->logfile = NULL;
2405 av_fifo_free(ost->fifo); /* works even if fifo is not
2406 initialized but set to zero */
2407 av_free(ost->pict_tmp.data[0]);
2408 if (ost->video_resample)
2409 sws_freeContext(ost->img_resample_ctx);
2411 audio_resample_close(ost->resample);
2412 if (ost->reformat_ctx)
2413 av_audio_convert_free(ost->reformat_ctx);
2422 static void opt_format(const char *arg)
2424 /* compatibility stuff for pgmyuv */
2425 if (!strcmp(arg, "pgmyuv")) {
2426 pgmyuv_compatibility_hack=1;
2427 // opt_image_format(arg);
2429 fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2432 last_asked_format = arg;
2435 static void opt_video_rc_override_string(const char *arg)
2437 video_rc_override_string = arg;
2440 static int opt_me_threshold(const char *opt, const char *arg)
2442 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2446 static int opt_verbose(const char *opt, const char *arg)
2448 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2452 static int opt_frame_rate(const char *opt, const char *arg)
2454 if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2455 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2461 static int opt_bitrate(const char *opt, const char *arg)
2463 int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2465 opt_default(opt, arg);
2467 if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2468 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2473 static void opt_frame_crop_top(const char *arg)
2475 frame_topBand = atoi(arg);
2476 if (frame_topBand < 0) {
2477 fprintf(stderr, "Incorrect top crop size\n");
2480 if ((frame_topBand) >= frame_height){
2481 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2484 frame_height -= frame_topBand;
2487 static void opt_frame_crop_bottom(const char *arg)
2489 frame_bottomBand = atoi(arg);
2490 if (frame_bottomBand < 0) {
2491 fprintf(stderr, "Incorrect bottom crop size\n");
2494 if ((frame_bottomBand) >= frame_height){
2495 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2498 frame_height -= frame_bottomBand;
2501 static void opt_frame_crop_left(const char *arg)
2503 frame_leftBand = atoi(arg);
2504 if (frame_leftBand < 0) {
2505 fprintf(stderr, "Incorrect left crop size\n");
2508 if ((frame_leftBand) >= frame_width){
2509 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2512 frame_width -= frame_leftBand;
2515 static void opt_frame_crop_right(const char *arg)
2517 frame_rightBand = atoi(arg);
2518 if (frame_rightBand < 0) {
2519 fprintf(stderr, "Incorrect right crop size\n");
2522 if ((frame_rightBand) >= frame_width){
2523 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2526 frame_width -= frame_rightBand;
2529 static void opt_frame_size(const char *arg)
2531 if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2532 fprintf(stderr, "Incorrect frame size\n");
2537 static void opt_pad_color(const char *arg) {
2538 /* Input is expected to be six hex digits similar to
2539 how colors are expressed in html tags (but without the #) */
2540 int rgb = strtol(arg, NULL, 16);
2544 g = ((rgb >> 8) & 255);
2547 padcolor[0] = RGB_TO_Y(r,g,b);
2548 padcolor[1] = RGB_TO_U(r,g,b,0);
2549 padcolor[2] = RGB_TO_V(r,g,b,0);
2552 static void opt_frame_pad_top(const char *arg)
2554 frame_padtop = atoi(arg);
2555 if (frame_padtop < 0) {
2556 fprintf(stderr, "Incorrect top pad size\n");
2561 static void opt_frame_pad_bottom(const char *arg)
2563 frame_padbottom = atoi(arg);
2564 if (frame_padbottom < 0) {
2565 fprintf(stderr, "Incorrect bottom pad size\n");
2571 static void opt_frame_pad_left(const char *arg)
2573 frame_padleft = atoi(arg);
2574 if (frame_padleft < 0) {
2575 fprintf(stderr, "Incorrect left pad size\n");
2581 static void opt_frame_pad_right(const char *arg)
2583 frame_padright = atoi(arg);
2584 if (frame_padright < 0) {
2585 fprintf(stderr, "Incorrect right pad size\n");
2590 static void opt_frame_pix_fmt(const char *arg)
2592 if (strcmp(arg, "list")) {
2593 frame_pix_fmt = av_get_pix_fmt(arg);
2594 if (frame_pix_fmt == PIX_FMT_NONE) {
2595 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2604 static void opt_frame_aspect_ratio(const char *arg)
2611 p = strchr(arg, ':');
2613 x = strtol(arg, &end, 10);
2615 y = strtol(end+1, &end, 10);
2617 ar = (double)x / (double)y;
2619 ar = strtod(arg, NULL);
2622 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2625 frame_aspect_ratio = ar;
2628 static int opt_metadata(const char *opt, const char *arg)
2630 char *mid= strchr(arg, '=');
2633 fprintf(stderr, "Missing =\n");
2639 metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2640 metadata[metadata_count-1].key = av_strdup(arg);
2641 metadata[metadata_count-1].value= av_strdup(mid);
2646 static void opt_qscale(const char *arg)
2648 video_qscale = atof(arg);
2649 if (video_qscale <= 0 ||
2650 video_qscale > 255) {
2651 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2656 static void opt_top_field_first(const char *arg)
2658 top_field_first= atoi(arg);
2661 static int opt_thread_count(const char *opt, const char *arg)
2663 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2666 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2671 static void opt_audio_sample_fmt(const char *arg)
2673 if (strcmp(arg, "list"))
2674 audio_sample_fmt = avcodec_get_sample_fmt(arg);
2676 list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2681 static int opt_audio_rate(const char *opt, const char *arg)
2683 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2687 static int opt_audio_channels(const char *opt, const char *arg)
2689 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2693 static void opt_video_channel(const char *arg)
2695 video_channel = strtol(arg, NULL, 0);
2698 static void opt_video_standard(const char *arg)
2700 video_standard = av_strdup(arg);
2703 static void opt_codec(int *pstream_copy, char **pcodec_name,
2704 int codec_type, const char *arg)
2706 av_freep(pcodec_name);
2707 if (!strcmp(arg, "copy")) {
2710 *pcodec_name = av_strdup(arg);
2714 static void opt_audio_codec(const char *arg)
2716 opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2719 static void opt_audio_tag(const char *arg)
2722 audio_codec_tag= strtol(arg, &tail, 0);
2725 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2728 static void opt_video_tag(const char *arg)
2731 video_codec_tag= strtol(arg, &tail, 0);
2734 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2737 static void opt_video_codec(const char *arg)
2739 opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2742 static void opt_subtitle_codec(const char *arg)
2744 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2747 static void opt_subtitle_tag(const char *arg)
2750 subtitle_codec_tag= strtol(arg, &tail, 0);
2753 subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2756 static void opt_map(const char *arg)
2761 m = &stream_maps[nb_stream_maps++];
2763 m->file_index = strtol(arg, &p, 0);
2767 m->stream_index = strtol(p, &p, 0);
2770 m->sync_file_index = strtol(p, &p, 0);
2773 m->sync_stream_index = strtol(p, &p, 0);
2775 m->sync_file_index = m->file_index;
2776 m->sync_stream_index = m->stream_index;
2780 static void opt_map_meta_data(const char *arg)
2785 m = &meta_data_maps[nb_meta_data_maps++];
2787 m->out_file = strtol(arg, &p, 0);
2791 m->in_file = strtol(p, &p, 0);
2794 static void opt_input_ts_scale(const char *arg)
2796 unsigned int stream;
2800 stream = strtol(arg, &p, 0);
2803 scale= strtod(p, &p);
2805 if(stream >= MAX_STREAMS)
2808 input_files_ts_scale[nb_input_files][stream]= scale;
2811 static int opt_recording_time(const char *opt, const char *arg)
2813 recording_time = parse_time_or_die(opt, arg, 1);
2817 static int opt_start_time(const char *opt, const char *arg)
2819 start_time = parse_time_or_die(opt, arg, 1);
2823 static int opt_rec_timestamp(const char *opt, const char *arg)
2825 rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2829 static int opt_input_ts_offset(const char *opt, const char *arg)
2831 input_ts_offset = parse_time_or_die(opt, arg, 1);
2835 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2837 const char *codec_string = encoder ? "encoder" : "decoder";
2841 return CODEC_ID_NONE;
2843 avcodec_find_encoder_by_name(name) :
2844 avcodec_find_decoder_by_name(name);
2846 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2849 if(codec->type != type) {
2850 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2856 static void opt_input_file(const char *filename)
2858 AVFormatContext *ic;
2859 AVFormatParameters params, *ap = ¶ms;
2860 AVInputFormat *file_iformat = NULL;
2861 int err, i, ret, rfps, rfps_base;
2864 if (last_asked_format) {
2865 file_iformat = av_find_input_format(last_asked_format);
2866 last_asked_format = NULL;
2869 if (!strcmp(filename, "-"))
2872 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2873 !strcmp(filename, "/dev/stdin");
2875 /* get default parameters from command line */
2876 ic = avformat_alloc_context();
2878 print_error(filename, AVERROR(ENOMEM));
2882 memset(ap, 0, sizeof(*ap));
2883 ap->prealloced_context = 1;
2884 ap->sample_rate = audio_sample_rate;
2885 ap->channels = audio_channels;
2886 ap->time_base.den = frame_rate.num;
2887 ap->time_base.num = frame_rate.den;
2888 ap->width = frame_width + frame_padleft + frame_padright;
2889 ap->height = frame_height + frame_padtop + frame_padbottom;
2890 ap->pix_fmt = frame_pix_fmt;
2891 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2892 ap->channel = video_channel;
2893 ap->standard = video_standard;
2895 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2897 ic->video_codec_id = find_codec_or_die(video_codec_name , CODEC_TYPE_VIDEO , 0);
2898 ic->audio_codec_id = find_codec_or_die(audio_codec_name , CODEC_TYPE_AUDIO , 0);
2899 ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2900 ic->flags |= AVFMT_FLAG_NONBLOCK;
2902 if(pgmyuv_compatibility_hack)
2903 ic->video_codec_id= CODEC_ID_PGMYUV;
2905 /* open the input file with generic libav function */
2906 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2908 print_error(filename, err);
2913 for(i=0; i<ic->nb_programs; i++)
2914 if(ic->programs[i]->id != opt_programid)
2915 ic->programs[i]->discard = AVDISCARD_ALL;
2918 ic->loop_input = loop_input;
2920 /* If not enough info to get the stream parameters, we decode the
2921 first frames to get it. (used in mpeg case for example) */
2922 ret = av_find_stream_info(ic);
2923 if (ret < 0 && verbose >= 0) {
2924 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2928 timestamp = start_time;
2929 /* add the stream start time */
2930 if (ic->start_time != AV_NOPTS_VALUE)
2931 timestamp += ic->start_time;
2933 /* if seeking requested, we execute it */
2934 if (start_time != 0) {
2935 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2937 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2938 filename, (double)timestamp / AV_TIME_BASE);
2940 /* reset seek info */
2944 /* update the current parameters so that they match the one of the input stream */
2945 for(i=0;i<ic->nb_streams;i++) {
2946 AVStream *st = ic->streams[i];
2947 AVCodecContext *enc = st->codec;
2948 avcodec_thread_init(enc, thread_count);
2949 switch(enc->codec_type) {
2950 case CODEC_TYPE_AUDIO:
2951 set_context_opts(enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2952 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2953 channel_layout = enc->channel_layout;
2954 audio_channels = enc->channels;
2955 audio_sample_rate = enc->sample_rate;
2956 audio_sample_fmt = enc->sample_fmt;
2957 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
2959 st->discard= AVDISCARD_ALL;
2961 case CODEC_TYPE_VIDEO:
2962 set_context_opts(enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2963 frame_height = enc->height;
2964 frame_width = enc->width;
2965 if(ic->streams[i]->sample_aspect_ratio.num)
2966 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
2968 frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
2969 frame_aspect_ratio *= (float) enc->width / enc->height;
2970 frame_pix_fmt = enc->pix_fmt;
2971 rfps = ic->streams[i]->r_frame_rate.num;
2972 rfps_base = ic->streams[i]->r_frame_rate.den;
2974 enc->flags |= CODEC_FLAG_EMU_EDGE;
2975 frame_height >>= enc->lowres;
2976 frame_width >>= enc->lowres;
2979 enc->debug |= FF_DEBUG_MV;
2981 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2984 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2985 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2987 (float)rfps / rfps_base, rfps, rfps_base);
2989 /* update the current frame rate to match the stream frame rate */
2990 frame_rate.num = rfps;
2991 frame_rate.den = rfps_base;
2993 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2995 st->discard= AVDISCARD_ALL;
2996 else if(video_discard)
2997 st->discard= video_discard;
2999 case CODEC_TYPE_DATA:
3001 case CODEC_TYPE_SUBTITLE:
3002 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
3003 if(subtitle_disable)
3004 st->discard = AVDISCARD_ALL;
3006 case CODEC_TYPE_ATTACHMENT:
3007 case CODEC_TYPE_UNKNOWN:
3015 input_files[nb_input_files] = ic;
3016 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3017 /* dump the file content */
3019 dump_format(ic, nb_input_files, filename, 0);
3025 av_freep(&video_codec_name);
3026 av_freep(&audio_codec_name);
3027 av_freep(&subtitle_codec_name);
3030 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3031 int *has_subtitle_ptr)
3033 int has_video, has_audio, has_subtitle, i, j;
3034 AVFormatContext *ic;
3039 for(j=0;j<nb_input_files;j++) {
3040 ic = input_files[j];
3041 for(i=0;i<ic->nb_streams;i++) {
3042 AVCodecContext *enc = ic->streams[i]->codec;
3043 switch(enc->codec_type) {
3044 case CODEC_TYPE_AUDIO:
3047 case CODEC_TYPE_VIDEO:
3050 case CODEC_TYPE_SUBTITLE:
3053 case CODEC_TYPE_DATA:
3054 case CODEC_TYPE_ATTACHMENT:
3055 case CODEC_TYPE_UNKNOWN:
3062 *has_video_ptr = has_video;
3063 *has_audio_ptr = has_audio;
3064 *has_subtitle_ptr = has_subtitle;
3067 static void new_video_stream(AVFormatContext *oc)
3070 AVCodecContext *video_enc;
3071 enum CodecID codec_id;
3073 st = av_new_stream(oc, oc->nb_streams);
3075 fprintf(stderr, "Could not alloc stream\n");
3078 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
3079 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3080 video_bitstream_filters= NULL;
3082 avcodec_thread_init(st->codec, thread_count);
3084 video_enc = st->codec;
3087 video_enc->codec_tag= video_codec_tag;
3089 if( (video_global_header&1)
3090 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3091 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3092 avcodec_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3094 if(video_global_header&2){
3095 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3096 avcodec_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3099 if (video_stream_copy) {
3100 st->stream_copy = 1;
3101 video_enc->codec_type = CODEC_TYPE_VIDEO;
3102 video_enc->sample_aspect_ratio =
3103 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3108 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3110 if (video_codec_name) {
3111 codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3112 codec = avcodec_find_encoder_by_name(video_codec_name);
3113 output_codecs[nb_ocodecs] = codec;
3115 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3116 codec = avcodec_find_encoder(codec_id);
3119 video_enc->codec_id = codec_id;
3121 set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3123 if (codec && codec->supported_framerates && !force_fps)
3124 fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3125 video_enc->time_base.den = fps.num;
3126 video_enc->time_base.num = fps.den;
3128 video_enc->width = frame_width + frame_padright + frame_padleft;
3129 video_enc->height = frame_height + frame_padtop + frame_padbottom;
3130 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3131 video_enc->pix_fmt = frame_pix_fmt;
3132 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3134 if(codec && codec->pix_fmts){
3135 const enum PixelFormat *p= codec->pix_fmts;
3137 if(*p == video_enc->pix_fmt)
3141 video_enc->pix_fmt = codec->pix_fmts[0];
3145 video_enc->gop_size = 0;
3146 if (video_qscale || same_quality) {
3147 video_enc->flags |= CODEC_FLAG_QSCALE;
3148 video_enc->global_quality=
3149 st->quality = FF_QP2LAMBDA * video_qscale;
3153 video_enc->intra_matrix = intra_matrix;
3155 video_enc->inter_matrix = inter_matrix;
3157 p= video_rc_override_string;
3160 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3162 fprintf(stderr, "error parsing rc_override\n");
3165 video_enc->rc_override=
3166 av_realloc(video_enc->rc_override,
3167 sizeof(RcOverride)*(i+1));
3168 video_enc->rc_override[i].start_frame= start;
3169 video_enc->rc_override[i].end_frame = end;
3171 video_enc->rc_override[i].qscale= q;
3172 video_enc->rc_override[i].quality_factor= 1.0;
3175 video_enc->rc_override[i].qscale= 0;
3176 video_enc->rc_override[i].quality_factor= -q/100.0;
3181 video_enc->rc_override_count=i;
3182 if (!video_enc->rc_initial_buffer_occupancy)
3183 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3184 video_enc->me_threshold= me_threshold;
3185 video_enc->intra_dc_precision= intra_dc_precision - 8;
3188 video_enc->flags|= CODEC_FLAG_PSNR;
3193 video_enc->flags |= CODEC_FLAG_PASS1;
3195 video_enc->flags |= CODEC_FLAG_PASS2;
3200 if (video_language) {
3201 av_metadata_set(&st->metadata, "language", video_language);
3202 av_freep(&video_language);
3205 /* reset some key parameters */
3207 av_freep(&video_codec_name);
3208 video_stream_copy = 0;
3211 static void new_audio_stream(AVFormatContext *oc)
3214 AVCodecContext *audio_enc;
3215 enum CodecID codec_id;
3217 st = av_new_stream(oc, oc->nb_streams);
3219 fprintf(stderr, "Could not alloc stream\n");
3222 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3224 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3225 audio_bitstream_filters= NULL;
3227 avcodec_thread_init(st->codec, thread_count);
3229 audio_enc = st->codec;
3230 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3233 audio_enc->codec_tag= audio_codec_tag;
3235 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3236 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3237 avcodec_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3239 if (audio_stream_copy) {
3240 st->stream_copy = 1;
3241 audio_enc->channels = audio_channels;
3245 set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3247 if (audio_codec_name) {
3248 codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3249 codec = avcodec_find_encoder_by_name(audio_codec_name);
3250 output_codecs[nb_ocodecs] = codec;
3252 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3253 codec = avcodec_find_encoder(codec_id);
3255 audio_enc->codec_id = codec_id;
3257 if (audio_qscale > QSCALE_NONE) {
3258 audio_enc->flags |= CODEC_FLAG_QSCALE;
3259 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3261 audio_enc->channels = audio_channels;
3262 audio_enc->sample_fmt = audio_sample_fmt;
3263 audio_enc->channel_layout = channel_layout;
3264 if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3265 audio_enc->channel_layout = 0;
3267 if(codec && codec->sample_fmts){
3268 const enum SampleFormat *p= codec->sample_fmts;
3270 if(*p == audio_enc->sample_fmt)
3274 audio_enc->sample_fmt = codec->sample_fmts[0];
3278 audio_enc->sample_rate = audio_sample_rate;
3279 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3280 if (audio_language) {
3281 av_metadata_set(&st->metadata, "language", audio_language);
3282 av_freep(&audio_language);
3285 /* reset some key parameters */
3287 av_freep(&audio_codec_name);
3288 audio_stream_copy = 0;
3291 static void new_subtitle_stream(AVFormatContext *oc)
3294 AVCodecContext *subtitle_enc;
3296 st = av_new_stream(oc, oc->nb_streams);
3298 fprintf(stderr, "Could not alloc stream\n");
3301 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3303 bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3304 subtitle_bitstream_filters= NULL;
3306 subtitle_enc = st->codec;
3307 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3309 if(subtitle_codec_tag)
3310 subtitle_enc->codec_tag= subtitle_codec_tag;
3312 if (subtitle_stream_copy) {
3313 st->stream_copy = 1;
3315 set_context_opts(avcodec_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3316 subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3317 output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3321 if (subtitle_language) {
3322 av_metadata_set(&st->metadata, "language", subtitle_language);
3323 av_freep(&subtitle_language);
3326 subtitle_disable = 0;
3327 av_freep(&subtitle_codec_name);
3328 subtitle_stream_copy = 0;
3331 static void opt_new_audio_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_audio_stream(oc);
3342 static void opt_new_video_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_video_stream(oc);
3353 static void opt_new_subtitle_stream(void)
3355 AVFormatContext *oc;
3356 if (nb_output_files <= 0) {
3357 fprintf(stderr, "At least one output file must be specified\n");
3360 oc = output_files[nb_output_files - 1];
3361 new_subtitle_stream(oc);
3364 static void opt_output_file(const char *filename)
3366 AVFormatContext *oc;
3367 int use_video, use_audio, use_subtitle;
3368 int input_has_video, input_has_audio, input_has_subtitle;
3369 AVFormatParameters params, *ap = ¶ms;
3370 AVOutputFormat *file_oformat;
3372 if (!strcmp(filename, "-"))
3375 oc = avformat_alloc_context();
3377 print_error(filename, AVERROR(ENOMEM));
3381 if (last_asked_format) {
3382 file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3383 if (!file_oformat) {
3384 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3387 last_asked_format = NULL;
3389 file_oformat = av_guess_format(NULL, filename, NULL);
3390 if (!file_oformat) {
3391 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3397 oc->oformat = file_oformat;
3398 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3400 if (!strcmp(file_oformat->name, "ffm") &&
3401 av_strstart(filename, "http:", NULL)) {
3402 /* special case for files sent to ffserver: we get the stream
3403 parameters from ffserver */
3404 int err = read_ffserver_streams(oc, filename);
3406 print_error(filename, err);
3410 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3411 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3412 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3414 /* disable if no corresponding type found and at least one
3416 if (nb_input_files > 0) {
3417 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3418 &input_has_subtitle);
3419 if (!input_has_video)
3421 if (!input_has_audio)
3423 if (!input_has_subtitle)
3427 /* manual disable */
3428 if (audio_disable) {
3431 if (video_disable) {
3434 if (subtitle_disable) {
3439 new_video_stream(oc);
3443 new_audio_stream(oc);
3447 new_subtitle_stream(oc);
3450 oc->timestamp = rec_timestamp;
3452 for(; metadata_count>0; metadata_count--){
3453 av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3454 metadata[metadata_count-1].value);
3456 av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3459 output_files[nb_output_files++] = oc;
3461 /* check filename in case of an image number is expected */
3462 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3463 if (!av_filename_number_test(oc->filename)) {
3464 print_error(oc->filename, AVERROR_NUMEXPECTED);
3469 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3470 /* test if it already exists to avoid loosing precious files */
3471 if (!file_overwrite &&
3472 (strchr(filename, ':') == NULL ||
3473 filename[1] == ':' ||
3474 av_strstart(filename, "file:", NULL))) {
3475 if (url_exist(filename)) {
3477 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3479 if (!read_yesno()) {
3480 fprintf(stderr, "Not overwriting - exiting\n");
3485 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3492 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3493 fprintf(stderr, "Could not open '%s'\n", filename);
3498 memset(ap, 0, sizeof(*ap));
3499 if (av_set_parameters(oc, ap) < 0) {
3500 fprintf(stderr, "%s: Invalid encoding parameters\n",
3505 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3506 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3507 oc->loop_output = loop_output;
3508 oc->flags |= AVFMT_FLAG_NONBLOCK;
3510 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3513 /* same option as mencoder */
3514 static void opt_pass(const char *pass_str)
3517 pass = atoi(pass_str);
3518 if (pass != 1 && pass != 2) {
3519 fprintf(stderr, "pass number can be only 1 or 2\n");
3525 static int64_t getutime(void)
3528 struct rusage rusage;
3530 getrusage(RUSAGE_SELF, &rusage);
3531 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3532 #elif HAVE_GETPROCESSTIMES
3534 FILETIME c, e, k, u;
3535 proc = GetCurrentProcess();
3536 GetProcessTimes(proc, &c, &e, &k, &u);
3537 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3539 return av_gettime();
3543 static int64_t getmaxrss(void)
3545 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3546 struct rusage rusage;
3547 getrusage(RUSAGE_SELF, &rusage);
3548 return (int64_t)rusage.ru_maxrss * 1024;
3549 #elif HAVE_GETPROCESSMEMORYINFO
3551 PROCESS_MEMORY_COUNTERS memcounters;
3552 proc = GetCurrentProcess();
3553 memcounters.cb = sizeof(memcounters);
3554 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3555 return memcounters.PeakPagefileUsage;
3561 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3564 const char *p = str;
3571 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3578 static void opt_inter_matrix(const char *arg)
3580 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3581 parse_matrix_coeffs(inter_matrix, arg);
3584 static void opt_intra_matrix(const char *arg)
3586 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3587 parse_matrix_coeffs(intra_matrix, arg);
3591 * Trivial log callback.
3592 * Only suitable for show_help and similar since it lacks prefix handling.
3594 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3596 vfprintf(stdout, fmt, vl);
3599 static void show_usage(void)
3601 printf("Hyper fast Audio and Video encoder\n");
3602 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3606 static void show_help(void)
3608 av_log_set_callback(log_callback_help);
3610 show_help_options(options, "Main options:\n",
3611 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3612 show_help_options(options, "\nAdvanced options:\n",
3613 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3615 show_help_options(options, "\nVideo options:\n",
3616 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3618 show_help_options(options, "\nAdvanced Video options:\n",
3619 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3620 OPT_VIDEO | OPT_EXPERT);
3621 show_help_options(options, "\nAudio options:\n",
3622 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3624 show_help_options(options, "\nAdvanced Audio options:\n",
3625 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3626 OPT_AUDIO | OPT_EXPERT);
3627 show_help_options(options, "\nSubtitle options:\n",
3628 OPT_SUBTITLE | OPT_GRAB,
3630 show_help_options(options, "\nAudio/Video grab options:\n",
3634 av_opt_show(avcodec_opts[0], NULL);
3636 av_opt_show(avformat_opts, NULL);
3638 av_opt_show(sws_opts, NULL);
3641 static void opt_target(const char *arg)
3643 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3644 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3646 if(!strncmp(arg, "pal-", 4)) {
3649 } else if(!strncmp(arg, "ntsc-", 5)) {
3652 } else if(!strncmp(arg, "film-", 5)) {
3657 /* Calculate FR via float to avoid int overflow */
3658 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3661 } else if((fr == 29970) || (fr == 23976)) {
3664 /* Try to determine PAL/NTSC by peeking in the input files */
3665 if(nb_input_files) {
3667 for(j = 0; j < nb_input_files; j++) {
3668 for(i = 0; i < input_files[j]->nb_streams; i++) {
3669 AVCodecContext *c = input_files[j]->streams[i]->codec;
3670 if(c->codec_type != CODEC_TYPE_VIDEO)
3672 fr = c->time_base.den * 1000 / c->time_base.num;
3676 } else if((fr == 29970) || (fr == 23976)) {
3686 if(verbose && norm != UNKNOWN)
3687 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3690 if(norm == UNKNOWN) {
3691 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3692 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3693 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3697 if(!strcmp(arg, "vcd")) {
3699 opt_video_codec("mpeg1video");
3700 opt_audio_codec("mp2");
3703 opt_frame_size(norm == PAL ? "352x288" : "352x240");
3704 opt_frame_rate(NULL, frame_rates[norm]);
3705 opt_default("g", norm == PAL ? "15" : "18");
3707 opt_default("b", "1150000");
3708 opt_default("maxrate", "1150000");
3709 opt_default("minrate", "1150000");
3710 opt_default("bufsize", "327680"); // 40*1024*8;
3712 opt_default("ab", "224000");
3713 audio_sample_rate = 44100;
3716 opt_default("packetsize", "2324");
3717 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3719 /* We have to offset the PTS, so that it is consistent with the SCR.
3720 SCR starts at 36000, but the first two packs contain only padding
3721 and the first pack from the other stream, respectively, may also have
3722 been written before.
3723 So the real data starts at SCR 36000+3*1200. */
3724 mux_preload= (36000+3*1200) / 90000.0; //0.44
3725 } else if(!strcmp(arg, "svcd")) {
3727 opt_video_codec("mpeg2video");
3728 opt_audio_codec("mp2");
3731 opt_frame_size(norm == PAL ? "480x576" : "480x480");
3732 opt_frame_rate(NULL, frame_rates[norm]);
3733 opt_default("g", norm == PAL ? "15" : "18");
3735 opt_default("b", "2040000");
3736 opt_default("maxrate", "2516000");
3737 opt_default("minrate", "0"); //1145000;
3738 opt_default("bufsize", "1835008"); //224*1024*8;
3739 opt_default("flags", "+scan_offset");
3742 opt_default("ab", "224000");
3743 audio_sample_rate = 44100;
3745 opt_default("packetsize", "2324");
3747 } else if(!strcmp(arg, "dvd")) {
3749 opt_video_codec("mpeg2video");
3750 opt_audio_codec("ac3");
3753 opt_frame_size(norm == PAL ? "720x576" : "720x480");
3754 opt_frame_rate(NULL, frame_rates[norm]);
3755 opt_default("g", norm == PAL ? "15" : "18");
3757 opt_default("b", "6000000");
3758 opt_default("maxrate", "9000000");
3759 opt_default("minrate", "0"); //1500000;
3760 opt_default("bufsize", "1835008"); //224*1024*8;
3762 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3763 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3765 opt_default("ab", "448000");
3766 audio_sample_rate = 48000;
3768 } else if(!strncmp(arg, "dv", 2)) {
3772 opt_frame_size(norm == PAL ? "720x576" : "720x480");
3773 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3774 (norm == PAL ? "yuv420p" : "yuv411p"));
3775 opt_frame_rate(NULL, frame_rates[norm]);
3777 audio_sample_rate = 48000;
3781 fprintf(stderr, "Unknown target: %s\n", arg);
3786 static void opt_vstats_file (const char *arg)
3788 av_free (vstats_filename);
3789 vstats_filename=av_strdup (arg);
3792 static void opt_vstats (void)
3795 time_t today2 = time(NULL);
3796 struct tm *today = localtime(&today2);
3798 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3800 opt_vstats_file(filename);
3803 static int opt_bsf(const char *opt, const char *arg)
3805 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3806 AVBitStreamFilterContext **bsfp;
3809 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3813 bsfp= *opt == 'v' ? &video_bitstream_filters :
3814 *opt == 'a' ? &audio_bitstream_filters :
3815 &subtitle_bitstream_filters;
3817 bsfp= &(*bsfp)->next;
3824 static int opt_preset(const char *opt, const char *arg)
3827 char filename[1000], tmp[1000], tmp2[1000], line[1000];
3829 const char *base[2]= { getenv("HOME"),
3834 for(i=!base[0]; i<2 && !f; i++){
3835 snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
3836 f= fopen(filename, "r");
3838 char *codec_name= *opt == 'v' ? video_codec_name :
3839 *opt == 'a' ? audio_codec_name :
3840 subtitle_codec_name;
3841 snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i], i ? "" : "/.ffmpeg", codec_name, arg);
3842 f= fopen(filename, "r");
3846 av_strlcpy(filename, arg, sizeof(filename));
3847 f= fopen(filename, "r");
3851 fprintf(stderr, "File for preset '%s' not found\n", arg);
3856 int e= fscanf(f, "%999[^\n]\n", line) - 1;
3857 if(line[0] == '#' && !e)
3859 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3861 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3864 if(!strcmp(tmp, "acodec")){
3865 opt_audio_codec(tmp2);
3866 }else if(!strcmp(tmp, "vcodec")){
3867 opt_video_codec(tmp2);
3868 }else if(!strcmp(tmp, "scodec")){
3869 opt_subtitle_codec(tmp2);
3870 }else if(opt_default(tmp, tmp2) < 0){
3871 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3881 static const OptionDef options[] = {
3883 #include "cmdutils_common_opts.h"
3884 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3885 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3886 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3887 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3888 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3889 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3890 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3891 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3892 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3893 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
3894 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_rec_timestamp}, "set the timestamp ('now' to set the current time)", "time" },
3895 { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
3896 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3897 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3898 "add timings for benchmarking" },
3899 { "timelimit", OPT_FUNC2 | HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
3900 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3901 "dump each input packet" },
3902 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3903 "when dumping packets, also dump the payload" },
3904 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3905 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3906 { "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)", "" },
3907 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
3908 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3909 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3910 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3911 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3912 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3913 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3914 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3915 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3916 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3917 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3918 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
3919 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
3922 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3923 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3924 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3925 { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3926 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3927 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3928 { "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" },
3929 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3930 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3931 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3932 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3933 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3934 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3935 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3936 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3937 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3938 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3939 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3940 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3941 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3942 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3943 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3944 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
3945 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3946 "use same video quality as source (implies VBR)" },
3947 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3948 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
3949 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3950 "deinterlace pictures" },
3951 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3952 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3953 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3954 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3955 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3956 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3957 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3958 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3959 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3960 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
3961 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3962 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
3965 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3966 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3967 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3968 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3969 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3970 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3971 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3972 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3973 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3974 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3975 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3976 { "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" },
3978 /* subtitle options */
3979 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3980 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3981 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3982 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3983 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
3986 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3987 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3988 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3991 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3992 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3994 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3995 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3996 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3998 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3999 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4000 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4001 { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4003 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4007 int main(int argc, char **argv)
4012 avcodec_register_all();
4013 avdevice_register_all();
4017 if(isatty(STDIN_FILENO))
4018 url_set_interrupt_cb(decode_interrupt_cb);
4021 for(i=0; i<CODEC_TYPE_NB; i++){
4022 avcodec_opts[i]= avcodec_alloc_context2(i);
4024 avformat_opts = avformat_alloc_context();
4025 sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
4030 parse_options(argc, argv, options, opt_output_file);
4032 if(nb_output_files <= 0 && nb_input_files == 0) {
4034 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4038 /* file converter / grab */
4039 if (nb_output_files <= 0) {
4040 fprintf(stderr, "At least one output file must be specified\n");
4044 if (nb_input_files == 0) {
4045 fprintf(stderr, "At least one input file must be specified\n");
4050 if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
4051 stream_maps, nb_stream_maps) < 0)
4053 ti = getutime() - ti;
4055 int maxrss = getmaxrss() / 1024;
4056 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);