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 int same_quality = 0;
138 static int do_deinterlace = 0;
139 static int top_field_first = -1;
140 static int me_threshold = 0;
141 static int intra_dc_precision = 8;
142 static int loop_input = 0;
143 static int loop_output = AVFMT_NOOUTPUTLOOP;
144 static int qp_hist = 0;
146 static int intra_only = 0;
147 static int audio_sample_rate = 44100;
148 static int64_t channel_layout = 0;
149 #define QSCALE_NONE -99999
150 static float audio_qscale = QSCALE_NONE;
151 static int audio_disable = 0;
152 static int audio_channels = 1;
153 static char *audio_codec_name = NULL;
154 static int audio_codec_tag = 0;
155 static char *audio_language = NULL;
157 static int subtitle_disable = 0;
158 static char *subtitle_codec_name = NULL;
159 static char *subtitle_language = NULL;
160 static int subtitle_codec_tag = 0;
162 static float mux_preload= 0.5;
163 static float mux_max_delay= 0.7;
165 static int64_t recording_time = INT64_MAX;
166 static int64_t start_time = 0;
167 static int64_t rec_timestamp = 0;
168 static int64_t input_ts_offset = 0;
169 static int file_overwrite = 0;
170 static int metadata_count;
171 static AVMetadataTag *metadata;
172 static int do_benchmark = 0;
173 static int do_hex_dump = 0;
174 static int do_pkt_dump = 0;
175 static int do_psnr = 0;
176 static int do_pass = 0;
177 static char *pass_logfilename_prefix = NULL;
178 static int audio_stream_copy = 0;
179 static int video_stream_copy = 0;
180 static int subtitle_stream_copy = 0;
181 static int video_sync_method= -1;
182 static int audio_sync_method= 0;
183 static float audio_drift_threshold= 0.1;
184 static int copy_ts= 0;
185 static int opt_shortest = 0;
186 static int video_global_header = 0;
187 static char *vstats_filename;
188 static FILE *vstats_file;
189 static int opt_programid = 0;
190 static int copy_initial_nonkeyframes = 0;
192 static int rate_emu = 0;
194 static int video_channel = 0;
195 static char *video_standard;
197 static int audio_volume = 256;
199 static int exit_on_error = 0;
200 static int using_stdin = 0;
201 static int verbose = 1;
202 static int thread_count= 1;
203 static int q_pressed = 0;
204 static int64_t video_size = 0;
205 static int64_t audio_size = 0;
206 static int64_t extra_size = 0;
207 static int nb_frames_dup = 0;
208 static int nb_frames_drop = 0;
209 static int input_sync;
210 static uint64_t limit_filesize = 0;
211 static int force_fps = 0;
213 static int pgmyuv_compatibility_hack=0;
214 static float dts_delta_threshold = 10;
216 static unsigned int sws_flags = SWS_BICUBIC;
218 static int64_t timer_start;
220 static uint8_t *audio_buf;
221 static uint8_t *audio_out;
222 unsigned int allocated_audio_out_size, allocated_audio_buf_size;
224 static short *samples;
226 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
227 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
228 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
229 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
231 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
233 struct AVInputStream;
235 typedef struct AVOutputStream {
236 int file_index; /* file index */
237 int index; /* stream index in the output file */
238 int source_index; /* AVInputStream index */
239 AVStream *st; /* stream in the output file */
240 int encoding_needed; /* true if encoding needed for this stream */
242 /* input pts and corresponding output pts
244 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
245 struct AVInputStream *sync_ist; /* input stream to sync against */
246 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
249 AVFrame pict_tmp; /* temporary image for resampling */
250 struct SwsContext *img_resample_ctx; /* for image resampling */
253 int resample_pix_fmt;
255 /* full frame size of first frame */
259 /* cropping area sizes */
266 /* cropping area of first frame */
267 int original_topBand;
268 int original_bottomBand;
269 int original_leftBand;
270 int original_rightBand;
272 /* padding area sizes */
281 ReSampleContext *resample; /* for audio resampling */
283 AVAudioConvert *reformat_ctx;
284 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
288 typedef struct AVInputStream {
292 int discard; /* true if stream data should be discarded */
293 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
294 int64_t sample_index; /* current sample */
296 int64_t start; /* time when read started */
297 int64_t next_pts; /* synthetic pts for cases where pkt.pts
299 int64_t pts; /* current pts */
300 int is_start; /* is 1 at the start and after a discontinuity */
303 typedef struct AVInputFile {
304 int eof_reached; /* true if eof reached */
305 int ist_index; /* index of first stream in ist_table */
306 int buffer_size; /* current total buffer size */
307 int nb_streams; /* nb streams we are aware of */
312 /* init terminal so that we can grab keys */
313 static struct termios oldtty;
316 static void term_exit(void)
319 tcsetattr (0, TCSANOW, &oldtty);
323 static volatile int received_sigterm = 0;
326 sigterm_handler(int sig)
328 received_sigterm = sig;
332 static void term_init(void)
340 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
341 |INLCR|IGNCR|ICRNL|IXON);
342 tty.c_oflag |= OPOST;
343 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
344 tty.c_cflag &= ~(CSIZE|PARENB);
349 tcsetattr (0, TCSANOW, &tty);
350 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
353 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
354 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
356 register a function to be called at normal program termination
359 #if CONFIG_BEOS_NETSERVER
360 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
364 /* read a key without blocking */
365 static int read_key(void)
370 #if !CONFIG_BEOS_NETSERVER
378 n = select(1, &rfds, NULL, NULL, &tv);
394 static int decode_interrupt_cb(void)
396 return q_pressed || (q_pressed = read_key() == 'q');
399 static int av_exit(int ret)
404 for(i=0;i<nb_output_files;i++) {
405 /* maybe av_close_output_file ??? */
406 AVFormatContext *s = output_files[i];
408 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
410 for(j=0;j<s->nb_streams;j++) {
411 av_metadata_free(&s->streams[j]->metadata);
412 av_free(s->streams[j]->codec);
413 av_free(s->streams[j]);
415 for(j=0;j<s->nb_programs;j++) {
416 av_metadata_free(&s->programs[j]->metadata);
418 for(j=0;j<s->nb_chapters;j++) {
419 av_metadata_free(&s->chapters[j]->metadata);
421 av_metadata_free(&s->metadata);
424 for(i=0;i<nb_input_files;i++)
425 av_close_input_file(input_files[i]);
427 av_free(intra_matrix);
428 av_free(inter_matrix);
432 av_free(vstats_filename);
436 av_free(video_codec_name);
437 av_free(audio_codec_name);
438 av_free(subtitle_codec_name);
440 av_free(video_standard);
442 #if CONFIG_POWERPC_PERF
443 void powerpc_display_perf_report(void);
444 powerpc_display_perf_report();
445 #endif /* CONFIG_POWERPC_PERF */
447 for (i=0;i<CODEC_TYPE_NB;i++)
448 av_free(avcodec_opts[i]);
449 av_free(avformat_opts);
453 allocated_audio_buf_size= allocated_audio_out_size= 0;
456 if (received_sigterm) {
458 "Received signal %d: terminating.\n",
459 (int) received_sigterm);
463 exit(ret); /* not all OS-es handle main() return value */
467 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
473 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
476 /* copy stream format */
477 s->nb_streams = ic->nb_streams;
478 for(i=0;i<ic->nb_streams;i++) {
481 // FIXME: a more elegant solution is needed
482 st = av_mallocz(sizeof(AVStream));
483 memcpy(st, ic->streams[i], sizeof(AVStream));
484 st->codec = avcodec_alloc_context();
486 print_error(filename, AVERROR(ENOMEM));
489 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
492 if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
494 else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
497 if(!st->codec->thread_count)
498 st->codec->thread_count = 1;
499 if(st->codec->thread_count>1)
500 avcodec_thread_init(st->codec, st->codec->thread_count);
502 if(st->codec->flags & CODEC_FLAG_BITEXACT)
507 s->timestamp = av_gettime();
509 av_close_input_file(ic);
514 get_sync_ipts(const AVOutputStream *ost)
516 const AVInputStream *ist = ost->sync_ist;
517 return (double)(ist->pts - start_time)/AV_TIME_BASE;
520 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
524 AVPacket new_pkt= *pkt;
525 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
526 &new_pkt.data, &new_pkt.size,
527 pkt->data, pkt->size,
528 pkt->flags & PKT_FLAG_KEY);
531 new_pkt.destruct= av_destruct_packet;
533 fprintf(stderr, "%s failed for stream %d, codec %s",
534 bsfc->filter->name, pkt->stream_index,
535 avctx->codec ? avctx->codec->name : "copy");
545 ret= av_interleaved_write_frame(s, pkt);
547 print_error("av_interleaved_write_frame()", ret);
552 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
554 static void do_audio_out(AVFormatContext *s,
557 unsigned char *buf, int size)
560 int64_t audio_out_size, audio_buf_size;
562 int size_out, frame_bytes, ret;
563 AVCodecContext *enc= ost->st->codec;
564 AVCodecContext *dec= ist->st->codec;
565 int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
566 int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
567 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
569 audio_buf_size= (size + isize*dec->channels - 1) / (isize*dec->channels);
570 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
571 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
572 audio_buf_size*= osize*enc->channels;
574 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
575 if(coded_bps > 8*osize)
576 audio_out_size= audio_out_size * coded_bps / (8*osize);
577 audio_out_size += FF_MIN_BUFFER_SIZE;
579 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
580 fprintf(stderr, "Buffer sizes too large\n");
584 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
585 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
586 if (!audio_buf || !audio_out){
587 fprintf(stderr, "Out of memory in do_audio_out\n");
591 if (enc->channels != dec->channels)
592 ost->audio_resample = 1;
594 if (ost->audio_resample && !ost->resample) {
595 if (dec->sample_fmt != SAMPLE_FMT_S16)
596 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
597 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
598 enc->sample_rate, dec->sample_rate,
599 enc->sample_fmt, dec->sample_fmt,
601 if (!ost->resample) {
602 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
603 dec->channels, dec->sample_rate,
604 enc->channels, enc->sample_rate);
609 #define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
610 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
611 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
612 if (ost->reformat_ctx)
613 av_audio_convert_free(ost->reformat_ctx);
614 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
615 dec->sample_fmt, 1, NULL, 0);
616 if (!ost->reformat_ctx) {
617 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
618 avcodec_get_sample_fmt_name(dec->sample_fmt),
619 avcodec_get_sample_fmt_name(enc->sample_fmt));
622 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
625 if(audio_sync_method){
626 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
627 - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2);
628 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
629 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
631 //FIXME resample delay
632 if(fabs(delta) > 50){
633 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
635 byte_delta= FFMAX(byte_delta, -size);
639 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
644 static uint8_t *input_tmp= NULL;
645 input_tmp= av_realloc(input_tmp, byte_delta + size);
647 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
650 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
652 memset(input_tmp, 0, byte_delta);
653 memcpy(input_tmp + byte_delta, buf, size);
657 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
659 }else if(audio_sync_method>1){
660 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
661 assert(ost->audio_resample);
663 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
664 // 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));
665 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
669 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
670 - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
672 if (ost->audio_resample) {
674 size_out = audio_resample(ost->resample,
675 (short *)buftmp, (short *)buf,
676 size / (ist->st->codec->channels * isize));
677 size_out = size_out * enc->channels * osize;
683 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
684 const void *ibuf[6]= {buftmp};
685 void *obuf[6]= {audio_buf};
686 int istride[6]= {isize};
687 int ostride[6]= {osize};
688 int len= size_out/istride[0];
689 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
690 printf("av_audio_convert() failed\n");
696 size_out = len*osize;
699 /* now encode as many frames as possible */
700 if (enc->frame_size > 1) {
701 /* output resampled raw samples */
702 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
703 fprintf(stderr, "av_fifo_realloc2() failed\n");
706 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
708 frame_bytes = enc->frame_size * osize * enc->channels;
710 while (av_fifo_size(ost->fifo) >= frame_bytes) {
712 av_init_packet(&pkt);
714 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
716 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
718 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
721 fprintf(stderr, "Audio encoding failed\n");
725 pkt.stream_index= ost->index;
728 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
729 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
730 pkt.flags |= PKT_FLAG_KEY;
731 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
733 ost->sync_opts += enc->frame_size;
737 av_init_packet(&pkt);
739 ost->sync_opts += size_out / (osize * enc->channels);
741 /* output a pcm frame */
742 /* determine the size of the coded buffer */
745 size_out = size_out*coded_bps/8;
747 if(size_out > audio_out_size){
748 fprintf(stderr, "Internal error, buffer size too small\n");
752 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
753 ret = avcodec_encode_audio(enc, audio_out, size_out,
756 fprintf(stderr, "Audio encoding failed\n");
760 pkt.stream_index= ost->index;
763 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
764 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
765 pkt.flags |= PKT_FLAG_KEY;
766 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
770 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
774 AVPicture picture_tmp;
777 dec = ist->st->codec;
779 /* deinterlace : must be done before any resize */
780 if (do_deinterlace) {
783 /* create temporary picture */
784 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
785 buf = av_malloc(size);
789 picture2 = &picture_tmp;
790 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
792 if(avpicture_deinterlace(picture2, picture,
793 dec->pix_fmt, dec->width, dec->height) < 0) {
794 /* if error, do not deinterlace */
795 fprintf(stderr, "Deinterlacing failed\n");
804 if (picture != picture2)
805 *picture = *picture2;
809 /* we begin to correct av delay at this threshold */
810 #define AV_DELAY_MAX 0.100
812 static void do_subtitle_out(AVFormatContext *s,
818 static uint8_t *subtitle_out = NULL;
819 int subtitle_out_max_size = 1024 * 1024;
820 int subtitle_out_size, nb, i;
824 if (pts == AV_NOPTS_VALUE) {
825 fprintf(stderr, "Subtitle packets must have a pts\n");
831 enc = ost->st->codec;
834 subtitle_out = av_malloc(subtitle_out_max_size);
837 /* Note: DVB subtitle need one packet to draw them and one other
838 packet to clear them */
839 /* XXX: signal it in the codec context ? */
840 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
845 for(i = 0; i < nb; i++) {
846 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
847 // start_display_time is required to be 0
848 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
849 sub->end_display_time -= sub->start_display_time;
850 sub->start_display_time = 0;
851 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
852 subtitle_out_max_size, sub);
853 if (subtitle_out_size < 0) {
854 fprintf(stderr, "Subtitle encoding failed\n");
858 av_init_packet(&pkt);
859 pkt.stream_index = ost->index;
860 pkt.data = subtitle_out;
861 pkt.size = subtitle_out_size;
862 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
863 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
864 /* XXX: the pts correction is handled here. Maybe handling
865 it in the codec would be better */
867 pkt.pts += 90 * sub->start_display_time;
869 pkt.pts += 90 * sub->end_display_time;
871 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
875 static int bit_buffer_size= 1024*256;
876 static uint8_t *bit_buffer= NULL;
878 static void do_video_out(AVFormatContext *s,
884 int nb_frames, i, ret;
885 int64_t topBand, bottomBand, leftBand, rightBand;
886 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
887 AVFrame picture_crop_temp, picture_pad_temp;
888 AVCodecContext *enc, *dec;
890 avcodec_get_frame_defaults(&picture_crop_temp);
891 avcodec_get_frame_defaults(&picture_pad_temp);
893 enc = ost->st->codec;
894 dec = ist->st->codec;
896 /* by default, we output a single frame */
901 if(video_sync_method){
903 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
904 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
907 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
911 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
912 }else if (vdelta > 1.1)
913 nb_frames = lrintf(vdelta);
914 //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);
918 fprintf(stderr, "*** drop!\n");
919 }else if (nb_frames > 1) {
920 nb_frames_dup += nb_frames - 1;
922 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
925 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
927 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
931 if (ost->video_crop) {
932 if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
933 fprintf(stderr, "error cropping picture\n");
938 formatted_picture = &picture_crop_temp;
940 formatted_picture = in_picture;
943 final_picture = formatted_picture;
944 padding_src = formatted_picture;
945 resampling_dst = &ost->pict_tmp;
946 if (ost->video_pad) {
947 final_picture = &ost->pict_tmp;
948 if (ost->video_resample) {
949 if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
950 fprintf(stderr, "error padding picture\n");
955 resampling_dst = &picture_pad_temp;
959 if( (ost->resample_height != (ist->st->codec->height - (ost->topBand + ost->bottomBand)))
960 || (ost->resample_width != (ist->st->codec->width - (ost->leftBand + ost->rightBand)))
961 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
963 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));
964 if(!ost->video_resample)
968 if (ost->video_resample) {
970 final_picture = &ost->pict_tmp;
971 if( (ost->resample_height != (ist->st->codec->height - (ost->topBand + ost->bottomBand)))
972 || (ost->resample_width != (ist->st->codec->width - (ost->leftBand + ost->rightBand)))
973 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
975 /* keep bands proportional to the frame size */
976 topBand = ((int64_t)ist->st->codec->height * ost->original_topBand / ost->original_height) & ~1;
977 bottomBand = ((int64_t)ist->st->codec->height * ost->original_bottomBand / ost->original_height) & ~1;
978 leftBand = ((int64_t)ist->st->codec->width * ost->original_leftBand / ost->original_width) & ~1;
979 rightBand = ((int64_t)ist->st->codec->width * ost->original_rightBand / ost->original_width) & ~1;
981 /* sanity check to ensure no bad band sizes sneak in */
982 assert(topBand <= INT_MAX && topBand >= 0);
983 assert(bottomBand <= INT_MAX && bottomBand >= 0);
984 assert(leftBand <= INT_MAX && leftBand >= 0);
985 assert(rightBand <= INT_MAX && rightBand >= 0);
987 ost->topBand = topBand;
988 ost->bottomBand = bottomBand;
989 ost->leftBand = leftBand;
990 ost->rightBand = rightBand;
992 ost->resample_height = ist->st->codec->height - (ost->topBand + ost->bottomBand);
993 ost->resample_width = ist->st->codec->width - (ost->leftBand + ost->rightBand);
994 ost->resample_pix_fmt= ist->st->codec->pix_fmt;
996 /* initialize a new scaler context */
997 sws_freeContext(ost->img_resample_ctx);
998 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
999 ost->img_resample_ctx = sws_getContext(
1000 ist->st->codec->width - (ost->leftBand + ost->rightBand),
1001 ist->st->codec->height - (ost->topBand + ost->bottomBand),
1002 ist->st->codec->pix_fmt,
1003 ost->st->codec->width - (ost->padleft + ost->padright),
1004 ost->st->codec->height - (ost->padtop + ost->padbottom),
1005 ost->st->codec->pix_fmt,
1006 sws_flags, NULL, NULL, NULL);
1007 if (ost->img_resample_ctx == NULL) {
1008 fprintf(stderr, "Cannot get resampling context\n");
1012 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1013 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1016 if (ost->video_pad) {
1017 av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
1018 enc->height, enc->width, enc->pix_fmt,
1019 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
1022 /* duplicates frame if needed */
1023 for(i=0;i<nb_frames;i++) {
1025 av_init_packet(&pkt);
1026 pkt.stream_index= ost->index;
1028 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1029 /* raw pictures are written as AVPicture structure to
1030 avoid any copies. We support temorarily the older
1032 AVFrame* old_frame = enc->coded_frame;
1033 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1034 pkt.data= (uint8_t *)final_picture;
1035 pkt.size= sizeof(AVPicture);
1036 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1037 pkt.flags |= PKT_FLAG_KEY;
1039 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1040 enc->coded_frame = old_frame;
1042 AVFrame big_picture;
1044 big_picture= *final_picture;
1045 /* better than nothing: use input picture interlaced
1047 big_picture.interlaced_frame = in_picture->interlaced_frame;
1048 if(avcodec_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1049 if(top_field_first == -1)
1050 big_picture.top_field_first = in_picture->top_field_first;
1052 big_picture.top_field_first = top_field_first;
1055 /* handles sameq here. This is not correct because it may
1056 not be a global option */
1058 big_picture.quality = ist->st->quality;
1060 big_picture.quality = ost->st->quality;
1062 big_picture.pict_type = 0;
1063 // big_picture.pts = AV_NOPTS_VALUE;
1064 big_picture.pts= ost->sync_opts;
1065 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1066 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1067 ret = avcodec_encode_video(enc,
1068 bit_buffer, bit_buffer_size,
1071 fprintf(stderr, "Video encoding failed\n");
1076 pkt.data= bit_buffer;
1078 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1079 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1080 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1081 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1082 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1084 if(enc->coded_frame->key_frame)
1085 pkt.flags |= PKT_FLAG_KEY;
1086 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1089 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1090 // enc->frame_number-1, ret, enc->pict_type);
1091 /* if two pass, output log */
1092 if (ost->logfile && enc->stats_out) {
1093 fprintf(ost->logfile, "%s", enc->stats_out);
1098 ost->frame_number++;
1102 static double psnr(double d){
1103 return -10.0*log(d)/log(10.0);
1106 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1109 AVCodecContext *enc;
1111 double ti1, bitrate, avg_bitrate;
1113 /* this is executed just the first time do_video_stats is called */
1115 vstats_file = fopen(vstats_filename, "w");
1122 enc = ost->st->codec;
1123 if (enc->codec_type == CODEC_TYPE_VIDEO) {
1124 frame_number = ost->frame_number;
1125 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1126 if (enc->flags&CODEC_FLAG_PSNR)
1127 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1129 fprintf(vstats_file,"f_size= %6d ", frame_size);
1130 /* compute pts value */
1131 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1135 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1136 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1137 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1138 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1139 fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1143 static void print_report(AVFormatContext **output_files,
1144 AVOutputStream **ost_table, int nb_ostreams,
1148 AVOutputStream *ost;
1149 AVFormatContext *oc;
1151 AVCodecContext *enc;
1152 int frame_number, vid, i;
1153 double bitrate, ti1, pts;
1154 static int64_t last_time = -1;
1155 static int qp_histogram[52];
1157 if (!is_last_report) {
1159 /* display the report every 0.5 seconds */
1160 cur_time = av_gettime();
1161 if (last_time == -1) {
1162 last_time = cur_time;
1165 if ((cur_time - last_time) < 500000)
1167 last_time = cur_time;
1171 oc = output_files[0];
1173 total_size = url_fsize(oc->pb);
1174 if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1175 total_size= url_ftell(oc->pb);
1180 for(i=0;i<nb_ostreams;i++) {
1182 enc = ost->st->codec;
1183 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1184 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1185 !ost->st->stream_copy ?
1186 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1188 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1189 float t = (av_gettime()-timer_start) / 1000000.0;
1191 frame_number = ost->frame_number;
1192 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1193 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1194 !ost->st->stream_copy ?
1195 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1197 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1200 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1201 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1204 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1206 if (enc->flags&CODEC_FLAG_PSNR){
1208 double error, error_sum=0;
1209 double scale, scale_sum=0;
1210 char type[3]= {'Y','U','V'};
1211 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1214 error= enc->error[j];
1215 scale= enc->width*enc->height*255.0*255.0*frame_number;
1217 error= enc->coded_frame->error[j];
1218 scale= enc->width*enc->height*255.0*255.0;
1223 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1225 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1229 /* compute min output value */
1230 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1231 if ((pts < ti1) && (pts > 0))
1237 if (verbose || is_last_report) {
1238 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1240 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1241 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1242 (double)total_size / 1024, ti1, bitrate);
1244 if (nb_frames_dup || nb_frames_drop)
1245 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1246 nb_frames_dup, nb_frames_drop);
1249 fprintf(stderr, "%s \r", buf);
1254 if (is_last_report && verbose >= 0){
1255 int64_t raw= audio_size + video_size + extra_size;
1256 fprintf(stderr, "\n");
1257 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1261 100.0*(total_size - raw)/raw
1266 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1267 static int output_packet(AVInputStream *ist, int ist_index,
1268 AVOutputStream **ost_table, int nb_ostreams,
1269 const AVPacket *pkt)
1271 AVFormatContext *os;
1272 AVOutputStream *ost;
1275 int data_size, got_picture;
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)) {
1303 ist->pts= ist->next_pts;
1305 if(avpkt.size && avpkt.size != pkt->size &&
1306 !(ist->st->codec->codec->capabilities & CODEC_CAP_SUBFRAMES) && verbose>0)
1307 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1309 /* decode the packet if needed */
1310 data_buf = NULL; /* fail safe */
1312 subtitle_to_free = NULL;
1313 if (ist->decoding_needed) {
1314 switch(ist->st->codec->codec_type) {
1315 case CODEC_TYPE_AUDIO:{
1316 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1317 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1319 samples= av_malloc(samples_size);
1321 data_size= samples_size;
1322 /* XXX: could avoid copy if PCM 16 bits with same
1323 endianness as CPU */
1324 ret = avcodec_decode_audio3(ist->st->codec, samples, &data_size,
1330 /* Some bug in mpeg audio decoder gives */
1331 /* data_size < 0, it seems they are overflows */
1332 if (data_size <= 0) {
1333 /* no audio frame */
1336 data_buf = (uint8_t *)samples;
1337 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * data_size) /
1338 (ist->st->codec->sample_rate * ist->st->codec->channels);
1340 case CODEC_TYPE_VIDEO:
1341 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1342 /* XXX: allocate picture correctly */
1343 avcodec_get_frame_defaults(&picture);
1345 ret = avcodec_decode_video2(ist->st->codec,
1346 &picture, &got_picture, &avpkt);
1347 ist->st->quality= picture.quality;
1351 /* no picture yet */
1352 goto discard_packet;
1354 if (ist->st->codec->time_base.num != 0) {
1355 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1356 ist->next_pts += ((int64_t)AV_TIME_BASE *
1357 ist->st->codec->time_base.num * ticks) /
1358 ist->st->codec->time_base.den;
1362 case CODEC_TYPE_SUBTITLE:
1363 ret = avcodec_decode_subtitle2(ist->st->codec,
1364 &subtitle, &got_subtitle, &avpkt);
1367 if (!got_subtitle) {
1368 goto discard_packet;
1370 subtitle_to_free = &subtitle;
1377 switch(ist->st->codec->codec_type) {
1378 case CODEC_TYPE_AUDIO:
1379 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1380 ist->st->codec->sample_rate;
1382 case CODEC_TYPE_VIDEO:
1383 if (ist->st->codec->time_base.num != 0) {
1384 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1385 ist->next_pts += ((int64_t)AV_TIME_BASE *
1386 ist->st->codec->time_base.num * ticks) /
1387 ist->st->codec->time_base.den;
1391 data_buf = avpkt.data;
1392 data_size = avpkt.size;
1397 buffer_to_free = NULL;
1398 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1399 pre_process_video_frame(ist, (AVPicture *)&picture,
1403 // preprocess audio (volume)
1404 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1405 if (audio_volume != 256) {
1408 for(i=0;i<(data_size / sizeof(short));i++) {
1409 int v = ((*volp) * audio_volume + 128) >> 8;
1410 if (v < -32768) v = -32768;
1411 if (v > 32767) v = 32767;
1417 /* frame rate emulation */
1419 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1420 int64_t now = av_gettime() - ist->start;
1425 /* if output time reached then transcode raw format,
1426 encode packets and output them */
1427 if (start_time == 0 || ist->pts >= start_time)
1428 for(i=0;i<nb_ostreams;i++) {
1432 if (ost->source_index == ist_index) {
1433 os = output_files[ost->file_index];
1435 /* set the input output pts pairs */
1436 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1438 if (ost->encoding_needed) {
1439 switch(ost->st->codec->codec_type) {
1440 case CODEC_TYPE_AUDIO:
1441 do_audio_out(os, ost, ist, data_buf, data_size);
1443 case CODEC_TYPE_VIDEO:
1444 do_video_out(os, ost, ist, &picture, &frame_size);
1445 if (vstats_filename && frame_size)
1446 do_video_stats(os, ost, frame_size);
1448 case CODEC_TYPE_SUBTITLE:
1449 do_subtitle_out(os, ost, ist, &subtitle,
1456 AVFrame avframe; //FIXME/XXX remove this
1458 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1460 av_init_packet(&opkt);
1462 if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1465 /* no reencoding needed : output the packet directly */
1466 /* force the input stream PTS */
1468 avcodec_get_frame_defaults(&avframe);
1469 ost->st->codec->coded_frame= &avframe;
1470 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1472 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1473 audio_size += data_size;
1474 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1475 video_size += data_size;
1479 opkt.stream_index= ost->index;
1480 if(pkt->pts != AV_NOPTS_VALUE)
1481 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1483 opkt.pts= AV_NOPTS_VALUE;
1485 if (pkt->dts == AV_NOPTS_VALUE)
1486 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1488 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1489 opkt.dts -= ost_tb_start_time;
1491 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1492 opkt.flags= pkt->flags;
1494 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1495 if(ost->st->codec->codec_id != CODEC_ID_H264) {
1496 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1497 opkt.destruct= av_destruct_packet;
1499 opkt.data = data_buf;
1500 opkt.size = data_size;
1503 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1504 ost->st->codec->frame_number++;
1505 ost->frame_number++;
1506 av_free_packet(&opkt);
1510 av_free(buffer_to_free);
1511 /* XXX: allocate the subtitles in the codec ? */
1512 if (subtitle_to_free) {
1513 if (subtitle_to_free->rects != NULL) {
1514 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1515 av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1516 av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1517 av_freep(&subtitle_to_free->rects[i]);
1519 av_freep(&subtitle_to_free->rects);
1521 subtitle_to_free->num_rects = 0;
1522 subtitle_to_free = NULL;
1529 for(i=0;i<nb_ostreams;i++) {
1531 if (ost->source_index == ist_index) {
1532 AVCodecContext *enc= ost->st->codec;
1533 os = output_files[ost->file_index];
1535 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1537 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1540 if (ost->encoding_needed) {
1544 av_init_packet(&pkt);
1545 pkt.stream_index= ost->index;
1547 switch(ost->st->codec->codec_type) {
1548 case CODEC_TYPE_AUDIO:
1549 fifo_bytes = av_fifo_size(ost->fifo);
1551 /* encode any samples remaining in fifo */
1552 if (fifo_bytes > 0) {
1553 int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
1554 int fs_tmp = enc->frame_size;
1556 av_fifo_generic_read(ost->fifo, samples, fifo_bytes, NULL);
1557 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1558 enc->frame_size = fifo_bytes / (osize * enc->channels);
1560 int frame_bytes = enc->frame_size*osize*enc->channels;
1561 if (samples_size < frame_bytes)
1563 memset((uint8_t*)samples+fifo_bytes, 0, frame_bytes - fifo_bytes);
1566 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1567 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1568 ost->st->time_base.num, enc->sample_rate);
1569 enc->frame_size = fs_tmp;
1572 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1575 fprintf(stderr, "Audio encoding failed\n");
1579 pkt.flags |= PKT_FLAG_KEY;
1581 case CODEC_TYPE_VIDEO:
1582 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1584 fprintf(stderr, "Video encoding failed\n");
1588 if(enc->coded_frame && enc->coded_frame->key_frame)
1589 pkt.flags |= PKT_FLAG_KEY;
1590 if (ost->logfile && enc->stats_out) {
1591 fprintf(ost->logfile, "%s", enc->stats_out);
1600 pkt.data= bit_buffer;
1602 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1603 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1604 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1616 static void print_sdp(AVFormatContext **avc, int n)
1620 avf_sdp_create(avc, n, sdp, sizeof(sdp));
1621 printf("SDP:\n%s\n", sdp);
1625 static int stream_index_from_inputs(AVFormatContext **input_files,
1627 AVInputFile *file_table,
1628 AVInputStream **ist_table,
1629 enum CodecType type,
1633 for(z=0; z<nb_input_files; z++) {
1634 AVFormatContext *ic = input_files[z];
1635 for(p=0; p<ic->nb_programs; p++) {
1636 AVProgram *program = ic->programs[p];
1637 if(program->id != programid)
1639 for(q=0; q<program->nb_stream_indexes; q++) {
1640 int sidx = program->stream_index[q];
1641 int ris = file_table[z].ist_index + sidx;
1642 if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1652 * The following code is the main loop of the file converter
1654 static int av_encode(AVFormatContext **output_files,
1655 int nb_output_files,
1656 AVFormatContext **input_files,
1658 AVStreamMap *stream_maps, int nb_stream_maps)
1660 int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1661 AVFormatContext *is, *os;
1662 AVCodecContext *codec, *icodec;
1663 AVOutputStream *ost, **ost_table = NULL;
1664 AVInputStream *ist, **ist_table = NULL;
1665 AVInputFile *file_table;
1669 uint8_t no_packet[MAX_FILES]={0};
1670 int no_packet_count=0;
1672 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1676 /* input stream init */
1678 for(i=0;i<nb_input_files;i++) {
1679 is = input_files[i];
1680 file_table[i].ist_index = j;
1681 file_table[i].nb_streams = is->nb_streams;
1682 j += is->nb_streams;
1686 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1690 for(i=0;i<nb_istreams;i++) {
1691 ist = av_mallocz(sizeof(AVInputStream));
1697 for(i=0;i<nb_input_files;i++) {
1698 is = input_files[i];
1699 for(k=0;k<is->nb_streams;k++) {
1700 ist = ist_table[j++];
1701 ist->st = is->streams[k];
1702 ist->file_index = i;
1704 ist->discard = 1; /* the stream is discarded by default
1708 ist->start = av_gettime();
1713 /* output stream init */
1715 for(i=0;i<nb_output_files;i++) {
1716 os = output_files[i];
1717 if (!os->nb_streams) {
1718 dump_format(output_files[i], i, output_files[i]->filename, 1);
1719 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1722 nb_ostreams += os->nb_streams;
1724 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1725 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1729 /* Sanity check the mapping args -- do the input files & streams exist? */
1730 for(i=0;i<nb_stream_maps;i++) {
1731 int fi = stream_maps[i].file_index;
1732 int si = stream_maps[i].stream_index;
1734 if (fi < 0 || fi > nb_input_files - 1 ||
1735 si < 0 || si > file_table[fi].nb_streams - 1) {
1736 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1739 fi = stream_maps[i].sync_file_index;
1740 si = stream_maps[i].sync_stream_index;
1741 if (fi < 0 || fi > nb_input_files - 1 ||
1742 si < 0 || si > file_table[fi].nb_streams - 1) {
1743 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1748 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1751 for(i=0;i<nb_ostreams;i++) {
1752 ost = av_mallocz(sizeof(AVOutputStream));
1759 for(k=0;k<nb_output_files;k++) {
1760 os = output_files[k];
1761 for(i=0;i<os->nb_streams;i++,n++) {
1764 ost->file_index = k;
1766 ost->st = os->streams[i];
1767 if (nb_stream_maps > 0) {
1768 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1769 stream_maps[n].stream_index;
1771 /* Sanity check that the stream types match */
1772 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1773 int i= ost->file_index;
1774 dump_format(output_files[i], i, output_files[i]->filename, 1);
1775 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1776 stream_maps[n].file_index, stream_maps[n].stream_index,
1777 ost->file_index, ost->index);
1784 j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1786 ost->source_index = j;
1790 /* get corresponding input stream index : we select the first one with the right type */
1792 for(j=0;j<nb_istreams;j++) {
1795 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1796 ost->source_index = j;
1804 if(! opt_programid) {
1805 /* try again and reuse existing stream */
1806 for(j=0;j<nb_istreams;j++) {
1808 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1809 ost->source_index = j;
1815 int i= ost->file_index;
1816 dump_format(output_files[i], i, output_files[i]->filename, 1);
1817 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1818 ost->file_index, ost->index);
1823 ist = ist_table[ost->source_index];
1825 ost->sync_ist = (nb_stream_maps > 0) ?
1826 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
1827 stream_maps[n].sync_stream_index] : ist;
1831 /* for each output stream, we compute the right encoding parameters */
1832 for(i=0;i<nb_ostreams;i++) {
1833 AVMetadataTag *lang;
1835 os = output_files[ost->file_index];
1836 ist = ist_table[ost->source_index];
1838 codec = ost->st->codec;
1839 icodec = ist->st->codec;
1841 if ((lang=av_metadata_get(ist->st->metadata, "language", NULL, 0))
1842 && !av_metadata_get(ost->st->metadata, "language", NULL, 0))
1843 av_metadata_set(&ost->st->metadata, "language", lang->value);
1845 ost->st->disposition = ist->st->disposition;
1846 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1847 codec->chroma_sample_location = icodec->chroma_sample_location;
1849 if (ost->st->stream_copy) {
1850 /* if stream_copy is selected, no need to decode or encode */
1851 codec->codec_id = icodec->codec_id;
1852 codec->codec_type = icodec->codec_type;
1854 if(!codec->codec_tag){
1855 if( !os->oformat->codec_tag
1856 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1857 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1858 codec->codec_tag = icodec->codec_tag;
1861 codec->bit_rate = icodec->bit_rate;
1862 codec->extradata= icodec->extradata;
1863 codec->extradata_size= icodec->extradata_size;
1864 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){
1865 codec->time_base = icodec->time_base;
1866 codec->time_base.num *= icodec->ticks_per_frame;
1868 codec->time_base = ist->st->time_base;
1869 switch(codec->codec_type) {
1870 case CODEC_TYPE_AUDIO:
1871 if(audio_volume != 256) {
1872 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1875 codec->channel_layout = icodec->channel_layout;
1876 codec->sample_rate = icodec->sample_rate;
1877 codec->channels = icodec->channels;
1878 codec->frame_size = icodec->frame_size;
1879 codec->block_align= icodec->block_align;
1880 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1881 codec->block_align= 0;
1882 if(codec->codec_id == CODEC_ID_AC3)
1883 codec->block_align= 0;
1885 case CODEC_TYPE_VIDEO:
1886 codec->pix_fmt = icodec->pix_fmt;
1887 codec->width = icodec->width;
1888 codec->height = icodec->height;
1889 codec->has_b_frames = icodec->has_b_frames;
1891 case CODEC_TYPE_SUBTITLE:
1892 codec->width = icodec->width;
1893 codec->height = icodec->height;
1899 switch(codec->codec_type) {
1900 case CODEC_TYPE_AUDIO:
1901 ost->fifo= av_fifo_alloc(1024);
1904 ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
1905 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1906 icodec->request_channels = codec->channels;
1907 ist->decoding_needed = 1;
1908 ost->encoding_needed = 1;
1910 case CODEC_TYPE_VIDEO:
1911 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
1912 fprintf(stderr, "Video pixel format is unknown, stream cannot be decoded\n");
1915 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1916 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1917 ost->video_resample = ((codec->width != icodec->width -
1918 (frame_leftBand + frame_rightBand) +
1919 (frame_padleft + frame_padright)) ||
1920 (codec->height != icodec->height -
1921 (frame_topBand + frame_bottomBand) +
1922 (frame_padtop + frame_padbottom)) ||
1923 (codec->pix_fmt != icodec->pix_fmt));
1924 if (ost->video_crop) {
1925 ost->topBand = ost->original_topBand = frame_topBand;
1926 ost->bottomBand = ost->original_bottomBand = frame_bottomBand;
1927 ost->leftBand = ost->original_leftBand = frame_leftBand;
1928 ost->rightBand = ost->original_rightBand = frame_rightBand;
1930 if (ost->video_pad) {
1931 ost->padtop = frame_padtop;
1932 ost->padleft = frame_padleft;
1933 ost->padbottom = frame_padbottom;
1934 ost->padright = frame_padright;
1935 if (!ost->video_resample) {
1936 avcodec_get_frame_defaults(&ost->pict_tmp);
1937 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1938 codec->width, codec->height))
1942 if (ost->video_resample) {
1943 avcodec_get_frame_defaults(&ost->pict_tmp);
1944 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1945 codec->width, codec->height)) {
1946 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1949 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1950 ost->img_resample_ctx = sws_getContext(
1951 icodec->width - (frame_leftBand + frame_rightBand),
1952 icodec->height - (frame_topBand + frame_bottomBand),
1954 codec->width - (frame_padleft + frame_padright),
1955 codec->height - (frame_padtop + frame_padbottom),
1957 sws_flags, NULL, NULL, NULL);
1958 if (ost->img_resample_ctx == NULL) {
1959 fprintf(stderr, "Cannot get resampling context\n");
1963 ost->original_height = icodec->height;
1964 ost->original_width = icodec->width;
1966 codec->bits_per_raw_sample= 0;
1968 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1969 ost->resample_width = icodec->width - (frame_leftBand + frame_rightBand);
1970 ost->resample_pix_fmt= icodec->pix_fmt;
1971 ost->encoding_needed = 1;
1972 ist->decoding_needed = 1;
1974 case CODEC_TYPE_SUBTITLE:
1975 ost->encoding_needed = 1;
1976 ist->decoding_needed = 1;
1983 if (ost->encoding_needed &&
1984 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1985 char logfilename[1024];
1990 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1991 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
1993 if (codec->flags & CODEC_FLAG_PASS1) {
1994 f = fopen(logfilename, "w");
1996 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2001 /* read the log file */
2002 f = fopen(logfilename, "r");
2004 fprintf(stderr, "Cannot read log file '%s' for pass-2 encoding: %s\n", logfilename, strerror(errno));
2007 fseek(f, 0, SEEK_END);
2009 fseek(f, 0, SEEK_SET);
2010 logbuffer = av_malloc(size + 1);
2012 fprintf(stderr, "Could not allocate log buffer\n");
2015 size = fread(logbuffer, 1, size, f);
2017 logbuffer[size] = '\0';
2018 codec->stats_in = logbuffer;
2022 if(codec->codec_type == CODEC_TYPE_VIDEO){
2023 int size= codec->width * codec->height;
2024 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2029 bit_buffer = av_malloc(bit_buffer_size);
2031 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2033 ret = AVERROR(ENOMEM);
2037 /* open each encoder */
2038 for(i=0;i<nb_ostreams;i++) {
2040 if (ost->encoding_needed) {
2041 AVCodec *codec = output_codecs[i];
2043 codec = avcodec_find_encoder(ost->st->codec->codec_id);
2045 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2046 ost->st->codec->codec_id, ost->file_index, ost->index);
2047 ret = AVERROR(EINVAL);
2050 if (avcodec_open(ost->st->codec, codec) < 0) {
2051 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2052 ost->file_index, ost->index);
2053 ret = AVERROR(EINVAL);
2056 extra_size += ost->st->codec->extradata_size;
2060 /* open each decoder */
2061 for(i=0;i<nb_istreams;i++) {
2063 if (ist->decoding_needed) {
2064 AVCodec *codec = input_codecs[i];
2066 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2068 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2069 ist->st->codec->codec_id, ist->file_index, ist->index);
2070 ret = AVERROR(EINVAL);
2073 if (avcodec_open(ist->st->codec, codec) < 0) {
2074 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2075 ist->file_index, ist->index);
2076 ret = AVERROR(EINVAL);
2079 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
2080 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2085 for(i=0;i<nb_istreams;i++) {
2088 ist->next_pts = AV_NOPTS_VALUE;
2092 /* set meta data information from input file if required */
2093 for (i=0;i<nb_meta_data_maps;i++) {
2094 AVFormatContext *out_file;
2095 AVFormatContext *in_file;
2096 AVMetadataTag *mtag;
2098 int out_file_index = meta_data_maps[i].out_file;
2099 int in_file_index = meta_data_maps[i].in_file;
2100 if (out_file_index < 0 || out_file_index >= nb_output_files) {
2101 snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
2102 out_file_index, out_file_index, in_file_index);
2103 ret = AVERROR(EINVAL);
2106 if (in_file_index < 0 || in_file_index >= nb_input_files) {
2107 snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
2108 in_file_index, out_file_index, in_file_index);
2109 ret = AVERROR(EINVAL);
2113 out_file = output_files[out_file_index];
2114 in_file = input_files[in_file_index];
2118 while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2119 av_metadata_set(&out_file->metadata, mtag->key, mtag->value);
2120 av_metadata_conv(out_file, out_file->oformat->metadata_conv,
2121 in_file->iformat->metadata_conv);
2124 /* open files and write file headers */
2125 for(i=0;i<nb_output_files;i++) {
2126 os = output_files[i];
2127 if (av_write_header(os) < 0) {
2128 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2129 ret = AVERROR(EINVAL);
2132 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2138 /* dump the file output parameters - cannot be done before in case
2140 for(i=0;i<nb_output_files;i++) {
2141 dump_format(output_files[i], i, output_files[i]->filename, 1);
2144 /* dump the stream mapping */
2146 fprintf(stderr, "Stream mapping:\n");
2147 for(i=0;i<nb_ostreams;i++) {
2149 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2150 ist_table[ost->source_index]->file_index,
2151 ist_table[ost->source_index]->index,
2154 if (ost->sync_ist != ist_table[ost->source_index])
2155 fprintf(stderr, " [sync #%d.%d]",
2156 ost->sync_ist->file_index,
2157 ost->sync_ist->index);
2158 fprintf(stderr, "\n");
2163 fprintf(stderr, "%s\n", error);
2168 print_sdp(output_files, nb_output_files);
2171 if (!using_stdin && verbose >= 0) {
2172 fprintf(stderr, "Press [q] to stop encoding\n");
2173 url_set_interrupt_cb(decode_interrupt_cb);
2177 timer_start = av_gettime();
2179 for(; received_sigterm == 0;) {
2180 int file_index, ist_index;
2188 /* if 'q' pressed, exits */
2192 /* read_key() returns 0 on EOF */
2198 /* select the stream that we must read now by looking at the
2199 smallest output pts */
2201 for(i=0;i<nb_ostreams;i++) {
2204 os = output_files[ost->file_index];
2205 ist = ist_table[ost->source_index];
2206 if(no_packet[ist->file_index])
2208 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2209 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2211 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2212 ipts = (double)ist->pts;
2213 if (!file_table[ist->file_index].eof_reached){
2214 if(ipts < ipts_min) {
2216 if(input_sync ) file_index = ist->file_index;
2218 if(opts < opts_min) {
2220 if(!input_sync) file_index = ist->file_index;
2223 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2228 /* if none, if is finished */
2229 if (file_index < 0) {
2230 if(no_packet_count){
2232 memset(no_packet, 0, sizeof(no_packet));
2239 /* finish if recording time exhausted */
2240 if (opts_min >= (recording_time / 1000000.0))
2243 /* finish if limit size exhausted */
2244 if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2247 /* read a frame from it and output it in the fifo */
2248 is = input_files[file_index];
2249 ret= av_read_frame(is, &pkt);
2250 if(ret == AVERROR(EAGAIN)){
2251 no_packet[file_index]=1;
2256 file_table[file_index].eof_reached = 1;
2264 memset(no_packet, 0, sizeof(no_packet));
2267 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2269 /* the following test is needed in case new streams appear
2270 dynamically in stream : we ignore them */
2271 if (pkt.stream_index >= file_table[file_index].nb_streams)
2272 goto discard_packet;
2273 ist_index = file_table[file_index].ist_index + pkt.stream_index;
2274 ist = ist_table[ist_index];
2276 goto discard_packet;
2278 if (pkt.dts != AV_NOPTS_VALUE)
2279 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2280 if (pkt.pts != AV_NOPTS_VALUE)
2281 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2283 if(input_files_ts_scale[file_index][pkt.stream_index]){
2284 if(pkt.pts != AV_NOPTS_VALUE)
2285 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2286 if(pkt.dts != AV_NOPTS_VALUE)
2287 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2290 // 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);
2291 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2292 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2293 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2294 int64_t delta= pkt_dts - ist->next_pts;
2295 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2296 input_files_ts_offset[ist->file_index]-= delta;
2298 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2299 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2300 if(pkt.pts != AV_NOPTS_VALUE)
2301 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2305 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2306 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2309 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2310 ist->file_index, ist->index);
2313 av_free_packet(&pkt);
2318 av_free_packet(&pkt);
2320 /* dump report by using the output first video and audio streams */
2321 print_report(output_files, ost_table, nb_ostreams, 0);
2324 /* at the end of stream, we must flush the decoder buffers */
2325 for(i=0;i<nb_istreams;i++) {
2327 if (ist->decoding_needed) {
2328 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2334 /* write the trailer if needed and close file */
2335 for(i=0;i<nb_output_files;i++) {
2336 os = output_files[i];
2337 av_write_trailer(os);
2340 /* dump report by using the first video and audio streams */
2341 print_report(output_files, ost_table, nb_ostreams, 1);
2343 /* close each encoder */
2344 for(i=0;i<nb_ostreams;i++) {
2346 if (ost->encoding_needed) {
2347 av_freep(&ost->st->codec->stats_in);
2348 avcodec_close(ost->st->codec);
2352 /* close each decoder */
2353 for(i=0;i<nb_istreams;i++) {
2355 if (ist->decoding_needed) {
2356 avcodec_close(ist->st->codec);
2364 av_freep(&bit_buffer);
2365 av_free(file_table);
2368 for(i=0;i<nb_istreams;i++) {
2375 for(i=0;i<nb_ostreams;i++) {
2379 fclose(ost->logfile);
2380 ost->logfile = NULL;
2382 av_fifo_free(ost->fifo); /* works even if fifo is not
2383 initialized but set to zero */
2384 av_free(ost->pict_tmp.data[0]);
2385 if (ost->video_resample)
2386 sws_freeContext(ost->img_resample_ctx);
2388 audio_resample_close(ost->resample);
2389 if (ost->reformat_ctx)
2390 av_audio_convert_free(ost->reformat_ctx);
2399 static void opt_format(const char *arg)
2401 /* compatibility stuff for pgmyuv */
2402 if (!strcmp(arg, "pgmyuv")) {
2403 pgmyuv_compatibility_hack=1;
2404 // opt_image_format(arg);
2406 fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2409 last_asked_format = arg;
2412 static void opt_video_rc_override_string(const char *arg)
2414 video_rc_override_string = arg;
2417 static int opt_me_threshold(const char *opt, const char *arg)
2419 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2423 static int opt_verbose(const char *opt, const char *arg)
2425 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2429 static int opt_frame_rate(const char *opt, const char *arg)
2431 if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2432 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2438 static int opt_bitrate(const char *opt, const char *arg)
2440 int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2442 opt_default(opt, arg);
2444 if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2445 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2450 static void opt_frame_crop_top(const char *arg)
2452 frame_topBand = atoi(arg);
2453 if (frame_topBand < 0) {
2454 fprintf(stderr, "Incorrect top crop size\n");
2457 if ((frame_topBand) >= frame_height){
2458 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2461 frame_height -= frame_topBand;
2464 static void opt_frame_crop_bottom(const char *arg)
2466 frame_bottomBand = atoi(arg);
2467 if (frame_bottomBand < 0) {
2468 fprintf(stderr, "Incorrect bottom crop size\n");
2471 if ((frame_bottomBand) >= frame_height){
2472 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2475 frame_height -= frame_bottomBand;
2478 static void opt_frame_crop_left(const char *arg)
2480 frame_leftBand = atoi(arg);
2481 if (frame_leftBand < 0) {
2482 fprintf(stderr, "Incorrect left crop size\n");
2485 if ((frame_leftBand) >= frame_width){
2486 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2489 frame_width -= frame_leftBand;
2492 static void opt_frame_crop_right(const char *arg)
2494 frame_rightBand = atoi(arg);
2495 if (frame_rightBand < 0) {
2496 fprintf(stderr, "Incorrect right crop size\n");
2499 if ((frame_rightBand) >= frame_width){
2500 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2503 frame_width -= frame_rightBand;
2506 static void opt_frame_size(const char *arg)
2508 if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2509 fprintf(stderr, "Incorrect frame size\n");
2514 static void opt_pad_color(const char *arg) {
2515 /* Input is expected to be six hex digits similar to
2516 how colors are expressed in html tags (but without the #) */
2517 int rgb = strtol(arg, NULL, 16);
2521 g = ((rgb >> 8) & 255);
2524 padcolor[0] = RGB_TO_Y(r,g,b);
2525 padcolor[1] = RGB_TO_U(r,g,b,0);
2526 padcolor[2] = RGB_TO_V(r,g,b,0);
2529 static void opt_frame_pad_top(const char *arg)
2531 frame_padtop = atoi(arg);
2532 if (frame_padtop < 0) {
2533 fprintf(stderr, "Incorrect top pad size\n");
2538 static void opt_frame_pad_bottom(const char *arg)
2540 frame_padbottom = atoi(arg);
2541 if (frame_padbottom < 0) {
2542 fprintf(stderr, "Incorrect bottom pad size\n");
2548 static void opt_frame_pad_left(const char *arg)
2550 frame_padleft = atoi(arg);
2551 if (frame_padleft < 0) {
2552 fprintf(stderr, "Incorrect left pad size\n");
2558 static void opt_frame_pad_right(const char *arg)
2560 frame_padright = atoi(arg);
2561 if (frame_padright < 0) {
2562 fprintf(stderr, "Incorrect right pad size\n");
2567 static void opt_frame_pix_fmt(const char *arg)
2569 if (strcmp(arg, "list")) {
2570 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2571 if (frame_pix_fmt == PIX_FMT_NONE) {
2572 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2576 list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2581 static void opt_frame_aspect_ratio(const char *arg)
2588 p = strchr(arg, ':');
2590 x = strtol(arg, &end, 10);
2592 y = strtol(end+1, &end, 10);
2594 ar = (double)x / (double)y;
2596 ar = strtod(arg, NULL);
2599 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2602 frame_aspect_ratio = ar;
2605 static int opt_metadata(const char *opt, const char *arg)
2607 char *mid= strchr(arg, '=');
2610 fprintf(stderr, "Missing =\n");
2616 metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2617 metadata[metadata_count-1].key = av_strdup(arg);
2618 metadata[metadata_count-1].value= av_strdup(mid);
2623 static void opt_qscale(const char *arg)
2625 video_qscale = atof(arg);
2626 if (video_qscale <= 0 ||
2627 video_qscale > 255) {
2628 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2633 static void opt_top_field_first(const char *arg)
2635 top_field_first= atoi(arg);
2638 static int opt_thread_count(const char *opt, const char *arg)
2640 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2643 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2648 static void opt_audio_sample_fmt(const char *arg)
2650 if (strcmp(arg, "list"))
2651 audio_sample_fmt = avcodec_get_sample_fmt(arg);
2653 list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2658 static int opt_audio_rate(const char *opt, const char *arg)
2660 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2664 static int opt_audio_channels(const char *opt, const char *arg)
2666 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2670 static void opt_video_channel(const char *arg)
2672 video_channel = strtol(arg, NULL, 0);
2675 static void opt_video_standard(const char *arg)
2677 video_standard = av_strdup(arg);
2680 static void opt_codec(int *pstream_copy, char **pcodec_name,
2681 int codec_type, const char *arg)
2683 av_freep(pcodec_name);
2684 if (!strcmp(arg, "copy")) {
2687 *pcodec_name = av_strdup(arg);
2691 static void opt_audio_codec(const char *arg)
2693 opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2696 static void opt_audio_tag(const char *arg)
2699 audio_codec_tag= strtol(arg, &tail, 0);
2702 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2705 static void opt_video_tag(const char *arg)
2708 video_codec_tag= strtol(arg, &tail, 0);
2711 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2714 static void opt_video_codec(const char *arg)
2716 opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2719 static void opt_subtitle_codec(const char *arg)
2721 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2724 static void opt_subtitle_tag(const char *arg)
2727 subtitle_codec_tag= strtol(arg, &tail, 0);
2730 subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2733 static void opt_map(const char *arg)
2738 m = &stream_maps[nb_stream_maps++];
2740 m->file_index = strtol(arg, &p, 0);
2744 m->stream_index = strtol(p, &p, 0);
2747 m->sync_file_index = strtol(p, &p, 0);
2750 m->sync_stream_index = strtol(p, &p, 0);
2752 m->sync_file_index = m->file_index;
2753 m->sync_stream_index = m->stream_index;
2757 static void opt_map_meta_data(const char *arg)
2762 m = &meta_data_maps[nb_meta_data_maps++];
2764 m->out_file = strtol(arg, &p, 0);
2768 m->in_file = strtol(p, &p, 0);
2771 static void opt_input_ts_scale(const char *arg)
2773 unsigned int stream;
2777 stream = strtol(arg, &p, 0);
2780 scale= strtod(p, &p);
2782 if(stream >= MAX_STREAMS)
2785 input_files_ts_scale[nb_input_files][stream]= scale;
2788 static int opt_recording_time(const char *opt, const char *arg)
2790 recording_time = parse_time_or_die(opt, arg, 1);
2794 static int opt_start_time(const char *opt, const char *arg)
2796 start_time = parse_time_or_die(opt, arg, 1);
2800 static int opt_rec_timestamp(const char *opt, const char *arg)
2802 rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2806 static int opt_input_ts_offset(const char *opt, const char *arg)
2808 input_ts_offset = parse_time_or_die(opt, arg, 1);
2812 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2814 const char *codec_string = encoder ? "encoder" : "decoder";
2818 return CODEC_ID_NONE;
2820 avcodec_find_encoder_by_name(name) :
2821 avcodec_find_decoder_by_name(name);
2823 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2826 if(codec->type != type) {
2827 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2833 static void opt_input_file(const char *filename)
2835 AVFormatContext *ic;
2836 AVFormatParameters params, *ap = ¶ms;
2837 AVInputFormat *file_iformat = NULL;
2838 int err, i, ret, rfps, rfps_base;
2841 if (last_asked_format) {
2842 file_iformat = av_find_input_format(last_asked_format);
2843 last_asked_format = NULL;
2846 if (!strcmp(filename, "-"))
2849 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2850 !strcmp(filename, "/dev/stdin");
2852 /* get default parameters from command line */
2853 ic = avformat_alloc_context();
2855 print_error(filename, AVERROR(ENOMEM));
2859 memset(ap, 0, sizeof(*ap));
2860 ap->prealloced_context = 1;
2861 ap->sample_rate = audio_sample_rate;
2862 ap->channels = audio_channels;
2863 ap->time_base.den = frame_rate.num;
2864 ap->time_base.num = frame_rate.den;
2865 ap->width = frame_width + frame_padleft + frame_padright;
2866 ap->height = frame_height + frame_padtop + frame_padbottom;
2867 ap->pix_fmt = frame_pix_fmt;
2868 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2869 ap->channel = video_channel;
2870 ap->standard = video_standard;
2871 ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2872 ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2873 if(pgmyuv_compatibility_hack)
2874 ap->video_codec_id= CODEC_ID_PGMYUV;
2876 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2878 ic->video_codec_id = find_codec_or_die(video_codec_name , CODEC_TYPE_VIDEO , 0);
2879 ic->audio_codec_id = find_codec_or_die(audio_codec_name , CODEC_TYPE_AUDIO , 0);
2880 ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2881 ic->flags |= AVFMT_FLAG_NONBLOCK;
2883 /* open the input file with generic libav function */
2884 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2886 print_error(filename, err);
2891 for(i=0; i<ic->nb_programs; i++)
2892 if(ic->programs[i]->id != opt_programid)
2893 ic->programs[i]->discard = AVDISCARD_ALL;
2896 ic->loop_input = loop_input;
2898 /* If not enough info to get the stream parameters, we decode the
2899 first frames to get it. (used in mpeg case for example) */
2900 ret = av_find_stream_info(ic);
2901 if (ret < 0 && verbose >= 0) {
2902 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2906 timestamp = start_time;
2907 /* add the stream start time */
2908 if (ic->start_time != AV_NOPTS_VALUE)
2909 timestamp += ic->start_time;
2911 /* if seeking requested, we execute it */
2912 if (start_time != 0) {
2913 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2915 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2916 filename, (double)timestamp / AV_TIME_BASE);
2918 /* reset seek info */
2922 /* update the current parameters so that they match the one of the input stream */
2923 for(i=0;i<ic->nb_streams;i++) {
2924 AVStream *st = ic->streams[i];
2925 AVCodecContext *enc = st->codec;
2927 avcodec_thread_init(enc, thread_count);
2928 enc->thread_count= thread_count;
2929 switch(enc->codec_type) {
2930 case CODEC_TYPE_AUDIO:
2931 set_context_opts(enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2932 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2933 channel_layout = enc->channel_layout;
2934 audio_channels = enc->channels;
2935 audio_sample_rate = enc->sample_rate;
2936 audio_sample_fmt = enc->sample_fmt;
2937 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
2939 st->discard= AVDISCARD_ALL;
2941 case CODEC_TYPE_VIDEO:
2942 set_context_opts(enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2943 frame_height = enc->height;
2944 frame_width = enc->width;
2945 if(ic->streams[i]->sample_aspect_ratio.num)
2946 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
2948 frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
2949 frame_aspect_ratio *= (float) enc->width / enc->height;
2950 frame_pix_fmt = enc->pix_fmt;
2951 rfps = ic->streams[i]->r_frame_rate.num;
2952 rfps_base = ic->streams[i]->r_frame_rate.den;
2954 enc->flags |= CODEC_FLAG_EMU_EDGE;
2955 frame_height >>= enc->lowres;
2956 frame_width >>= enc->lowres;
2959 enc->debug |= FF_DEBUG_MV;
2961 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2964 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2965 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2967 (float)rfps / rfps_base, rfps, rfps_base);
2969 /* update the current frame rate to match the stream frame rate */
2970 frame_rate.num = rfps;
2971 frame_rate.den = rfps_base;
2973 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2975 st->discard= AVDISCARD_ALL;
2976 else if(video_discard)
2977 st->discard= video_discard;
2979 case CODEC_TYPE_DATA:
2981 case CODEC_TYPE_SUBTITLE:
2982 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
2983 if(subtitle_disable)
2984 st->discard = AVDISCARD_ALL;
2986 case CODEC_TYPE_ATTACHMENT:
2987 case CODEC_TYPE_UNKNOWN:
2995 input_files[nb_input_files] = ic;
2996 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2997 /* dump the file content */
2999 dump_format(ic, nb_input_files, filename, 0);
3005 av_freep(&video_codec_name);
3006 av_freep(&audio_codec_name);
3007 av_freep(&subtitle_codec_name);
3010 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3011 int *has_subtitle_ptr)
3013 int has_video, has_audio, has_subtitle, i, j;
3014 AVFormatContext *ic;
3019 for(j=0;j<nb_input_files;j++) {
3020 ic = input_files[j];
3021 for(i=0;i<ic->nb_streams;i++) {
3022 AVCodecContext *enc = ic->streams[i]->codec;
3023 switch(enc->codec_type) {
3024 case CODEC_TYPE_AUDIO:
3027 case CODEC_TYPE_VIDEO:
3030 case CODEC_TYPE_SUBTITLE:
3033 case CODEC_TYPE_DATA:
3034 case CODEC_TYPE_ATTACHMENT:
3035 case CODEC_TYPE_UNKNOWN:
3042 *has_video_ptr = has_video;
3043 *has_audio_ptr = has_audio;
3044 *has_subtitle_ptr = has_subtitle;
3047 static void new_video_stream(AVFormatContext *oc)
3050 AVCodecContext *video_enc;
3051 enum CodecID codec_id;
3053 st = av_new_stream(oc, oc->nb_streams);
3055 fprintf(stderr, "Could not alloc stream\n");
3058 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
3059 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3060 video_bitstream_filters= NULL;
3063 avcodec_thread_init(st->codec, thread_count);
3065 video_enc = st->codec;
3068 video_enc->codec_tag= video_codec_tag;
3070 if( (video_global_header&1)
3071 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3072 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3073 avcodec_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3075 if(video_global_header&2){
3076 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3077 avcodec_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3080 if (video_stream_copy) {
3081 st->stream_copy = 1;
3082 video_enc->codec_type = CODEC_TYPE_VIDEO;
3083 video_enc->sample_aspect_ratio =
3084 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3089 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3091 if (video_codec_name) {
3092 codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3093 codec = avcodec_find_encoder_by_name(video_codec_name);
3094 output_codecs[nb_ocodecs] = codec;
3096 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3097 codec = avcodec_find_encoder(codec_id);
3100 video_enc->codec_id = codec_id;
3102 set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3104 if (codec && codec->supported_framerates && !force_fps)
3105 fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3106 video_enc->time_base.den = fps.num;
3107 video_enc->time_base.num = fps.den;
3109 video_enc->width = frame_width + frame_padright + frame_padleft;
3110 video_enc->height = frame_height + frame_padtop + frame_padbottom;
3111 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3112 video_enc->pix_fmt = frame_pix_fmt;
3113 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3115 if(codec && codec->pix_fmts){
3116 const enum PixelFormat *p= codec->pix_fmts;
3118 if(*p == video_enc->pix_fmt)
3122 video_enc->pix_fmt = codec->pix_fmts[0];
3126 video_enc->gop_size = 0;
3127 if (video_qscale || same_quality) {
3128 video_enc->flags |= CODEC_FLAG_QSCALE;
3129 video_enc->global_quality=
3130 st->quality = FF_QP2LAMBDA * video_qscale;
3134 video_enc->intra_matrix = intra_matrix;
3136 video_enc->inter_matrix = inter_matrix;
3138 video_enc->thread_count = thread_count;
3139 p= video_rc_override_string;
3142 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3144 fprintf(stderr, "error parsing rc_override\n");
3147 video_enc->rc_override=
3148 av_realloc(video_enc->rc_override,
3149 sizeof(RcOverride)*(i+1));
3150 video_enc->rc_override[i].start_frame= start;
3151 video_enc->rc_override[i].end_frame = end;
3153 video_enc->rc_override[i].qscale= q;
3154 video_enc->rc_override[i].quality_factor= 1.0;
3157 video_enc->rc_override[i].qscale= 0;
3158 video_enc->rc_override[i].quality_factor= -q/100.0;
3163 video_enc->rc_override_count=i;
3164 if (!video_enc->rc_initial_buffer_occupancy)
3165 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3166 video_enc->me_threshold= me_threshold;
3167 video_enc->intra_dc_precision= intra_dc_precision - 8;
3170 video_enc->flags|= CODEC_FLAG_PSNR;
3175 video_enc->flags |= CODEC_FLAG_PASS1;
3177 video_enc->flags |= CODEC_FLAG_PASS2;
3183 /* reset some key parameters */
3185 av_freep(&video_codec_name);
3186 video_stream_copy = 0;
3189 static void new_audio_stream(AVFormatContext *oc)
3192 AVCodecContext *audio_enc;
3193 enum CodecID codec_id;
3195 st = av_new_stream(oc, oc->nb_streams);
3197 fprintf(stderr, "Could not alloc stream\n");
3200 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3202 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3203 audio_bitstream_filters= NULL;
3206 avcodec_thread_init(st->codec, thread_count);
3208 audio_enc = st->codec;
3209 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3212 audio_enc->codec_tag= audio_codec_tag;
3214 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3215 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3216 avcodec_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3218 if (audio_stream_copy) {
3219 st->stream_copy = 1;
3220 audio_enc->channels = audio_channels;
3224 set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3226 if (audio_codec_name) {
3227 codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3228 codec = avcodec_find_encoder_by_name(audio_codec_name);
3229 output_codecs[nb_ocodecs] = codec;
3231 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3232 codec = avcodec_find_encoder(codec_id);
3234 audio_enc->codec_id = codec_id;
3236 if (audio_qscale > QSCALE_NONE) {
3237 audio_enc->flags |= CODEC_FLAG_QSCALE;
3238 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3240 audio_enc->thread_count = thread_count;
3241 audio_enc->channels = audio_channels;
3242 audio_enc->sample_fmt = audio_sample_fmt;
3243 audio_enc->channel_layout = channel_layout;
3244 if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3245 audio_enc->channel_layout = 0;
3247 if(codec && codec->sample_fmts){
3248 const enum SampleFormat *p= codec->sample_fmts;
3250 if(*p == audio_enc->sample_fmt)
3254 audio_enc->sample_fmt = codec->sample_fmts[0];
3258 audio_enc->sample_rate = audio_sample_rate;
3259 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3260 if (audio_language) {
3261 av_metadata_set(&st->metadata, "language", audio_language);
3262 av_free(audio_language);
3263 audio_language = NULL;
3266 /* reset some key parameters */
3268 av_freep(&audio_codec_name);
3269 audio_stream_copy = 0;
3272 static void new_subtitle_stream(AVFormatContext *oc)
3275 AVCodecContext *subtitle_enc;
3277 st = av_new_stream(oc, oc->nb_streams);
3279 fprintf(stderr, "Could not alloc stream\n");
3282 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3284 bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3285 subtitle_bitstream_filters= NULL;
3287 subtitle_enc = st->codec;
3288 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3290 if(subtitle_codec_tag)
3291 subtitle_enc->codec_tag= subtitle_codec_tag;
3293 if (subtitle_stream_copy) {
3294 st->stream_copy = 1;
3296 set_context_opts(avcodec_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3297 subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3298 output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3302 if (subtitle_language) {
3303 av_metadata_set(&st->metadata, "language", subtitle_language);
3304 av_free(subtitle_language);
3305 subtitle_language = NULL;
3308 subtitle_disable = 0;
3309 av_freep(&subtitle_codec_name);
3310 subtitle_stream_copy = 0;
3313 static void opt_new_audio_stream(void)
3315 AVFormatContext *oc;
3316 if (nb_output_files <= 0) {
3317 fprintf(stderr, "At least one output file must be specified\n");
3320 oc = output_files[nb_output_files - 1];
3321 new_audio_stream(oc);
3324 static void opt_new_video_stream(void)
3326 AVFormatContext *oc;
3327 if (nb_output_files <= 0) {
3328 fprintf(stderr, "At least one output file must be specified\n");
3331 oc = output_files[nb_output_files - 1];
3332 new_video_stream(oc);
3335 static void opt_new_subtitle_stream(void)
3337 AVFormatContext *oc;
3338 if (nb_output_files <= 0) {
3339 fprintf(stderr, "At least one output file must be specified\n");
3342 oc = output_files[nb_output_files - 1];
3343 new_subtitle_stream(oc);
3346 static void opt_output_file(const char *filename)
3348 AVFormatContext *oc;
3349 int use_video, use_audio, use_subtitle;
3350 int input_has_video, input_has_audio, input_has_subtitle;
3351 AVFormatParameters params, *ap = ¶ms;
3352 AVOutputFormat *file_oformat;
3354 if (!strcmp(filename, "-"))
3357 oc = avformat_alloc_context();
3359 print_error(filename, AVERROR(ENOMEM));
3363 if (last_asked_format) {
3364 file_oformat = guess_format(last_asked_format, NULL, NULL);
3365 if (!file_oformat) {
3366 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3369 last_asked_format = NULL;
3371 file_oformat = guess_format(NULL, filename, NULL);
3372 if (!file_oformat) {
3373 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3379 oc->oformat = file_oformat;
3380 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3382 if (!strcmp(file_oformat->name, "ffm") &&
3383 av_strstart(filename, "http:", NULL)) {
3384 /* special case for files sent to ffserver: we get the stream
3385 parameters from ffserver */
3386 int err = read_ffserver_streams(oc, filename);
3388 print_error(filename, err);
3392 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3393 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3394 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3396 /* disable if no corresponding type found and at least one
3398 if (nb_input_files > 0) {
3399 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3400 &input_has_subtitle);
3401 if (!input_has_video)
3403 if (!input_has_audio)
3405 if (!input_has_subtitle)
3409 /* manual disable */
3410 if (audio_disable) {
3413 if (video_disable) {
3416 if (subtitle_disable) {
3421 new_video_stream(oc);
3425 new_audio_stream(oc);
3429 new_subtitle_stream(oc);
3432 oc->timestamp = rec_timestamp;
3434 for(; metadata_count>0; metadata_count--){
3435 av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3436 metadata[metadata_count-1].value);
3438 av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3441 output_files[nb_output_files++] = oc;
3443 /* check filename in case of an image number is expected */
3444 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3445 if (!av_filename_number_test(oc->filename)) {
3446 print_error(oc->filename, AVERROR_NUMEXPECTED);
3451 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3452 /* test if it already exists to avoid loosing precious files */
3453 if (!file_overwrite &&
3454 (strchr(filename, ':') == NULL ||
3455 filename[1] == ':' ||
3456 av_strstart(filename, "file:", NULL))) {
3457 if (url_exist(filename)) {
3459 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3461 if (!read_yesno()) {
3462 fprintf(stderr, "Not overwriting - exiting\n");
3467 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3474 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3475 fprintf(stderr, "Could not open '%s'\n", filename);
3480 memset(ap, 0, sizeof(*ap));
3481 if (av_set_parameters(oc, ap) < 0) {
3482 fprintf(stderr, "%s: Invalid encoding parameters\n",
3487 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3488 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3489 oc->loop_output = loop_output;
3490 oc->flags |= AVFMT_FLAG_NONBLOCK;
3492 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3495 /* same option as mencoder */
3496 static void opt_pass(const char *pass_str)
3499 pass = atoi(pass_str);
3500 if (pass != 1 && pass != 2) {
3501 fprintf(stderr, "pass number can be only 1 or 2\n");
3507 static int64_t getutime(void)
3510 struct rusage rusage;
3512 getrusage(RUSAGE_SELF, &rusage);
3513 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3514 #elif HAVE_GETPROCESSTIMES
3516 FILETIME c, e, k, u;
3517 proc = GetCurrentProcess();
3518 GetProcessTimes(proc, &c, &e, &k, &u);
3519 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3521 return av_gettime();
3525 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3528 const char *p = str;
3535 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3542 static void opt_inter_matrix(const char *arg)
3544 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3545 parse_matrix_coeffs(inter_matrix, arg);
3548 static void opt_intra_matrix(const char *arg)
3550 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3551 parse_matrix_coeffs(intra_matrix, arg);
3555 * Trivial log callback.
3556 * Only suitable for show_help and similar since it lacks prefix handling.
3558 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3560 vfprintf(stdout, fmt, vl);
3563 static void show_help(void)
3565 av_log_set_callback(log_callback_help);
3566 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3567 "Hyper fast Audio and Video encoder\n");
3569 show_help_options(options, "Main options:\n",
3570 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3571 show_help_options(options, "\nAdvanced options:\n",
3572 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3574 show_help_options(options, "\nVideo options:\n",
3575 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3577 show_help_options(options, "\nAdvanced Video options:\n",
3578 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3579 OPT_VIDEO | OPT_EXPERT);
3580 show_help_options(options, "\nAudio options:\n",
3581 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3583 show_help_options(options, "\nAdvanced Audio options:\n",
3584 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3585 OPT_AUDIO | OPT_EXPERT);
3586 show_help_options(options, "\nSubtitle options:\n",
3587 OPT_SUBTITLE | OPT_GRAB,
3589 show_help_options(options, "\nAudio/Video grab options:\n",
3593 av_opt_show(avcodec_opts[0], NULL);
3595 av_opt_show(avformat_opts, NULL);
3597 av_opt_show(sws_opts, NULL);
3600 static void opt_target(const char *arg)
3602 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3603 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3605 if(!strncmp(arg, "pal-", 4)) {
3608 } else if(!strncmp(arg, "ntsc-", 5)) {
3611 } else if(!strncmp(arg, "film-", 5)) {
3616 /* Calculate FR via float to avoid int overflow */
3617 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3620 } else if((fr == 29970) || (fr == 23976)) {
3623 /* Try to determine PAL/NTSC by peeking in the input files */
3624 if(nb_input_files) {
3626 for(j = 0; j < nb_input_files; j++) {
3627 for(i = 0; i < input_files[j]->nb_streams; i++) {
3628 AVCodecContext *c = input_files[j]->streams[i]->codec;
3629 if(c->codec_type != CODEC_TYPE_VIDEO)
3631 fr = c->time_base.den * 1000 / c->time_base.num;
3635 } else if((fr == 29970) || (fr == 23976)) {
3645 if(verbose && norm != UNKNOWN)
3646 fprintf(stderr, "Assuming %s for target.\n", norm != PAL ? "NTSC" : "PAL");
3649 if(norm == UNKNOWN) {
3650 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3651 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3652 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3656 if(!strcmp(arg, "vcd")) {
3658 opt_video_codec("mpeg1video");
3659 opt_audio_codec("mp2");
3662 opt_frame_size(norm != PAL ? "352x240" : "352x288");
3663 opt_frame_rate(NULL, frame_rates[norm]);
3664 opt_default("g", norm != PAL ? "18" : "15");
3666 opt_default("b", "1150000");
3667 opt_default("maxrate", "1150000");
3668 opt_default("minrate", "1150000");
3669 opt_default("bufsize", "327680"); // 40*1024*8;
3671 opt_default("ab", "224000");
3672 audio_sample_rate = 44100;
3675 opt_default("packetsize", "2324");
3676 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3678 /* We have to offset the PTS, so that it is consistent with the SCR.
3679 SCR starts at 36000, but the first two packs contain only padding
3680 and the first pack from the other stream, respectively, may also have
3681 been written before.
3682 So the real data starts at SCR 36000+3*1200. */
3683 mux_preload= (36000+3*1200) / 90000.0; //0.44
3684 } else if(!strcmp(arg, "svcd")) {
3686 opt_video_codec("mpeg2video");
3687 opt_audio_codec("mp2");
3690 opt_frame_size(norm != PAL ? "480x480" : "480x576");
3691 opt_frame_rate(NULL, frame_rates[norm]);
3692 opt_default("g", norm != PAL ? "18" : "15");
3694 opt_default("b", "2040000");
3695 opt_default("maxrate", "2516000");
3696 opt_default("minrate", "0"); //1145000;
3697 opt_default("bufsize", "1835008"); //224*1024*8;
3698 opt_default("flags", "+scan_offset");
3701 opt_default("ab", "224000");
3702 audio_sample_rate = 44100;
3704 opt_default("packetsize", "2324");
3706 } else if(!strcmp(arg, "dvd")) {
3708 opt_video_codec("mpeg2video");
3709 opt_audio_codec("ac3");
3712 opt_frame_size(norm != PAL ? "720x480" : "720x576");
3713 opt_frame_rate(NULL, frame_rates[norm]);
3714 opt_default("g", norm != PAL ? "18" : "15");
3716 opt_default("b", "6000000");
3717 opt_default("maxrate", "9000000");
3718 opt_default("minrate", "0"); //1500000;
3719 opt_default("bufsize", "1835008"); //224*1024*8;
3721 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3722 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3724 opt_default("ab", "448000");
3725 audio_sample_rate = 48000;
3727 } else if(!strncmp(arg, "dv", 2)) {
3731 opt_frame_size(norm != PAL ? "720x480" : "720x576");
3732 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3733 (norm != PAL ? "yuv411p" : "yuv420p"));
3734 opt_frame_rate(NULL, frame_rates[norm]);
3736 audio_sample_rate = 48000;
3740 fprintf(stderr, "Unknown target: %s\n", arg);
3745 static void opt_vstats_file (const char *arg)
3747 av_free (vstats_filename);
3748 vstats_filename=av_strdup (arg);
3751 static void opt_vstats (void)
3754 time_t today2 = time(NULL);
3755 struct tm *today = localtime(&today2);
3757 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3759 opt_vstats_file(filename);
3762 static int opt_bsf(const char *opt, const char *arg)
3764 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3765 AVBitStreamFilterContext **bsfp;
3768 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3772 bsfp= *opt == 'v' ? &video_bitstream_filters :
3773 *opt == 'a' ? &audio_bitstream_filters :
3774 &subtitle_bitstream_filters;
3776 bsfp= &(*bsfp)->next;
3783 static int opt_preset(const char *opt, const char *arg)
3786 char filename[1000], tmp[1000], tmp2[1000], line[1000];
3788 const char *base[2]= { getenv("HOME"),
3793 for(i=!base[0]; i<2 && !f; i++){
3794 snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
3795 f= fopen(filename, "r");
3797 char *codec_name= *opt == 'v' ? video_codec_name :
3798 *opt == 'a' ? audio_codec_name :
3799 subtitle_codec_name;
3800 snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i], i ? "" : "/.ffmpeg", codec_name, arg);
3801 f= fopen(filename, "r");
3805 av_strlcpy(filename, arg, sizeof(filename));
3806 f= fopen(filename, "r");
3810 fprintf(stderr, "File for preset '%s' not found\n", arg);
3815 int e= fscanf(f, "%999[^\n]\n", line) - 1;
3816 if(line[0] == '#' && !e)
3818 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3820 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3823 if(!strcmp(tmp, "acodec")){
3824 opt_audio_codec(tmp2);
3825 }else if(!strcmp(tmp, "vcodec")){
3826 opt_video_codec(tmp2);
3827 }else if(!strcmp(tmp, "scodec")){
3828 opt_subtitle_codec(tmp2);
3829 }else if(opt_default(tmp, tmp2) < 0){
3830 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3840 static const OptionDef options[] = {
3842 #include "cmdutils_common_opts.h"
3843 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3844 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3845 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3846 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3847 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3848 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3849 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3850 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3851 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3852 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
3853 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_rec_timestamp}, "set the timestamp ('now' to set the current time)", "time" },
3854 { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
3855 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3856 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3857 "add timings for benchmarking" },
3858 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3859 "dump each input packet" },
3860 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3861 "when dumping packets, also dump the payload" },
3862 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3863 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3864 { "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)", "" },
3865 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
3866 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3867 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3868 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3869 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3870 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3871 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3872 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3873 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3874 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3875 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3876 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
3877 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
3880 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3881 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3882 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3883 { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3884 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3885 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3886 { "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" },
3887 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3888 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3889 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3890 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3891 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3892 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3893 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3894 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3895 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3896 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3897 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3898 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3899 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3900 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3901 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3902 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
3903 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3904 "use same video quality as source (implies VBR)" },
3905 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3906 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
3907 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3908 "deinterlace pictures" },
3909 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3910 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3911 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3912 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3913 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3914 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3915 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3916 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3917 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3918 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3919 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
3922 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3923 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3924 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3925 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3926 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3927 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3928 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3929 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3930 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3931 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3932 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3933 { "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" },
3935 /* subtitle options */
3936 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3937 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3938 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3939 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3940 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
3943 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3944 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3945 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3948 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3949 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3951 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3952 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3953 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3955 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3956 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3957 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3958 { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
3960 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3964 int main(int argc, char **argv)
3969 avcodec_register_all();
3970 avdevice_register_all();
3974 if(isatty(STDIN_FILENO))
3975 url_set_interrupt_cb(decode_interrupt_cb);
3978 for(i=0; i<CODEC_TYPE_NB; i++){
3979 avcodec_opts[i]= avcodec_alloc_context2(i);
3981 avformat_opts = avformat_alloc_context();
3982 sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3987 parse_options(argc, argv, options, opt_output_file);
3989 if(nb_output_files <= 0 && nb_input_files == 0)
3992 /* file converter / grab */
3993 if (nb_output_files <= 0) {
3994 fprintf(stderr, "At least one output file must be specified\n");
3998 if (nb_input_files == 0) {
3999 fprintf(stderr, "At least one input file must be specified\n");
4004 if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
4005 stream_maps, nb_stream_maps) < 0)
4007 ti = getutime() - ti;
4009 printf("bench: utime=%0.3fs\n", ti / 1000000.0);