3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 /* needed for usleep() */
23 #define _XOPEN_SOURCE 600
34 #include "libavformat/avformat.h"
35 #include "libavdevice/avdevice.h"
36 #include "libswscale/swscale.h"
37 #include "libavcodec/opt.h"
38 #include "libavcodec/audioconvert.h"
39 #include "libavcodec/colorspace.h"
40 #include "libavutil/fifo.h"
41 #include "libavutil/avstring.h"
42 #include "libavformat/os_support.h"
44 #if HAVE_SYS_RESOURCE_H
45 #include <sys/types.h>
46 #include <sys/resource.h>
47 #elif HAVE_GETPROCESSTIMES
52 #include <sys/select.h>
57 #include <sys/ioctl.h>
63 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
73 const char program_name[] = "FFmpeg";
74 const int program_birth_year = 2000;
76 /* select an input stream for an output stream */
77 typedef struct AVStreamMap {
81 int sync_stream_index;
84 /** select an input file for an output file */
85 typedef struct AVMetaDataMap {
90 static const OptionDef options[];
94 static const char *last_asked_format = NULL;
95 static AVFormatContext *input_files[MAX_FILES];
96 static int64_t input_files_ts_offset[MAX_FILES];
97 static double input_files_ts_scale[MAX_FILES][MAX_STREAMS];
98 static AVCodec *input_codecs[MAX_FILES*MAX_STREAMS];
99 static int nb_input_files = 0;
100 static int nb_icodecs;
102 static AVFormatContext *output_files[MAX_FILES];
103 static AVCodec *output_codecs[MAX_FILES*MAX_STREAMS];
104 static int nb_output_files = 0;
105 static int nb_ocodecs;
107 static AVStreamMap stream_maps[MAX_FILES*MAX_STREAMS];
108 static int nb_stream_maps;
110 static AVMetaDataMap meta_data_maps[MAX_FILES];
111 static int nb_meta_data_maps;
113 static int frame_width = 0;
114 static int frame_height = 0;
115 static float frame_aspect_ratio = 0;
116 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
117 static enum SampleFormat audio_sample_fmt = SAMPLE_FMT_NONE;
118 static int frame_padtop = 0;
119 static int frame_padbottom = 0;
120 static int frame_padleft = 0;
121 static int frame_padright = 0;
122 static int padcolor[3] = {16,128,128}; /* default to black */
123 static int frame_topBand = 0;
124 static int frame_bottomBand = 0;
125 static int frame_leftBand = 0;
126 static int frame_rightBand = 0;
127 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
128 static AVRational frame_rate;
129 static float video_qscale = 0;
130 static uint16_t *intra_matrix = NULL;
131 static uint16_t *inter_matrix = NULL;
132 static const char *video_rc_override_string=NULL;
133 static int video_disable = 0;
134 static int video_discard = 0;
135 static char *video_codec_name = NULL;
136 static int video_codec_tag = 0;
137 static char *video_language = NULL;
138 static int same_quality = 0;
139 static int do_deinterlace = 0;
140 static int top_field_first = -1;
141 static int me_threshold = 0;
142 static int intra_dc_precision = 8;
143 static int loop_input = 0;
144 static int loop_output = AVFMT_NOOUTPUTLOOP;
145 static int qp_hist = 0;
147 static int intra_only = 0;
148 static int audio_sample_rate = 44100;
149 static int64_t channel_layout = 0;
150 #define QSCALE_NONE -99999
151 static float audio_qscale = QSCALE_NONE;
152 static int audio_disable = 0;
153 static int audio_channels = 1;
154 static char *audio_codec_name = NULL;
155 static int audio_codec_tag = 0;
156 static char *audio_language = NULL;
158 static int subtitle_disable = 0;
159 static char *subtitle_codec_name = NULL;
160 static char *subtitle_language = NULL;
161 static int subtitle_codec_tag = 0;
163 static float mux_preload= 0.5;
164 static float mux_max_delay= 0.7;
166 static int64_t recording_time = INT64_MAX;
167 static int64_t start_time = 0;
168 static int64_t rec_timestamp = 0;
169 static int64_t input_ts_offset = 0;
170 static int file_overwrite = 0;
171 static int metadata_count;
172 static AVMetadataTag *metadata;
173 static int do_benchmark = 0;
174 static int do_hex_dump = 0;
175 static int do_pkt_dump = 0;
176 static int do_psnr = 0;
177 static int do_pass = 0;
178 static char *pass_logfilename_prefix = NULL;
179 static int audio_stream_copy = 0;
180 static int video_stream_copy = 0;
181 static int subtitle_stream_copy = 0;
182 static int video_sync_method= -1;
183 static int audio_sync_method= 0;
184 static float audio_drift_threshold= 0.1;
185 static int copy_ts= 0;
186 static int opt_shortest = 0;
187 static int video_global_header = 0;
188 static char *vstats_filename;
189 static FILE *vstats_file;
190 static int opt_programid = 0;
191 static int copy_initial_nonkeyframes = 0;
193 static int rate_emu = 0;
195 static int video_channel = 0;
196 static char *video_standard;
198 static int audio_volume = 256;
200 static int exit_on_error = 0;
201 static int using_stdin = 0;
202 static int verbose = 1;
203 static int thread_count= 1;
204 static int q_pressed = 0;
205 static int64_t video_size = 0;
206 static int64_t audio_size = 0;
207 static int64_t extra_size = 0;
208 static int nb_frames_dup = 0;
209 static int nb_frames_drop = 0;
210 static int input_sync;
211 static uint64_t limit_filesize = 0;
212 static int force_fps = 0;
214 static int pgmyuv_compatibility_hack=0;
215 static float dts_delta_threshold = 10;
217 static unsigned int sws_flags = SWS_BICUBIC;
219 static int64_t timer_start;
221 static uint8_t *audio_buf;
222 static uint8_t *audio_out;
223 unsigned int allocated_audio_out_size, allocated_audio_buf_size;
225 static short *samples;
227 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
228 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
229 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
230 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
232 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
234 struct AVInputStream;
236 typedef struct AVOutputStream {
237 int file_index; /* file index */
238 int index; /* stream index in the output file */
239 int source_index; /* AVInputStream index */
240 AVStream *st; /* stream in the output file */
241 int encoding_needed; /* true if encoding needed for this stream */
243 /* input pts and corresponding output pts
245 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
246 struct AVInputStream *sync_ist; /* input stream to sync against */
247 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
250 AVFrame pict_tmp; /* temporary image for resampling */
251 struct SwsContext *img_resample_ctx; /* for image resampling */
254 int resample_pix_fmt;
256 /* full frame size of first frame */
260 /* cropping area sizes */
267 /* cropping area of first frame */
268 int original_topBand;
269 int original_bottomBand;
270 int original_leftBand;
271 int original_rightBand;
273 /* padding area sizes */
282 ReSampleContext *resample; /* for audio resampling */
284 AVAudioConvert *reformat_ctx;
285 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
289 typedef struct AVInputStream {
293 int discard; /* true if stream data should be discarded */
294 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
295 int64_t sample_index; /* current sample */
297 int64_t start; /* time when read started */
298 int64_t next_pts; /* synthetic pts for cases where pkt.pts
300 int64_t pts; /* current pts */
301 int is_start; /* is 1 at the start and after a discontinuity */
304 typedef struct AVInputFile {
305 int eof_reached; /* true if eof reached */
306 int ist_index; /* index of first stream in ist_table */
307 int buffer_size; /* current total buffer size */
308 int nb_streams; /* nb streams we are aware of */
313 /* init terminal so that we can grab keys */
314 static struct termios oldtty;
317 static void term_exit(void)
320 tcsetattr (0, TCSANOW, &oldtty);
324 static volatile int received_sigterm = 0;
327 sigterm_handler(int sig)
329 received_sigterm = sig;
333 static void term_init(void)
341 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
342 |INLCR|IGNCR|ICRNL|IXON);
343 tty.c_oflag |= OPOST;
344 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
345 tty.c_cflag &= ~(CSIZE|PARENB);
350 tcsetattr (0, TCSANOW, &tty);
351 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
354 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
355 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
357 register a function to be called at normal program termination
360 #if CONFIG_BEOS_NETSERVER
361 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
365 /* read a key without blocking */
366 static int read_key(void)
371 #if !CONFIG_BEOS_NETSERVER
379 n = select(1, &rfds, NULL, NULL, &tv);
395 static int decode_interrupt_cb(void)
397 return q_pressed || (q_pressed = read_key() == 'q');
400 static int av_exit(int ret)
405 for(i=0;i<nb_output_files;i++) {
406 /* maybe av_close_output_file ??? */
407 AVFormatContext *s = output_files[i];
409 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
411 for(j=0;j<s->nb_streams;j++) {
412 av_metadata_free(&s->streams[j]->metadata);
413 av_free(s->streams[j]->codec);
414 av_free(s->streams[j]);
416 for(j=0;j<s->nb_programs;j++) {
417 av_metadata_free(&s->programs[j]->metadata);
419 for(j=0;j<s->nb_chapters;j++) {
420 av_metadata_free(&s->chapters[j]->metadata);
422 av_metadata_free(&s->metadata);
425 for(i=0;i<nb_input_files;i++)
426 av_close_input_file(input_files[i]);
428 av_free(intra_matrix);
429 av_free(inter_matrix);
433 av_free(vstats_filename);
437 av_free(video_codec_name);
438 av_free(audio_codec_name);
439 av_free(subtitle_codec_name);
441 av_free(video_standard);
443 #if CONFIG_POWERPC_PERF
444 void powerpc_display_perf_report(void);
445 powerpc_display_perf_report();
446 #endif /* CONFIG_POWERPC_PERF */
448 for (i=0;i<CODEC_TYPE_NB;i++)
449 av_free(avcodec_opts[i]);
450 av_free(avformat_opts);
454 allocated_audio_buf_size= allocated_audio_out_size= 0;
457 if (received_sigterm) {
459 "Received signal %d: terminating.\n",
460 (int) received_sigterm);
464 exit(ret); /* not all OS-es handle main() return value */
468 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
474 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
477 /* copy stream format */
478 s->nb_streams = ic->nb_streams;
479 for(i=0;i<ic->nb_streams;i++) {
482 // FIXME: a more elegant solution is needed
483 st = av_mallocz(sizeof(AVStream));
484 memcpy(st, ic->streams[i], sizeof(AVStream));
485 st->codec = avcodec_alloc_context();
487 print_error(filename, AVERROR(ENOMEM));
490 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
493 if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
495 else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
498 if(!st->codec->thread_count)
499 st->codec->thread_count = 1;
500 if(st->codec->thread_count>1)
501 avcodec_thread_init(st->codec, st->codec->thread_count);
503 if(st->codec->flags & CODEC_FLAG_BITEXACT)
508 s->timestamp = av_gettime();
510 av_close_input_file(ic);
515 get_sync_ipts(const AVOutputStream *ost)
517 const AVInputStream *ist = ost->sync_ist;
518 return (double)(ist->pts - start_time)/AV_TIME_BASE;
521 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
525 AVPacket new_pkt= *pkt;
526 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
527 &new_pkt.data, &new_pkt.size,
528 pkt->data, pkt->size,
529 pkt->flags & PKT_FLAG_KEY);
532 new_pkt.destruct= av_destruct_packet;
534 fprintf(stderr, "%s failed for stream %d, codec %s",
535 bsfc->filter->name, pkt->stream_index,
536 avctx->codec ? avctx->codec->name : "copy");
546 ret= av_interleaved_write_frame(s, pkt);
548 print_error("av_interleaved_write_frame()", ret);
553 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
555 static void do_audio_out(AVFormatContext *s,
558 unsigned char *buf, int size)
561 int64_t audio_out_size, audio_buf_size;
563 int size_out, frame_bytes, ret;
564 AVCodecContext *enc= ost->st->codec;
565 AVCodecContext *dec= ist->st->codec;
566 int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
567 int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
568 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
570 audio_buf_size= (size + isize*dec->channels - 1) / (isize*dec->channels);
571 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
572 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
573 audio_buf_size*= osize*enc->channels;
575 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
576 if(coded_bps > 8*osize)
577 audio_out_size= audio_out_size * coded_bps / (8*osize);
578 audio_out_size += FF_MIN_BUFFER_SIZE;
580 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
581 fprintf(stderr, "Buffer sizes too large\n");
585 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
586 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
587 if (!audio_buf || !audio_out){
588 fprintf(stderr, "Out of memory in do_audio_out\n");
592 if (enc->channels != dec->channels)
593 ost->audio_resample = 1;
595 if (ost->audio_resample && !ost->resample) {
596 if (dec->sample_fmt != SAMPLE_FMT_S16)
597 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
598 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
599 enc->sample_rate, dec->sample_rate,
600 enc->sample_fmt, dec->sample_fmt,
602 if (!ost->resample) {
603 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
604 dec->channels, dec->sample_rate,
605 enc->channels, enc->sample_rate);
610 #define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
611 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
612 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
613 if (ost->reformat_ctx)
614 av_audio_convert_free(ost->reformat_ctx);
615 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
616 dec->sample_fmt, 1, NULL, 0);
617 if (!ost->reformat_ctx) {
618 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
619 avcodec_get_sample_fmt_name(dec->sample_fmt),
620 avcodec_get_sample_fmt_name(enc->sample_fmt));
623 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
626 if(audio_sync_method){
627 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
628 - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2);
629 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
630 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
632 //FIXME resample delay
633 if(fabs(delta) > 50){
634 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
636 byte_delta= FFMAX(byte_delta, -size);
640 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
645 static uint8_t *input_tmp= NULL;
646 input_tmp= av_realloc(input_tmp, byte_delta + size);
648 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
651 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
653 memset(input_tmp, 0, byte_delta);
654 memcpy(input_tmp + byte_delta, buf, size);
658 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
660 }else if(audio_sync_method>1){
661 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
662 assert(ost->audio_resample);
664 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
665 // 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));
666 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
670 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
671 - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
673 if (ost->audio_resample) {
675 size_out = audio_resample(ost->resample,
676 (short *)buftmp, (short *)buf,
677 size / (ist->st->codec->channels * isize));
678 size_out = size_out * enc->channels * osize;
684 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
685 const void *ibuf[6]= {buftmp};
686 void *obuf[6]= {audio_buf};
687 int istride[6]= {isize};
688 int ostride[6]= {osize};
689 int len= size_out/istride[0];
690 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
691 printf("av_audio_convert() failed\n");
697 size_out = len*osize;
700 /* now encode as many frames as possible */
701 if (enc->frame_size > 1) {
702 /* output resampled raw samples */
703 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
704 fprintf(stderr, "av_fifo_realloc2() failed\n");
707 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
709 frame_bytes = enc->frame_size * osize * enc->channels;
711 while (av_fifo_size(ost->fifo) >= frame_bytes) {
713 av_init_packet(&pkt);
715 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
717 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
719 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
722 fprintf(stderr, "Audio encoding failed\n");
726 pkt.stream_index= ost->index;
729 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
730 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
731 pkt.flags |= PKT_FLAG_KEY;
732 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
734 ost->sync_opts += enc->frame_size;
738 av_init_packet(&pkt);
740 ost->sync_opts += size_out / (osize * enc->channels);
742 /* output a pcm frame */
743 /* determine the size of the coded buffer */
746 size_out = size_out*coded_bps/8;
748 if(size_out > audio_out_size){
749 fprintf(stderr, "Internal error, buffer size too small\n");
753 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
754 ret = avcodec_encode_audio(enc, audio_out, size_out,
757 fprintf(stderr, "Audio encoding failed\n");
761 pkt.stream_index= ost->index;
764 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
765 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
766 pkt.flags |= PKT_FLAG_KEY;
767 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
771 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
775 AVPicture picture_tmp;
778 dec = ist->st->codec;
780 /* deinterlace : must be done before any resize */
781 if (do_deinterlace) {
784 /* create temporary picture */
785 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
786 buf = av_malloc(size);
790 picture2 = &picture_tmp;
791 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
793 if(avpicture_deinterlace(picture2, picture,
794 dec->pix_fmt, dec->width, dec->height) < 0) {
795 /* if error, do not deinterlace */
796 fprintf(stderr, "Deinterlacing failed\n");
805 if (picture != picture2)
806 *picture = *picture2;
810 /* we begin to correct av delay at this threshold */
811 #define AV_DELAY_MAX 0.100
813 static void do_subtitle_out(AVFormatContext *s,
819 static uint8_t *subtitle_out = NULL;
820 int subtitle_out_max_size = 1024 * 1024;
821 int subtitle_out_size, nb, i;
825 if (pts == AV_NOPTS_VALUE) {
826 fprintf(stderr, "Subtitle packets must have a pts\n");
832 enc = ost->st->codec;
835 subtitle_out = av_malloc(subtitle_out_max_size);
838 /* Note: DVB subtitle need one packet to draw them and one other
839 packet to clear them */
840 /* XXX: signal it in the codec context ? */
841 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
846 for(i = 0; i < nb; i++) {
847 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
848 // start_display_time is required to be 0
849 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
850 sub->end_display_time -= sub->start_display_time;
851 sub->start_display_time = 0;
852 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
853 subtitle_out_max_size, sub);
854 if (subtitle_out_size < 0) {
855 fprintf(stderr, "Subtitle encoding failed\n");
859 av_init_packet(&pkt);
860 pkt.stream_index = ost->index;
861 pkt.data = subtitle_out;
862 pkt.size = subtitle_out_size;
863 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
864 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
865 /* XXX: the pts correction is handled here. Maybe handling
866 it in the codec would be better */
868 pkt.pts += 90 * sub->start_display_time;
870 pkt.pts += 90 * sub->end_display_time;
872 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
876 static int bit_buffer_size= 1024*256;
877 static uint8_t *bit_buffer= NULL;
879 static void do_video_out(AVFormatContext *s,
885 int nb_frames, i, ret;
886 int64_t topBand, bottomBand, leftBand, rightBand;
887 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
888 AVFrame picture_crop_temp, picture_pad_temp;
889 AVCodecContext *enc, *dec;
891 avcodec_get_frame_defaults(&picture_crop_temp);
892 avcodec_get_frame_defaults(&picture_pad_temp);
894 enc = ost->st->codec;
895 dec = ist->st->codec;
897 /* by default, we output a single frame */
902 if(video_sync_method){
904 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
905 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
908 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
912 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
913 }else if (vdelta > 1.1)
914 nb_frames = lrintf(vdelta);
915 //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);
919 fprintf(stderr, "*** drop!\n");
920 }else if (nb_frames > 1) {
921 nb_frames_dup += nb_frames - 1;
923 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
926 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
928 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
932 if (ost->video_crop) {
933 if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
934 fprintf(stderr, "error cropping picture\n");
939 formatted_picture = &picture_crop_temp;
941 formatted_picture = in_picture;
944 final_picture = formatted_picture;
945 padding_src = formatted_picture;
946 resampling_dst = &ost->pict_tmp;
947 if (ost->video_pad) {
948 final_picture = &ost->pict_tmp;
949 if (ost->video_resample) {
950 if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
951 fprintf(stderr, "error padding picture\n");
956 resampling_dst = &picture_pad_temp;
960 if( (ost->resample_height != (ist->st->codec->height - (ost->topBand + ost->bottomBand)))
961 || (ost->resample_width != (ist->st->codec->width - (ost->leftBand + ost->rightBand)))
962 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
964 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));
965 if(!ost->video_resample)
969 if (ost->video_resample) {
971 final_picture = &ost->pict_tmp;
972 if( (ost->resample_height != (ist->st->codec->height - (ost->topBand + ost->bottomBand)))
973 || (ost->resample_width != (ist->st->codec->width - (ost->leftBand + ost->rightBand)))
974 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
976 /* keep bands proportional to the frame size */
977 topBand = ((int64_t)ist->st->codec->height * ost->original_topBand / ost->original_height) & ~1;
978 bottomBand = ((int64_t)ist->st->codec->height * ost->original_bottomBand / ost->original_height) & ~1;
979 leftBand = ((int64_t)ist->st->codec->width * ost->original_leftBand / ost->original_width) & ~1;
980 rightBand = ((int64_t)ist->st->codec->width * ost->original_rightBand / ost->original_width) & ~1;
982 /* sanity check to ensure no bad band sizes sneak in */
983 assert(topBand <= INT_MAX && topBand >= 0);
984 assert(bottomBand <= INT_MAX && bottomBand >= 0);
985 assert(leftBand <= INT_MAX && leftBand >= 0);
986 assert(rightBand <= INT_MAX && rightBand >= 0);
988 ost->topBand = topBand;
989 ost->bottomBand = bottomBand;
990 ost->leftBand = leftBand;
991 ost->rightBand = rightBand;
993 ost->resample_height = ist->st->codec->height - (ost->topBand + ost->bottomBand);
994 ost->resample_width = ist->st->codec->width - (ost->leftBand + ost->rightBand);
995 ost->resample_pix_fmt= ist->st->codec->pix_fmt;
997 /* initialize a new scaler context */
998 sws_freeContext(ost->img_resample_ctx);
999 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1000 ost->img_resample_ctx = sws_getContext(
1001 ist->st->codec->width - (ost->leftBand + ost->rightBand),
1002 ist->st->codec->height - (ost->topBand + ost->bottomBand),
1003 ist->st->codec->pix_fmt,
1004 ost->st->codec->width - (ost->padleft + ost->padright),
1005 ost->st->codec->height - (ost->padtop + ost->padbottom),
1006 ost->st->codec->pix_fmt,
1007 sws_flags, NULL, NULL, NULL);
1008 if (ost->img_resample_ctx == NULL) {
1009 fprintf(stderr, "Cannot get resampling context\n");
1013 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1014 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1017 if (ost->video_pad) {
1018 av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
1019 enc->height, enc->width, enc->pix_fmt,
1020 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
1023 /* duplicates frame if needed */
1024 for(i=0;i<nb_frames;i++) {
1026 av_init_packet(&pkt);
1027 pkt.stream_index= ost->index;
1029 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1030 /* raw pictures are written as AVPicture structure to
1031 avoid any copies. We support temorarily the older
1033 AVFrame* old_frame = enc->coded_frame;
1034 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1035 pkt.data= (uint8_t *)final_picture;
1036 pkt.size= sizeof(AVPicture);
1037 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1038 pkt.flags |= PKT_FLAG_KEY;
1040 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1041 enc->coded_frame = old_frame;
1043 AVFrame big_picture;
1045 big_picture= *final_picture;
1046 /* better than nothing: use input picture interlaced
1048 big_picture.interlaced_frame = in_picture->interlaced_frame;
1049 if(avcodec_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1050 if(top_field_first == -1)
1051 big_picture.top_field_first = in_picture->top_field_first;
1053 big_picture.top_field_first = top_field_first;
1056 /* handles sameq here. This is not correct because it may
1057 not be a global option */
1059 big_picture.quality = ist->st->quality;
1061 big_picture.quality = ost->st->quality;
1063 big_picture.pict_type = 0;
1064 // big_picture.pts = AV_NOPTS_VALUE;
1065 big_picture.pts= ost->sync_opts;
1066 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1067 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1068 ret = avcodec_encode_video(enc,
1069 bit_buffer, bit_buffer_size,
1072 fprintf(stderr, "Video encoding failed\n");
1077 pkt.data= bit_buffer;
1079 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1080 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1081 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1082 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1083 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1085 if(enc->coded_frame->key_frame)
1086 pkt.flags |= PKT_FLAG_KEY;
1087 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1090 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1091 // enc->frame_number-1, ret, enc->pict_type);
1092 /* if two pass, output log */
1093 if (ost->logfile && enc->stats_out) {
1094 fprintf(ost->logfile, "%s", enc->stats_out);
1099 ost->frame_number++;
1103 static double psnr(double d){
1104 return -10.0*log(d)/log(10.0);
1107 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1110 AVCodecContext *enc;
1112 double ti1, bitrate, avg_bitrate;
1114 /* this is executed just the first time do_video_stats is called */
1116 vstats_file = fopen(vstats_filename, "w");
1123 enc = ost->st->codec;
1124 if (enc->codec_type == CODEC_TYPE_VIDEO) {
1125 frame_number = ost->frame_number;
1126 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1127 if (enc->flags&CODEC_FLAG_PSNR)
1128 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1130 fprintf(vstats_file,"f_size= %6d ", frame_size);
1131 /* compute pts value */
1132 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1136 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1137 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1138 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1139 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1140 fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1144 static void print_report(AVFormatContext **output_files,
1145 AVOutputStream **ost_table, int nb_ostreams,
1149 AVOutputStream *ost;
1150 AVFormatContext *oc;
1152 AVCodecContext *enc;
1153 int frame_number, vid, i;
1154 double bitrate, ti1, pts;
1155 static int64_t last_time = -1;
1156 static int qp_histogram[52];
1158 if (!is_last_report) {
1160 /* display the report every 0.5 seconds */
1161 cur_time = av_gettime();
1162 if (last_time == -1) {
1163 last_time = cur_time;
1166 if ((cur_time - last_time) < 500000)
1168 last_time = cur_time;
1172 oc = output_files[0];
1174 total_size = url_fsize(oc->pb);
1175 if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1176 total_size= url_ftell(oc->pb);
1181 for(i=0;i<nb_ostreams;i++) {
1183 enc = ost->st->codec;
1184 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1185 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1186 !ost->st->stream_copy ?
1187 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1189 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1190 float t = (av_gettime()-timer_start) / 1000000.0;
1192 frame_number = ost->frame_number;
1193 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1194 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1195 !ost->st->stream_copy ?
1196 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1198 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1201 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1202 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1205 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1207 if (enc->flags&CODEC_FLAG_PSNR){
1209 double error, error_sum=0;
1210 double scale, scale_sum=0;
1211 char type[3]= {'Y','U','V'};
1212 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1215 error= enc->error[j];
1216 scale= enc->width*enc->height*255.0*255.0*frame_number;
1218 error= enc->coded_frame->error[j];
1219 scale= enc->width*enc->height*255.0*255.0;
1224 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1226 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1230 /* compute min output value */
1231 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1232 if ((pts < ti1) && (pts > 0))
1238 if (verbose || is_last_report) {
1239 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1241 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1242 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1243 (double)total_size / 1024, ti1, bitrate);
1245 if (nb_frames_dup || nb_frames_drop)
1246 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1247 nb_frames_dup, nb_frames_drop);
1250 fprintf(stderr, "%s \r", buf);
1255 if (is_last_report && verbose >= 0){
1256 int64_t raw= audio_size + video_size + extra_size;
1257 fprintf(stderr, "\n");
1258 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1262 100.0*(total_size - raw)/raw
1267 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1268 static int output_packet(AVInputStream *ist, int ist_index,
1269 AVOutputStream **ost_table, int nb_ostreams,
1270 const AVPacket *pkt)
1272 AVFormatContext *os;
1273 AVOutputStream *ost;
1277 void *buffer_to_free;
1278 static unsigned int samples_size= 0;
1279 AVSubtitle subtitle, *subtitle_to_free;
1282 int bps = av_get_bits_per_sample_format(ist->st->codec->sample_fmt)>>3;
1284 if(ist->next_pts == AV_NOPTS_VALUE)
1285 ist->next_pts= ist->pts;
1289 av_init_packet(&avpkt);
1297 if(pkt->dts != AV_NOPTS_VALUE)
1298 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1300 //while we have more to decode or while the decoder did output something on EOF
1301 while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1302 uint8_t *data_buf, *decoded_data_buf;
1303 int data_size, decoded_data_size;
1305 ist->pts= ist->next_pts;
1307 if(avpkt.size && avpkt.size != pkt->size &&
1308 !(ist->st->codec->codec->capabilities & CODEC_CAP_SUBFRAMES) && verbose>0)
1309 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1311 /* decode the packet if needed */
1312 decoded_data_buf = NULL; /* fail safe */
1313 decoded_data_size= 0;
1314 data_buf = avpkt.data;
1315 data_size = avpkt.size;
1316 subtitle_to_free = NULL;
1317 if (ist->decoding_needed) {
1318 switch(ist->st->codec->codec_type) {
1319 case CODEC_TYPE_AUDIO:{
1320 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1321 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1323 samples= av_malloc(samples_size);
1325 decoded_data_size= samples_size;
1326 /* XXX: could avoid copy if PCM 16 bits with same
1327 endianness as CPU */
1328 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1335 /* Some bug in mpeg audio decoder gives */
1336 /* decoded_data_size < 0, it seems they are overflows */
1337 if (decoded_data_size <= 0) {
1338 /* no audio frame */
1341 decoded_data_buf = (uint8_t *)samples;
1342 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1343 (ist->st->codec->sample_rate * ist->st->codec->channels);
1345 case CODEC_TYPE_VIDEO:
1346 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1347 /* XXX: allocate picture correctly */
1348 avcodec_get_frame_defaults(&picture);
1350 ret = avcodec_decode_video2(ist->st->codec,
1351 &picture, &got_picture, &avpkt);
1352 ist->st->quality= picture.quality;
1356 /* no picture yet */
1357 goto discard_packet;
1359 if (ist->st->codec->time_base.num != 0) {
1360 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1361 ist->next_pts += ((int64_t)AV_TIME_BASE *
1362 ist->st->codec->time_base.num * ticks) /
1363 ist->st->codec->time_base.den;
1367 case CODEC_TYPE_SUBTITLE:
1368 ret = avcodec_decode_subtitle2(ist->st->codec,
1369 &subtitle, &got_subtitle, &avpkt);
1372 if (!got_subtitle) {
1373 goto discard_packet;
1375 subtitle_to_free = &subtitle;
1382 switch(ist->st->codec->codec_type) {
1383 case CODEC_TYPE_AUDIO:
1384 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1385 ist->st->codec->sample_rate;
1387 case CODEC_TYPE_VIDEO:
1388 if (ist->st->codec->time_base.num != 0) {
1389 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1390 ist->next_pts += ((int64_t)AV_TIME_BASE *
1391 ist->st->codec->time_base.num * ticks) /
1392 ist->st->codec->time_base.den;
1400 buffer_to_free = NULL;
1401 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1402 pre_process_video_frame(ist, (AVPicture *)&picture,
1406 // preprocess audio (volume)
1407 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1408 if (audio_volume != 256) {
1411 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1412 int v = ((*volp) * audio_volume + 128) >> 8;
1413 if (v < -32768) v = -32768;
1414 if (v > 32767) v = 32767;
1420 /* frame rate emulation */
1422 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1423 int64_t now = av_gettime() - ist->start;
1428 /* if output time reached then transcode raw format,
1429 encode packets and output them */
1430 if (start_time == 0 || ist->pts >= start_time)
1431 for(i=0;i<nb_ostreams;i++) {
1435 if (ost->source_index == ist_index) {
1436 os = output_files[ost->file_index];
1438 /* set the input output pts pairs */
1439 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1441 if (ost->encoding_needed) {
1442 assert(ist->decoding_needed);
1443 switch(ost->st->codec->codec_type) {
1444 case CODEC_TYPE_AUDIO:
1445 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1447 case CODEC_TYPE_VIDEO:
1448 do_video_out(os, ost, ist, &picture, &frame_size);
1449 if (vstats_filename && frame_size)
1450 do_video_stats(os, ost, frame_size);
1452 case CODEC_TYPE_SUBTITLE:
1453 do_subtitle_out(os, ost, ist, &subtitle,
1460 AVFrame avframe; //FIXME/XXX remove this
1462 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1464 av_init_packet(&opkt);
1466 if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1469 /* no reencoding needed : output the packet directly */
1470 /* force the input stream PTS */
1472 avcodec_get_frame_defaults(&avframe);
1473 ost->st->codec->coded_frame= &avframe;
1474 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1476 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1477 audio_size += data_size;
1478 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1479 video_size += data_size;
1483 opkt.stream_index= ost->index;
1484 if(pkt->pts != AV_NOPTS_VALUE)
1485 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1487 opkt.pts= AV_NOPTS_VALUE;
1489 if (pkt->dts == AV_NOPTS_VALUE)
1490 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1492 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1493 opkt.dts -= ost_tb_start_time;
1495 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1496 opkt.flags= pkt->flags;
1498 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1499 if(ost->st->codec->codec_id != CODEC_ID_H264) {
1500 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1501 opkt.destruct= av_destruct_packet;
1503 opkt.data = data_buf;
1504 opkt.size = data_size;
1507 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1508 ost->st->codec->frame_number++;
1509 ost->frame_number++;
1510 av_free_packet(&opkt);
1514 av_free(buffer_to_free);
1515 /* XXX: allocate the subtitles in the codec ? */
1516 if (subtitle_to_free) {
1517 if (subtitle_to_free->rects != NULL) {
1518 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1519 av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1520 av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1521 av_freep(&subtitle_to_free->rects[i]);
1523 av_freep(&subtitle_to_free->rects);
1525 subtitle_to_free->num_rects = 0;
1526 subtitle_to_free = NULL;
1533 for(i=0;i<nb_ostreams;i++) {
1535 if (ost->source_index == ist_index) {
1536 AVCodecContext *enc= ost->st->codec;
1537 os = output_files[ost->file_index];
1539 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1541 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1544 if (ost->encoding_needed) {
1548 av_init_packet(&pkt);
1549 pkt.stream_index= ost->index;
1551 switch(ost->st->codec->codec_type) {
1552 case CODEC_TYPE_AUDIO:
1553 fifo_bytes = av_fifo_size(ost->fifo);
1555 /* encode any samples remaining in fifo */
1556 if (fifo_bytes > 0) {
1557 int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
1558 int fs_tmp = enc->frame_size;
1560 av_fifo_generic_read(ost->fifo, samples, fifo_bytes, NULL);
1561 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1562 enc->frame_size = fifo_bytes / (osize * enc->channels);
1564 int frame_bytes = enc->frame_size*osize*enc->channels;
1565 if (samples_size < frame_bytes)
1567 memset((uint8_t*)samples+fifo_bytes, 0, frame_bytes - fifo_bytes);
1570 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1571 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1572 ost->st->time_base.num, enc->sample_rate);
1573 enc->frame_size = fs_tmp;
1576 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1579 fprintf(stderr, "Audio encoding failed\n");
1583 pkt.flags |= PKT_FLAG_KEY;
1585 case CODEC_TYPE_VIDEO:
1586 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1588 fprintf(stderr, "Video encoding failed\n");
1592 if(enc->coded_frame && enc->coded_frame->key_frame)
1593 pkt.flags |= PKT_FLAG_KEY;
1594 if (ost->logfile && enc->stats_out) {
1595 fprintf(ost->logfile, "%s", enc->stats_out);
1604 pkt.data= bit_buffer;
1606 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1607 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1608 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1620 static void print_sdp(AVFormatContext **avc, int n)
1624 avf_sdp_create(avc, n, sdp, sizeof(sdp));
1625 printf("SDP:\n%s\n", sdp);
1629 static int stream_index_from_inputs(AVFormatContext **input_files,
1631 AVInputFile *file_table,
1632 AVInputStream **ist_table,
1633 enum CodecType type,
1637 for(z=0; z<nb_input_files; z++) {
1638 AVFormatContext *ic = input_files[z];
1639 for(p=0; p<ic->nb_programs; p++) {
1640 AVProgram *program = ic->programs[p];
1641 if(program->id != programid)
1643 for(q=0; q<program->nb_stream_indexes; q++) {
1644 int sidx = program->stream_index[q];
1645 int ris = file_table[z].ist_index + sidx;
1646 if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1656 * The following code is the main loop of the file converter
1658 static int av_encode(AVFormatContext **output_files,
1659 int nb_output_files,
1660 AVFormatContext **input_files,
1662 AVStreamMap *stream_maps, int nb_stream_maps)
1664 int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1665 AVFormatContext *is, *os;
1666 AVCodecContext *codec, *icodec;
1667 AVOutputStream *ost, **ost_table = NULL;
1668 AVInputStream *ist, **ist_table = NULL;
1669 AVInputFile *file_table;
1673 uint8_t no_packet[MAX_FILES]={0};
1674 int no_packet_count=0;
1676 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1680 /* input stream init */
1682 for(i=0;i<nb_input_files;i++) {
1683 is = input_files[i];
1684 file_table[i].ist_index = j;
1685 file_table[i].nb_streams = is->nb_streams;
1686 j += is->nb_streams;
1690 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1694 for(i=0;i<nb_istreams;i++) {
1695 ist = av_mallocz(sizeof(AVInputStream));
1701 for(i=0;i<nb_input_files;i++) {
1702 is = input_files[i];
1703 for(k=0;k<is->nb_streams;k++) {
1704 ist = ist_table[j++];
1705 ist->st = is->streams[k];
1706 ist->file_index = i;
1708 ist->discard = 1; /* the stream is discarded by default
1712 ist->start = av_gettime();
1717 /* output stream init */
1719 for(i=0;i<nb_output_files;i++) {
1720 os = output_files[i];
1721 if (!os->nb_streams) {
1722 dump_format(output_files[i], i, output_files[i]->filename, 1);
1723 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1726 nb_ostreams += os->nb_streams;
1728 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1729 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1733 /* Sanity check the mapping args -- do the input files & streams exist? */
1734 for(i=0;i<nb_stream_maps;i++) {
1735 int fi = stream_maps[i].file_index;
1736 int si = stream_maps[i].stream_index;
1738 if (fi < 0 || fi > nb_input_files - 1 ||
1739 si < 0 || si > file_table[fi].nb_streams - 1) {
1740 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1743 fi = stream_maps[i].sync_file_index;
1744 si = stream_maps[i].sync_stream_index;
1745 if (fi < 0 || fi > nb_input_files - 1 ||
1746 si < 0 || si > file_table[fi].nb_streams - 1) {
1747 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1752 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1755 for(i=0;i<nb_ostreams;i++) {
1756 ost = av_mallocz(sizeof(AVOutputStream));
1763 for(k=0;k<nb_output_files;k++) {
1764 os = output_files[k];
1765 for(i=0;i<os->nb_streams;i++,n++) {
1768 ost->file_index = k;
1770 ost->st = os->streams[i];
1771 if (nb_stream_maps > 0) {
1772 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1773 stream_maps[n].stream_index;
1775 /* Sanity check that the stream types match */
1776 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1777 int i= ost->file_index;
1778 dump_format(output_files[i], i, output_files[i]->filename, 1);
1779 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1780 stream_maps[n].file_index, stream_maps[n].stream_index,
1781 ost->file_index, ost->index);
1788 j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1790 ost->source_index = j;
1794 /* get corresponding input stream index : we select the first one with the right type */
1796 for(j=0;j<nb_istreams;j++) {
1799 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1800 ost->source_index = j;
1808 if(! opt_programid) {
1809 /* try again and reuse existing stream */
1810 for(j=0;j<nb_istreams;j++) {
1812 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1813 ost->source_index = j;
1819 int i= ost->file_index;
1820 dump_format(output_files[i], i, output_files[i]->filename, 1);
1821 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1822 ost->file_index, ost->index);
1827 ist = ist_table[ost->source_index];
1829 ost->sync_ist = (nb_stream_maps > 0) ?
1830 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
1831 stream_maps[n].sync_stream_index] : ist;
1835 /* for each output stream, we compute the right encoding parameters */
1836 for(i=0;i<nb_ostreams;i++) {
1837 AVMetadataTag *lang;
1839 os = output_files[ost->file_index];
1840 ist = ist_table[ost->source_index];
1842 codec = ost->st->codec;
1843 icodec = ist->st->codec;
1845 if ((lang=av_metadata_get(ist->st->metadata, "language", NULL, 0))
1846 && !av_metadata_get(ost->st->metadata, "language", NULL, 0))
1847 av_metadata_set(&ost->st->metadata, "language", lang->value);
1849 ost->st->disposition = ist->st->disposition;
1850 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1851 codec->chroma_sample_location = icodec->chroma_sample_location;
1853 if (ost->st->stream_copy) {
1854 /* if stream_copy is selected, no need to decode or encode */
1855 codec->codec_id = icodec->codec_id;
1856 codec->codec_type = icodec->codec_type;
1858 if(!codec->codec_tag){
1859 if( !os->oformat->codec_tag
1860 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
1861 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1862 codec->codec_tag = icodec->codec_tag;
1865 codec->bit_rate = icodec->bit_rate;
1866 codec->extradata= icodec->extradata;
1867 codec->extradata_size= icodec->extradata_size;
1868 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){
1869 codec->time_base = icodec->time_base;
1870 codec->time_base.num *= icodec->ticks_per_frame;
1872 codec->time_base = ist->st->time_base;
1873 switch(codec->codec_type) {
1874 case CODEC_TYPE_AUDIO:
1875 if(audio_volume != 256) {
1876 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1879 codec->channel_layout = icodec->channel_layout;
1880 codec->sample_rate = icodec->sample_rate;
1881 codec->channels = icodec->channels;
1882 codec->frame_size = icodec->frame_size;
1883 codec->block_align= icodec->block_align;
1884 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1885 codec->block_align= 0;
1886 if(codec->codec_id == CODEC_ID_AC3)
1887 codec->block_align= 0;
1889 case CODEC_TYPE_VIDEO:
1890 codec->pix_fmt = icodec->pix_fmt;
1891 codec->width = icodec->width;
1892 codec->height = icodec->height;
1893 codec->has_b_frames = icodec->has_b_frames;
1895 case CODEC_TYPE_SUBTITLE:
1896 codec->width = icodec->width;
1897 codec->height = icodec->height;
1903 switch(codec->codec_type) {
1904 case CODEC_TYPE_AUDIO:
1905 ost->fifo= av_fifo_alloc(1024);
1908 ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
1909 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1910 icodec->request_channels = codec->channels;
1911 ist->decoding_needed = 1;
1912 ost->encoding_needed = 1;
1914 case CODEC_TYPE_VIDEO:
1915 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
1916 fprintf(stderr, "Video pixel format is unknown, stream cannot be decoded\n");
1919 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1920 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1921 ost->video_resample = ((codec->width != icodec->width -
1922 (frame_leftBand + frame_rightBand) +
1923 (frame_padleft + frame_padright)) ||
1924 (codec->height != icodec->height -
1925 (frame_topBand + frame_bottomBand) +
1926 (frame_padtop + frame_padbottom)) ||
1927 (codec->pix_fmt != icodec->pix_fmt));
1928 if (ost->video_crop) {
1929 ost->topBand = ost->original_topBand = frame_topBand;
1930 ost->bottomBand = ost->original_bottomBand = frame_bottomBand;
1931 ost->leftBand = ost->original_leftBand = frame_leftBand;
1932 ost->rightBand = ost->original_rightBand = frame_rightBand;
1934 if (ost->video_pad) {
1935 ost->padtop = frame_padtop;
1936 ost->padleft = frame_padleft;
1937 ost->padbottom = frame_padbottom;
1938 ost->padright = frame_padright;
1939 if (!ost->video_resample) {
1940 avcodec_get_frame_defaults(&ost->pict_tmp);
1941 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1942 codec->width, codec->height))
1946 if (ost->video_resample) {
1947 avcodec_get_frame_defaults(&ost->pict_tmp);
1948 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1949 codec->width, codec->height)) {
1950 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1953 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1954 ost->img_resample_ctx = sws_getContext(
1955 icodec->width - (frame_leftBand + frame_rightBand),
1956 icodec->height - (frame_topBand + frame_bottomBand),
1958 codec->width - (frame_padleft + frame_padright),
1959 codec->height - (frame_padtop + frame_padbottom),
1961 sws_flags, NULL, NULL, NULL);
1962 if (ost->img_resample_ctx == NULL) {
1963 fprintf(stderr, "Cannot get resampling context\n");
1967 ost->original_height = icodec->height;
1968 ost->original_width = icodec->width;
1970 codec->bits_per_raw_sample= 0;
1972 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1973 ost->resample_width = icodec->width - (frame_leftBand + frame_rightBand);
1974 ost->resample_pix_fmt= icodec->pix_fmt;
1975 ost->encoding_needed = 1;
1976 ist->decoding_needed = 1;
1978 case CODEC_TYPE_SUBTITLE:
1979 ost->encoding_needed = 1;
1980 ist->decoding_needed = 1;
1987 if (ost->encoding_needed &&
1988 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1989 char logfilename[1024];
1994 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1995 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
1997 if (codec->flags & CODEC_FLAG_PASS1) {
1998 f = fopen(logfilename, "w");
2000 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2005 /* read the log file */
2006 f = fopen(logfilename, "r");
2008 fprintf(stderr, "Cannot read log file '%s' for pass-2 encoding: %s\n", logfilename, strerror(errno));
2011 fseek(f, 0, SEEK_END);
2013 fseek(f, 0, SEEK_SET);
2014 logbuffer = av_malloc(size + 1);
2016 fprintf(stderr, "Could not allocate log buffer\n");
2019 size = fread(logbuffer, 1, size, f);
2021 logbuffer[size] = '\0';
2022 codec->stats_in = logbuffer;
2026 if(codec->codec_type == CODEC_TYPE_VIDEO){
2027 int size= codec->width * codec->height;
2028 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2033 bit_buffer = av_malloc(bit_buffer_size);
2035 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2037 ret = AVERROR(ENOMEM);
2041 /* open each encoder */
2042 for(i=0;i<nb_ostreams;i++) {
2044 if (ost->encoding_needed) {
2045 AVCodec *codec = output_codecs[i];
2047 codec = avcodec_find_encoder(ost->st->codec->codec_id);
2049 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2050 ost->st->codec->codec_id, ost->file_index, ost->index);
2051 ret = AVERROR(EINVAL);
2054 if (avcodec_open(ost->st->codec, codec) < 0) {
2055 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2056 ost->file_index, ost->index);
2057 ret = AVERROR(EINVAL);
2060 extra_size += ost->st->codec->extradata_size;
2064 /* open each decoder */
2065 for(i=0;i<nb_istreams;i++) {
2067 if (ist->decoding_needed) {
2068 AVCodec *codec = input_codecs[i];
2070 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2072 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2073 ist->st->codec->codec_id, ist->file_index, ist->index);
2074 ret = AVERROR(EINVAL);
2077 if (avcodec_open(ist->st->codec, codec) < 0) {
2078 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2079 ist->file_index, ist->index);
2080 ret = AVERROR(EINVAL);
2083 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
2084 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2089 for(i=0;i<nb_istreams;i++) {
2092 ist->next_pts = AV_NOPTS_VALUE;
2096 /* set meta data information from input file if required */
2097 for (i=0;i<nb_meta_data_maps;i++) {
2098 AVFormatContext *out_file;
2099 AVFormatContext *in_file;
2100 AVMetadataTag *mtag;
2102 int out_file_index = meta_data_maps[i].out_file;
2103 int in_file_index = meta_data_maps[i].in_file;
2104 if (out_file_index < 0 || out_file_index >= nb_output_files) {
2105 snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
2106 out_file_index, out_file_index, in_file_index);
2107 ret = AVERROR(EINVAL);
2110 if (in_file_index < 0 || in_file_index >= nb_input_files) {
2111 snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
2112 in_file_index, out_file_index, in_file_index);
2113 ret = AVERROR(EINVAL);
2117 out_file = output_files[out_file_index];
2118 in_file = input_files[in_file_index];
2122 while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2123 av_metadata_set(&out_file->metadata, mtag->key, mtag->value);
2124 av_metadata_conv(out_file, out_file->oformat->metadata_conv,
2125 in_file->iformat->metadata_conv);
2128 /* open files and write file headers */
2129 for(i=0;i<nb_output_files;i++) {
2130 os = output_files[i];
2131 if (av_write_header(os) < 0) {
2132 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2133 ret = AVERROR(EINVAL);
2136 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2142 /* dump the file output parameters - cannot be done before in case
2144 for(i=0;i<nb_output_files;i++) {
2145 dump_format(output_files[i], i, output_files[i]->filename, 1);
2148 /* dump the stream mapping */
2150 fprintf(stderr, "Stream mapping:\n");
2151 for(i=0;i<nb_ostreams;i++) {
2153 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2154 ist_table[ost->source_index]->file_index,
2155 ist_table[ost->source_index]->index,
2158 if (ost->sync_ist != ist_table[ost->source_index])
2159 fprintf(stderr, " [sync #%d.%d]",
2160 ost->sync_ist->file_index,
2161 ost->sync_ist->index);
2162 fprintf(stderr, "\n");
2167 fprintf(stderr, "%s\n", error);
2172 print_sdp(output_files, nb_output_files);
2175 if (!using_stdin && verbose >= 0) {
2176 fprintf(stderr, "Press [q] to stop encoding\n");
2177 url_set_interrupt_cb(decode_interrupt_cb);
2181 timer_start = av_gettime();
2183 for(; received_sigterm == 0;) {
2184 int file_index, ist_index;
2192 /* if 'q' pressed, exits */
2196 /* read_key() returns 0 on EOF */
2202 /* select the stream that we must read now by looking at the
2203 smallest output pts */
2205 for(i=0;i<nb_ostreams;i++) {
2208 os = output_files[ost->file_index];
2209 ist = ist_table[ost->source_index];
2210 if(no_packet[ist->file_index])
2212 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2213 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2215 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2216 ipts = (double)ist->pts;
2217 if (!file_table[ist->file_index].eof_reached){
2218 if(ipts < ipts_min) {
2220 if(input_sync ) file_index = ist->file_index;
2222 if(opts < opts_min) {
2224 if(!input_sync) file_index = ist->file_index;
2227 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2232 /* if none, if is finished */
2233 if (file_index < 0) {
2234 if(no_packet_count){
2236 memset(no_packet, 0, sizeof(no_packet));
2243 /* finish if recording time exhausted */
2244 if (opts_min >= (recording_time / 1000000.0))
2247 /* finish if limit size exhausted */
2248 if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2251 /* read a frame from it and output it in the fifo */
2252 is = input_files[file_index];
2253 ret= av_read_frame(is, &pkt);
2254 if(ret == AVERROR(EAGAIN)){
2255 no_packet[file_index]=1;
2260 file_table[file_index].eof_reached = 1;
2268 memset(no_packet, 0, sizeof(no_packet));
2271 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2273 /* the following test is needed in case new streams appear
2274 dynamically in stream : we ignore them */
2275 if (pkt.stream_index >= file_table[file_index].nb_streams)
2276 goto discard_packet;
2277 ist_index = file_table[file_index].ist_index + pkt.stream_index;
2278 ist = ist_table[ist_index];
2280 goto discard_packet;
2282 if (pkt.dts != AV_NOPTS_VALUE)
2283 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2284 if (pkt.pts != AV_NOPTS_VALUE)
2285 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2287 if(input_files_ts_scale[file_index][pkt.stream_index]){
2288 if(pkt.pts != AV_NOPTS_VALUE)
2289 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2290 if(pkt.dts != AV_NOPTS_VALUE)
2291 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2294 // 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);
2295 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2296 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2297 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2298 int64_t delta= pkt_dts - ist->next_pts;
2299 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2300 input_files_ts_offset[ist->file_index]-= delta;
2302 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2303 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2304 if(pkt.pts != AV_NOPTS_VALUE)
2305 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2309 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2310 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2313 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2314 ist->file_index, ist->index);
2317 av_free_packet(&pkt);
2322 av_free_packet(&pkt);
2324 /* dump report by using the output first video and audio streams */
2325 print_report(output_files, ost_table, nb_ostreams, 0);
2328 /* at the end of stream, we must flush the decoder buffers */
2329 for(i=0;i<nb_istreams;i++) {
2331 if (ist->decoding_needed) {
2332 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2338 /* write the trailer if needed and close file */
2339 for(i=0;i<nb_output_files;i++) {
2340 os = output_files[i];
2341 av_write_trailer(os);
2344 /* dump report by using the first video and audio streams */
2345 print_report(output_files, ost_table, nb_ostreams, 1);
2347 /* close each encoder */
2348 for(i=0;i<nb_ostreams;i++) {
2350 if (ost->encoding_needed) {
2351 av_freep(&ost->st->codec->stats_in);
2352 avcodec_close(ost->st->codec);
2356 /* close each decoder */
2357 for(i=0;i<nb_istreams;i++) {
2359 if (ist->decoding_needed) {
2360 avcodec_close(ist->st->codec);
2368 av_freep(&bit_buffer);
2369 av_free(file_table);
2372 for(i=0;i<nb_istreams;i++) {
2379 for(i=0;i<nb_ostreams;i++) {
2383 fclose(ost->logfile);
2384 ost->logfile = NULL;
2386 av_fifo_free(ost->fifo); /* works even if fifo is not
2387 initialized but set to zero */
2388 av_free(ost->pict_tmp.data[0]);
2389 if (ost->video_resample)
2390 sws_freeContext(ost->img_resample_ctx);
2392 audio_resample_close(ost->resample);
2393 if (ost->reformat_ctx)
2394 av_audio_convert_free(ost->reformat_ctx);
2403 static void opt_format(const char *arg)
2405 /* compatibility stuff for pgmyuv */
2406 if (!strcmp(arg, "pgmyuv")) {
2407 pgmyuv_compatibility_hack=1;
2408 // opt_image_format(arg);
2410 fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2413 last_asked_format = arg;
2416 static void opt_video_rc_override_string(const char *arg)
2418 video_rc_override_string = arg;
2421 static int opt_me_threshold(const char *opt, const char *arg)
2423 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2427 static int opt_verbose(const char *opt, const char *arg)
2429 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2433 static int opt_frame_rate(const char *opt, const char *arg)
2435 if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2436 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2442 static int opt_bitrate(const char *opt, const char *arg)
2444 int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2446 opt_default(opt, arg);
2448 if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2449 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2454 static void opt_frame_crop_top(const char *arg)
2456 frame_topBand = atoi(arg);
2457 if (frame_topBand < 0) {
2458 fprintf(stderr, "Incorrect top crop size\n");
2461 if ((frame_topBand) >= frame_height){
2462 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2465 frame_height -= frame_topBand;
2468 static void opt_frame_crop_bottom(const char *arg)
2470 frame_bottomBand = atoi(arg);
2471 if (frame_bottomBand < 0) {
2472 fprintf(stderr, "Incorrect bottom crop size\n");
2475 if ((frame_bottomBand) >= frame_height){
2476 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2479 frame_height -= frame_bottomBand;
2482 static void opt_frame_crop_left(const char *arg)
2484 frame_leftBand = atoi(arg);
2485 if (frame_leftBand < 0) {
2486 fprintf(stderr, "Incorrect left crop size\n");
2489 if ((frame_leftBand) >= frame_width){
2490 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2493 frame_width -= frame_leftBand;
2496 static void opt_frame_crop_right(const char *arg)
2498 frame_rightBand = atoi(arg);
2499 if (frame_rightBand < 0) {
2500 fprintf(stderr, "Incorrect right crop size\n");
2503 if ((frame_rightBand) >= frame_width){
2504 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2507 frame_width -= frame_rightBand;
2510 static void opt_frame_size(const char *arg)
2512 if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2513 fprintf(stderr, "Incorrect frame size\n");
2518 static void opt_pad_color(const char *arg) {
2519 /* Input is expected to be six hex digits similar to
2520 how colors are expressed in html tags (but without the #) */
2521 int rgb = strtol(arg, NULL, 16);
2525 g = ((rgb >> 8) & 255);
2528 padcolor[0] = RGB_TO_Y(r,g,b);
2529 padcolor[1] = RGB_TO_U(r,g,b,0);
2530 padcolor[2] = RGB_TO_V(r,g,b,0);
2533 static void opt_frame_pad_top(const char *arg)
2535 frame_padtop = atoi(arg);
2536 if (frame_padtop < 0) {
2537 fprintf(stderr, "Incorrect top pad size\n");
2542 static void opt_frame_pad_bottom(const char *arg)
2544 frame_padbottom = atoi(arg);
2545 if (frame_padbottom < 0) {
2546 fprintf(stderr, "Incorrect bottom pad size\n");
2552 static void opt_frame_pad_left(const char *arg)
2554 frame_padleft = atoi(arg);
2555 if (frame_padleft < 0) {
2556 fprintf(stderr, "Incorrect left pad size\n");
2562 static void opt_frame_pad_right(const char *arg)
2564 frame_padright = atoi(arg);
2565 if (frame_padright < 0) {
2566 fprintf(stderr, "Incorrect right pad size\n");
2571 static void opt_frame_pix_fmt(const char *arg)
2573 if (strcmp(arg, "list")) {
2574 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2575 if (frame_pix_fmt == PIX_FMT_NONE) {
2576 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2580 list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2585 static void opt_frame_aspect_ratio(const char *arg)
2592 p = strchr(arg, ':');
2594 x = strtol(arg, &end, 10);
2596 y = strtol(end+1, &end, 10);
2598 ar = (double)x / (double)y;
2600 ar = strtod(arg, NULL);
2603 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2606 frame_aspect_ratio = ar;
2609 static int opt_metadata(const char *opt, const char *arg)
2611 char *mid= strchr(arg, '=');
2614 fprintf(stderr, "Missing =\n");
2620 metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2621 metadata[metadata_count-1].key = av_strdup(arg);
2622 metadata[metadata_count-1].value= av_strdup(mid);
2627 static void opt_qscale(const char *arg)
2629 video_qscale = atof(arg);
2630 if (video_qscale <= 0 ||
2631 video_qscale > 255) {
2632 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2637 static void opt_top_field_first(const char *arg)
2639 top_field_first= atoi(arg);
2642 static int opt_thread_count(const char *opt, const char *arg)
2644 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2647 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2652 static void opt_audio_sample_fmt(const char *arg)
2654 if (strcmp(arg, "list"))
2655 audio_sample_fmt = avcodec_get_sample_fmt(arg);
2657 list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2662 static int opt_audio_rate(const char *opt, const char *arg)
2664 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2668 static int opt_audio_channels(const char *opt, const char *arg)
2670 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2674 static void opt_video_channel(const char *arg)
2676 video_channel = strtol(arg, NULL, 0);
2679 static void opt_video_standard(const char *arg)
2681 video_standard = av_strdup(arg);
2684 static void opt_codec(int *pstream_copy, char **pcodec_name,
2685 int codec_type, const char *arg)
2687 av_freep(pcodec_name);
2688 if (!strcmp(arg, "copy")) {
2691 *pcodec_name = av_strdup(arg);
2695 static void opt_audio_codec(const char *arg)
2697 opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2700 static void opt_audio_tag(const char *arg)
2703 audio_codec_tag= strtol(arg, &tail, 0);
2706 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2709 static void opt_video_tag(const char *arg)
2712 video_codec_tag= strtol(arg, &tail, 0);
2715 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2718 static void opt_video_codec(const char *arg)
2720 opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2723 static void opt_subtitle_codec(const char *arg)
2725 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2728 static void opt_subtitle_tag(const char *arg)
2731 subtitle_codec_tag= strtol(arg, &tail, 0);
2734 subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2737 static void opt_map(const char *arg)
2742 m = &stream_maps[nb_stream_maps++];
2744 m->file_index = strtol(arg, &p, 0);
2748 m->stream_index = strtol(p, &p, 0);
2751 m->sync_file_index = strtol(p, &p, 0);
2754 m->sync_stream_index = strtol(p, &p, 0);
2756 m->sync_file_index = m->file_index;
2757 m->sync_stream_index = m->stream_index;
2761 static void opt_map_meta_data(const char *arg)
2766 m = &meta_data_maps[nb_meta_data_maps++];
2768 m->out_file = strtol(arg, &p, 0);
2772 m->in_file = strtol(p, &p, 0);
2775 static void opt_input_ts_scale(const char *arg)
2777 unsigned int stream;
2781 stream = strtol(arg, &p, 0);
2784 scale= strtod(p, &p);
2786 if(stream >= MAX_STREAMS)
2789 input_files_ts_scale[nb_input_files][stream]= scale;
2792 static int opt_recording_time(const char *opt, const char *arg)
2794 recording_time = parse_time_or_die(opt, arg, 1);
2798 static int opt_start_time(const char *opt, const char *arg)
2800 start_time = parse_time_or_die(opt, arg, 1);
2804 static int opt_rec_timestamp(const char *opt, const char *arg)
2806 rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2810 static int opt_input_ts_offset(const char *opt, const char *arg)
2812 input_ts_offset = parse_time_or_die(opt, arg, 1);
2816 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2818 const char *codec_string = encoder ? "encoder" : "decoder";
2822 return CODEC_ID_NONE;
2824 avcodec_find_encoder_by_name(name) :
2825 avcodec_find_decoder_by_name(name);
2827 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2830 if(codec->type != type) {
2831 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2837 static void opt_input_file(const char *filename)
2839 AVFormatContext *ic;
2840 AVFormatParameters params, *ap = ¶ms;
2841 AVInputFormat *file_iformat = NULL;
2842 int err, i, ret, rfps, rfps_base;
2845 if (last_asked_format) {
2846 file_iformat = av_find_input_format(last_asked_format);
2847 last_asked_format = NULL;
2850 if (!strcmp(filename, "-"))
2853 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2854 !strcmp(filename, "/dev/stdin");
2856 /* get default parameters from command line */
2857 ic = avformat_alloc_context();
2859 print_error(filename, AVERROR(ENOMEM));
2863 memset(ap, 0, sizeof(*ap));
2864 ap->prealloced_context = 1;
2865 ap->sample_rate = audio_sample_rate;
2866 ap->channels = audio_channels;
2867 ap->time_base.den = frame_rate.num;
2868 ap->time_base.num = frame_rate.den;
2869 ap->width = frame_width + frame_padleft + frame_padright;
2870 ap->height = frame_height + frame_padtop + frame_padbottom;
2871 ap->pix_fmt = frame_pix_fmt;
2872 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2873 ap->channel = video_channel;
2874 ap->standard = video_standard;
2875 ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2876 ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2877 if(pgmyuv_compatibility_hack)
2878 ap->video_codec_id= CODEC_ID_PGMYUV;
2880 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2882 ic->video_codec_id = find_codec_or_die(video_codec_name , CODEC_TYPE_VIDEO , 0);
2883 ic->audio_codec_id = find_codec_or_die(audio_codec_name , CODEC_TYPE_AUDIO , 0);
2884 ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2885 ic->flags |= AVFMT_FLAG_NONBLOCK;
2887 /* open the input file with generic libav function */
2888 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2890 print_error(filename, err);
2895 for(i=0; i<ic->nb_programs; i++)
2896 if(ic->programs[i]->id != opt_programid)
2897 ic->programs[i]->discard = AVDISCARD_ALL;
2900 ic->loop_input = loop_input;
2902 /* If not enough info to get the stream parameters, we decode the
2903 first frames to get it. (used in mpeg case for example) */
2904 ret = av_find_stream_info(ic);
2905 if (ret < 0 && verbose >= 0) {
2906 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2910 timestamp = start_time;
2911 /* add the stream start time */
2912 if (ic->start_time != AV_NOPTS_VALUE)
2913 timestamp += ic->start_time;
2915 /* if seeking requested, we execute it */
2916 if (start_time != 0) {
2917 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2919 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2920 filename, (double)timestamp / AV_TIME_BASE);
2922 /* reset seek info */
2926 /* update the current parameters so that they match the one of the input stream */
2927 for(i=0;i<ic->nb_streams;i++) {
2928 AVStream *st = ic->streams[i];
2929 AVCodecContext *enc = st->codec;
2931 avcodec_thread_init(enc, thread_count);
2932 switch(enc->codec_type) {
2933 case CODEC_TYPE_AUDIO:
2934 set_context_opts(enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2935 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2936 channel_layout = enc->channel_layout;
2937 audio_channels = enc->channels;
2938 audio_sample_rate = enc->sample_rate;
2939 audio_sample_fmt = enc->sample_fmt;
2940 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
2942 st->discard= AVDISCARD_ALL;
2944 case CODEC_TYPE_VIDEO:
2945 set_context_opts(enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2946 frame_height = enc->height;
2947 frame_width = enc->width;
2948 if(ic->streams[i]->sample_aspect_ratio.num)
2949 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
2951 frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
2952 frame_aspect_ratio *= (float) enc->width / enc->height;
2953 frame_pix_fmt = enc->pix_fmt;
2954 rfps = ic->streams[i]->r_frame_rate.num;
2955 rfps_base = ic->streams[i]->r_frame_rate.den;
2957 enc->flags |= CODEC_FLAG_EMU_EDGE;
2958 frame_height >>= enc->lowres;
2959 frame_width >>= enc->lowres;
2962 enc->debug |= FF_DEBUG_MV;
2964 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2967 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2968 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2970 (float)rfps / rfps_base, rfps, rfps_base);
2972 /* update the current frame rate to match the stream frame rate */
2973 frame_rate.num = rfps;
2974 frame_rate.den = rfps_base;
2976 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2978 st->discard= AVDISCARD_ALL;
2979 else if(video_discard)
2980 st->discard= video_discard;
2982 case CODEC_TYPE_DATA:
2984 case CODEC_TYPE_SUBTITLE:
2985 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
2986 if(subtitle_disable)
2987 st->discard = AVDISCARD_ALL;
2989 case CODEC_TYPE_ATTACHMENT:
2990 case CODEC_TYPE_UNKNOWN:
2998 input_files[nb_input_files] = ic;
2999 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3000 /* dump the file content */
3002 dump_format(ic, nb_input_files, filename, 0);
3008 av_freep(&video_codec_name);
3009 av_freep(&audio_codec_name);
3010 av_freep(&subtitle_codec_name);
3013 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3014 int *has_subtitle_ptr)
3016 int has_video, has_audio, has_subtitle, i, j;
3017 AVFormatContext *ic;
3022 for(j=0;j<nb_input_files;j++) {
3023 ic = input_files[j];
3024 for(i=0;i<ic->nb_streams;i++) {
3025 AVCodecContext *enc = ic->streams[i]->codec;
3026 switch(enc->codec_type) {
3027 case CODEC_TYPE_AUDIO:
3030 case CODEC_TYPE_VIDEO:
3033 case CODEC_TYPE_SUBTITLE:
3036 case CODEC_TYPE_DATA:
3037 case CODEC_TYPE_ATTACHMENT:
3038 case CODEC_TYPE_UNKNOWN:
3045 *has_video_ptr = has_video;
3046 *has_audio_ptr = has_audio;
3047 *has_subtitle_ptr = has_subtitle;
3050 static void new_video_stream(AVFormatContext *oc)
3053 AVCodecContext *video_enc;
3054 enum CodecID codec_id;
3056 st = av_new_stream(oc, oc->nb_streams);
3058 fprintf(stderr, "Could not alloc stream\n");
3061 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
3062 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3063 video_bitstream_filters= NULL;
3066 avcodec_thread_init(st->codec, thread_count);
3068 video_enc = st->codec;
3071 video_enc->codec_tag= video_codec_tag;
3073 if( (video_global_header&1)
3074 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3075 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3076 avcodec_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3078 if(video_global_header&2){
3079 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3080 avcodec_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3083 if (video_stream_copy) {
3084 st->stream_copy = 1;
3085 video_enc->codec_type = CODEC_TYPE_VIDEO;
3086 video_enc->sample_aspect_ratio =
3087 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3092 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3094 if (video_codec_name) {
3095 codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3096 codec = avcodec_find_encoder_by_name(video_codec_name);
3097 output_codecs[nb_ocodecs] = codec;
3099 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3100 codec = avcodec_find_encoder(codec_id);
3103 video_enc->codec_id = codec_id;
3105 set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3107 if (codec && codec->supported_framerates && !force_fps)
3108 fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3109 video_enc->time_base.den = fps.num;
3110 video_enc->time_base.num = fps.den;
3112 video_enc->width = frame_width + frame_padright + frame_padleft;
3113 video_enc->height = frame_height + frame_padtop + frame_padbottom;
3114 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3115 video_enc->pix_fmt = frame_pix_fmt;
3116 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3118 if(codec && codec->pix_fmts){
3119 const enum PixelFormat *p= codec->pix_fmts;
3121 if(*p == video_enc->pix_fmt)
3125 video_enc->pix_fmt = codec->pix_fmts[0];
3129 video_enc->gop_size = 0;
3130 if (video_qscale || same_quality) {
3131 video_enc->flags |= CODEC_FLAG_QSCALE;
3132 video_enc->global_quality=
3133 st->quality = FF_QP2LAMBDA * video_qscale;
3137 video_enc->intra_matrix = intra_matrix;
3139 video_enc->inter_matrix = inter_matrix;
3141 p= video_rc_override_string;
3144 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3146 fprintf(stderr, "error parsing rc_override\n");
3149 video_enc->rc_override=
3150 av_realloc(video_enc->rc_override,
3151 sizeof(RcOverride)*(i+1));
3152 video_enc->rc_override[i].start_frame= start;
3153 video_enc->rc_override[i].end_frame = end;
3155 video_enc->rc_override[i].qscale= q;
3156 video_enc->rc_override[i].quality_factor= 1.0;
3159 video_enc->rc_override[i].qscale= 0;
3160 video_enc->rc_override[i].quality_factor= -q/100.0;
3165 video_enc->rc_override_count=i;
3166 if (!video_enc->rc_initial_buffer_occupancy)
3167 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3168 video_enc->me_threshold= me_threshold;
3169 video_enc->intra_dc_precision= intra_dc_precision - 8;
3172 video_enc->flags|= CODEC_FLAG_PSNR;
3177 video_enc->flags |= CODEC_FLAG_PASS1;
3179 video_enc->flags |= CODEC_FLAG_PASS2;
3184 if (video_language) {
3185 av_metadata_set(&st->metadata, "language", video_language);
3186 av_freep(&video_language);
3189 /* reset some key parameters */
3191 av_freep(&video_codec_name);
3192 video_stream_copy = 0;
3195 static void new_audio_stream(AVFormatContext *oc)
3198 AVCodecContext *audio_enc;
3199 enum CodecID codec_id;
3201 st = av_new_stream(oc, oc->nb_streams);
3203 fprintf(stderr, "Could not alloc stream\n");
3206 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3208 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3209 audio_bitstream_filters= NULL;
3212 avcodec_thread_init(st->codec, thread_count);
3214 audio_enc = st->codec;
3215 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3218 audio_enc->codec_tag= audio_codec_tag;
3220 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3221 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3222 avcodec_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3224 if (audio_stream_copy) {
3225 st->stream_copy = 1;
3226 audio_enc->channels = audio_channels;
3230 set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3232 if (audio_codec_name) {
3233 codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3234 codec = avcodec_find_encoder_by_name(audio_codec_name);
3235 output_codecs[nb_ocodecs] = codec;
3237 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3238 codec = avcodec_find_encoder(codec_id);
3240 audio_enc->codec_id = codec_id;
3242 if (audio_qscale > QSCALE_NONE) {
3243 audio_enc->flags |= CODEC_FLAG_QSCALE;
3244 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3246 audio_enc->channels = audio_channels;
3247 audio_enc->sample_fmt = audio_sample_fmt;
3248 audio_enc->channel_layout = channel_layout;
3249 if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3250 audio_enc->channel_layout = 0;
3252 if(codec && codec->sample_fmts){
3253 const enum SampleFormat *p= codec->sample_fmts;
3255 if(*p == audio_enc->sample_fmt)
3259 audio_enc->sample_fmt = codec->sample_fmts[0];
3263 audio_enc->sample_rate = audio_sample_rate;
3264 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3265 if (audio_language) {
3266 av_metadata_set(&st->metadata, "language", audio_language);
3267 av_freep(&audio_language);
3270 /* reset some key parameters */
3272 av_freep(&audio_codec_name);
3273 audio_stream_copy = 0;
3276 static void new_subtitle_stream(AVFormatContext *oc)
3279 AVCodecContext *subtitle_enc;
3281 st = av_new_stream(oc, oc->nb_streams);
3283 fprintf(stderr, "Could not alloc stream\n");
3286 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3288 bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3289 subtitle_bitstream_filters= NULL;
3291 subtitle_enc = st->codec;
3292 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3294 if(subtitle_codec_tag)
3295 subtitle_enc->codec_tag= subtitle_codec_tag;
3297 if (subtitle_stream_copy) {
3298 st->stream_copy = 1;
3300 set_context_opts(avcodec_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3301 subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3302 output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3306 if (subtitle_language) {
3307 av_metadata_set(&st->metadata, "language", subtitle_language);
3308 av_freep(&subtitle_language);
3311 subtitle_disable = 0;
3312 av_freep(&subtitle_codec_name);
3313 subtitle_stream_copy = 0;
3316 static void opt_new_audio_stream(void)
3318 AVFormatContext *oc;
3319 if (nb_output_files <= 0) {
3320 fprintf(stderr, "At least one output file must be specified\n");
3323 oc = output_files[nb_output_files - 1];
3324 new_audio_stream(oc);
3327 static void opt_new_video_stream(void)
3329 AVFormatContext *oc;
3330 if (nb_output_files <= 0) {
3331 fprintf(stderr, "At least one output file must be specified\n");
3334 oc = output_files[nb_output_files - 1];
3335 new_video_stream(oc);
3338 static void opt_new_subtitle_stream(void)
3340 AVFormatContext *oc;
3341 if (nb_output_files <= 0) {
3342 fprintf(stderr, "At least one output file must be specified\n");
3345 oc = output_files[nb_output_files - 1];
3346 new_subtitle_stream(oc);
3349 static void opt_output_file(const char *filename)
3351 AVFormatContext *oc;
3352 int use_video, use_audio, use_subtitle;
3353 int input_has_video, input_has_audio, input_has_subtitle;
3354 AVFormatParameters params, *ap = ¶ms;
3355 AVOutputFormat *file_oformat;
3357 if (!strcmp(filename, "-"))
3360 oc = avformat_alloc_context();
3362 print_error(filename, AVERROR(ENOMEM));
3366 if (last_asked_format) {
3367 file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3368 if (!file_oformat) {
3369 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3372 last_asked_format = NULL;
3374 file_oformat = av_guess_format(NULL, filename, NULL);
3375 if (!file_oformat) {
3376 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3382 oc->oformat = file_oformat;
3383 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3385 if (!strcmp(file_oformat->name, "ffm") &&
3386 av_strstart(filename, "http:", NULL)) {
3387 /* special case for files sent to ffserver: we get the stream
3388 parameters from ffserver */
3389 int err = read_ffserver_streams(oc, filename);
3391 print_error(filename, err);
3395 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3396 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3397 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3399 /* disable if no corresponding type found and at least one
3401 if (nb_input_files > 0) {
3402 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3403 &input_has_subtitle);
3404 if (!input_has_video)
3406 if (!input_has_audio)
3408 if (!input_has_subtitle)
3412 /* manual disable */
3413 if (audio_disable) {
3416 if (video_disable) {
3419 if (subtitle_disable) {
3424 new_video_stream(oc);
3428 new_audio_stream(oc);
3432 new_subtitle_stream(oc);
3435 oc->timestamp = rec_timestamp;
3437 for(; metadata_count>0; metadata_count--){
3438 av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3439 metadata[metadata_count-1].value);
3441 av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3444 output_files[nb_output_files++] = oc;
3446 /* check filename in case of an image number is expected */
3447 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3448 if (!av_filename_number_test(oc->filename)) {
3449 print_error(oc->filename, AVERROR_NUMEXPECTED);
3454 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3455 /* test if it already exists to avoid loosing precious files */
3456 if (!file_overwrite &&
3457 (strchr(filename, ':') == NULL ||
3458 filename[1] == ':' ||
3459 av_strstart(filename, "file:", NULL))) {
3460 if (url_exist(filename)) {
3462 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3464 if (!read_yesno()) {
3465 fprintf(stderr, "Not overwriting - exiting\n");
3470 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3477 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3478 fprintf(stderr, "Could not open '%s'\n", filename);
3483 memset(ap, 0, sizeof(*ap));
3484 if (av_set_parameters(oc, ap) < 0) {
3485 fprintf(stderr, "%s: Invalid encoding parameters\n",
3490 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3491 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3492 oc->loop_output = loop_output;
3493 oc->flags |= AVFMT_FLAG_NONBLOCK;
3495 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3498 /* same option as mencoder */
3499 static void opt_pass(const char *pass_str)
3502 pass = atoi(pass_str);
3503 if (pass != 1 && pass != 2) {
3504 fprintf(stderr, "pass number can be only 1 or 2\n");
3510 static int64_t getutime(void)
3513 struct rusage rusage;
3515 getrusage(RUSAGE_SELF, &rusage);
3516 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3517 #elif HAVE_GETPROCESSTIMES
3519 FILETIME c, e, k, u;
3520 proc = GetCurrentProcess();
3521 GetProcessTimes(proc, &c, &e, &k, &u);
3522 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3524 return av_gettime();
3528 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3531 const char *p = str;
3538 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3545 static void opt_inter_matrix(const char *arg)
3547 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3548 parse_matrix_coeffs(inter_matrix, arg);
3551 static void opt_intra_matrix(const char *arg)
3553 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3554 parse_matrix_coeffs(intra_matrix, arg);
3558 * Trivial log callback.
3559 * Only suitable for show_help and similar since it lacks prefix handling.
3561 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3563 vfprintf(stdout, fmt, vl);
3566 static void show_usage(void)
3568 printf("Hyper fast Audio and Video encoder\n");
3569 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3573 static void show_help(void)
3575 av_log_set_callback(log_callback_help);
3577 show_help_options(options, "Main options:\n",
3578 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3579 show_help_options(options, "\nAdvanced options:\n",
3580 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3582 show_help_options(options, "\nVideo options:\n",
3583 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3585 show_help_options(options, "\nAdvanced Video options:\n",
3586 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3587 OPT_VIDEO | OPT_EXPERT);
3588 show_help_options(options, "\nAudio options:\n",
3589 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3591 show_help_options(options, "\nAdvanced Audio options:\n",
3592 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3593 OPT_AUDIO | OPT_EXPERT);
3594 show_help_options(options, "\nSubtitle options:\n",
3595 OPT_SUBTITLE | OPT_GRAB,
3597 show_help_options(options, "\nAudio/Video grab options:\n",
3601 av_opt_show(avcodec_opts[0], NULL);
3603 av_opt_show(avformat_opts, NULL);
3605 av_opt_show(sws_opts, NULL);
3608 static void opt_target(const char *arg)
3610 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3611 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3613 if(!strncmp(arg, "pal-", 4)) {
3616 } else if(!strncmp(arg, "ntsc-", 5)) {
3619 } else if(!strncmp(arg, "film-", 5)) {
3624 /* Calculate FR via float to avoid int overflow */
3625 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3628 } else if((fr == 29970) || (fr == 23976)) {
3631 /* Try to determine PAL/NTSC by peeking in the input files */
3632 if(nb_input_files) {
3634 for(j = 0; j < nb_input_files; j++) {
3635 for(i = 0; i < input_files[j]->nb_streams; i++) {
3636 AVCodecContext *c = input_files[j]->streams[i]->codec;
3637 if(c->codec_type != CODEC_TYPE_VIDEO)
3639 fr = c->time_base.den * 1000 / c->time_base.num;
3643 } else if((fr == 29970) || (fr == 23976)) {
3653 if(verbose && norm != UNKNOWN)
3654 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3657 if(norm == UNKNOWN) {
3658 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3659 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3660 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3664 if(!strcmp(arg, "vcd")) {
3666 opt_video_codec("mpeg1video");
3667 opt_audio_codec("mp2");
3670 opt_frame_size(norm == PAL ? "352x288" : "352x240");
3671 opt_frame_rate(NULL, frame_rates[norm]);
3672 opt_default("g", norm == PAL ? "15" : "18");
3674 opt_default("b", "1150000");
3675 opt_default("maxrate", "1150000");
3676 opt_default("minrate", "1150000");
3677 opt_default("bufsize", "327680"); // 40*1024*8;
3679 opt_default("ab", "224000");
3680 audio_sample_rate = 44100;
3683 opt_default("packetsize", "2324");
3684 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3686 /* We have to offset the PTS, so that it is consistent with the SCR.
3687 SCR starts at 36000, but the first two packs contain only padding
3688 and the first pack from the other stream, respectively, may also have
3689 been written before.
3690 So the real data starts at SCR 36000+3*1200. */
3691 mux_preload= (36000+3*1200) / 90000.0; //0.44
3692 } else if(!strcmp(arg, "svcd")) {
3694 opt_video_codec("mpeg2video");
3695 opt_audio_codec("mp2");
3698 opt_frame_size(norm == PAL ? "480x576" : "480x480");
3699 opt_frame_rate(NULL, frame_rates[norm]);
3700 opt_default("g", norm == PAL ? "15" : "18");
3702 opt_default("b", "2040000");
3703 opt_default("maxrate", "2516000");
3704 opt_default("minrate", "0"); //1145000;
3705 opt_default("bufsize", "1835008"); //224*1024*8;
3706 opt_default("flags", "+scan_offset");
3709 opt_default("ab", "224000");
3710 audio_sample_rate = 44100;
3712 opt_default("packetsize", "2324");
3714 } else if(!strcmp(arg, "dvd")) {
3716 opt_video_codec("mpeg2video");
3717 opt_audio_codec("ac3");
3720 opt_frame_size(norm == PAL ? "720x576" : "720x480");
3721 opt_frame_rate(NULL, frame_rates[norm]);
3722 opt_default("g", norm == PAL ? "15" : "18");
3724 opt_default("b", "6000000");
3725 opt_default("maxrate", "9000000");
3726 opt_default("minrate", "0"); //1500000;
3727 opt_default("bufsize", "1835008"); //224*1024*8;
3729 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3730 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3732 opt_default("ab", "448000");
3733 audio_sample_rate = 48000;
3735 } else if(!strncmp(arg, "dv", 2)) {
3739 opt_frame_size(norm == PAL ? "720x576" : "720x480");
3740 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3741 (norm == PAL ? "yuv420p" : "yuv411p"));
3742 opt_frame_rate(NULL, frame_rates[norm]);
3744 audio_sample_rate = 48000;
3748 fprintf(stderr, "Unknown target: %s\n", arg);
3753 static void opt_vstats_file (const char *arg)
3755 av_free (vstats_filename);
3756 vstats_filename=av_strdup (arg);
3759 static void opt_vstats (void)
3762 time_t today2 = time(NULL);
3763 struct tm *today = localtime(&today2);
3765 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3767 opt_vstats_file(filename);
3770 static int opt_bsf(const char *opt, const char *arg)
3772 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3773 AVBitStreamFilterContext **bsfp;
3776 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3780 bsfp= *opt == 'v' ? &video_bitstream_filters :
3781 *opt == 'a' ? &audio_bitstream_filters :
3782 &subtitle_bitstream_filters;
3784 bsfp= &(*bsfp)->next;
3791 static int opt_preset(const char *opt, const char *arg)
3794 char filename[1000], tmp[1000], tmp2[1000], line[1000];
3796 const char *base[2]= { getenv("HOME"),
3801 for(i=!base[0]; i<2 && !f; i++){
3802 snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
3803 f= fopen(filename, "r");
3805 char *codec_name= *opt == 'v' ? video_codec_name :
3806 *opt == 'a' ? audio_codec_name :
3807 subtitle_codec_name;
3808 snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i], i ? "" : "/.ffmpeg", codec_name, arg);
3809 f= fopen(filename, "r");
3813 av_strlcpy(filename, arg, sizeof(filename));
3814 f= fopen(filename, "r");
3818 fprintf(stderr, "File for preset '%s' not found\n", arg);
3823 int e= fscanf(f, "%999[^\n]\n", line) - 1;
3824 if(line[0] == '#' && !e)
3826 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3828 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3831 if(!strcmp(tmp, "acodec")){
3832 opt_audio_codec(tmp2);
3833 }else if(!strcmp(tmp, "vcodec")){
3834 opt_video_codec(tmp2);
3835 }else if(!strcmp(tmp, "scodec")){
3836 opt_subtitle_codec(tmp2);
3837 }else if(opt_default(tmp, tmp2) < 0){
3838 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3848 static const OptionDef options[] = {
3850 #include "cmdutils_common_opts.h"
3851 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3852 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3853 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3854 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3855 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3856 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3857 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3858 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3859 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3860 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
3861 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_rec_timestamp}, "set the timestamp ('now' to set the current time)", "time" },
3862 { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
3863 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3864 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3865 "add timings for benchmarking" },
3866 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3867 "dump each input packet" },
3868 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3869 "when dumping packets, also dump the payload" },
3870 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3871 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3872 { "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)", "" },
3873 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
3874 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3875 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3876 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3877 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3878 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3879 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3880 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3881 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3882 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3883 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3884 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
3885 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
3888 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3889 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3890 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3891 { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3892 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3893 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3894 { "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" },
3895 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3896 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3897 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3898 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3899 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3900 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3901 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3902 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3903 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3904 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3905 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3906 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3907 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3908 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3909 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3910 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
3911 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3912 "use same video quality as source (implies VBR)" },
3913 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3914 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
3915 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3916 "deinterlace pictures" },
3917 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3918 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3919 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3920 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3921 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3922 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3923 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3924 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3925 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3926 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
3927 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3928 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
3931 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3932 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3933 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3934 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3935 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3936 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3937 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3938 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3939 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3940 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3941 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3942 { "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" },
3944 /* subtitle options */
3945 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3946 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3947 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3948 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3949 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
3952 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3953 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3954 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3957 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3958 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3960 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3961 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3962 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3964 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3965 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3966 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3967 { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
3969 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3973 int main(int argc, char **argv)
3978 avcodec_register_all();
3979 avdevice_register_all();
3983 if(isatty(STDIN_FILENO))
3984 url_set_interrupt_cb(decode_interrupt_cb);
3987 for(i=0; i<CODEC_TYPE_NB; i++){
3988 avcodec_opts[i]= avcodec_alloc_context2(i);
3990 avformat_opts = avformat_alloc_context();
3991 sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3996 parse_options(argc, argv, options, opt_output_file);
3998 if(nb_output_files <= 0 && nb_input_files == 0) {
4000 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4004 /* file converter / grab */
4005 if (nb_output_files <= 0) {
4006 fprintf(stderr, "At least one output file must be specified\n");
4010 if (nb_input_files == 0) {
4011 fprintf(stderr, "At least one input file must be specified\n");
4016 if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
4017 stream_maps, nb_stream_maps) < 0)
4019 ti = getutime() - ti;
4021 printf("bench: utime=%0.3fs\n", ti / 1000000.0);