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; //saftey 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;
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);
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 list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2571 for (i=-1; i < nb_fmts; i++) {
2572 get_fmt_string (fmt_str, sizeof(fmt_str), i);
2573 fprintf(stdout, "%s\n", fmt_str);
2577 static void opt_frame_pix_fmt(const char *arg)
2579 if (strcmp(arg, "list")) {
2580 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2581 if (frame_pix_fmt == PIX_FMT_NONE) {
2582 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2586 list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2591 static void opt_frame_aspect_ratio(const char *arg)
2598 p = strchr(arg, ':');
2600 x = strtol(arg, &end, 10);
2602 y = strtol(end+1, &end, 10);
2604 ar = (double)x / (double)y;
2606 ar = strtod(arg, NULL);
2609 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2612 frame_aspect_ratio = ar;
2615 static int opt_metadata(const char *opt, const char *arg)
2617 char *mid= strchr(arg, '=');
2620 fprintf(stderr, "Missing =\n");
2626 metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2627 metadata[metadata_count-1].key = av_strdup(arg);
2628 metadata[metadata_count-1].value= av_strdup(mid);
2633 static void opt_qscale(const char *arg)
2635 video_qscale = atof(arg);
2636 if (video_qscale <= 0 ||
2637 video_qscale > 255) {
2638 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2643 static void opt_top_field_first(const char *arg)
2645 top_field_first= atoi(arg);
2648 static int opt_thread_count(const char *opt, const char *arg)
2650 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2653 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2658 static void opt_audio_sample_fmt(const char *arg)
2660 if (strcmp(arg, "list"))
2661 audio_sample_fmt = avcodec_get_sample_fmt(arg);
2663 list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2668 static int opt_audio_rate(const char *opt, const char *arg)
2670 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2674 static int opt_audio_channels(const char *opt, const char *arg)
2676 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2680 static void opt_video_channel(const char *arg)
2682 video_channel = strtol(arg, NULL, 0);
2685 static void opt_video_standard(const char *arg)
2687 video_standard = av_strdup(arg);
2690 static void opt_codec(int *pstream_copy, char **pcodec_name,
2691 int codec_type, const char *arg)
2693 av_freep(pcodec_name);
2694 if (!strcmp(arg, "copy")) {
2697 *pcodec_name = av_strdup(arg);
2701 static void opt_audio_codec(const char *arg)
2703 opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2706 static void opt_audio_tag(const char *arg)
2709 audio_codec_tag= strtol(arg, &tail, 0);
2712 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2715 static void opt_video_tag(const char *arg)
2718 video_codec_tag= strtol(arg, &tail, 0);
2721 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2724 static void opt_video_codec(const char *arg)
2726 opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2729 static void opt_subtitle_codec(const char *arg)
2731 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2734 static void opt_subtitle_tag(const char *arg)
2737 subtitle_codec_tag= strtol(arg, &tail, 0);
2740 subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2743 static void opt_map(const char *arg)
2748 m = &stream_maps[nb_stream_maps++];
2750 m->file_index = strtol(arg, &p, 0);
2754 m->stream_index = strtol(p, &p, 0);
2757 m->sync_file_index = strtol(p, &p, 0);
2760 m->sync_stream_index = strtol(p, &p, 0);
2762 m->sync_file_index = m->file_index;
2763 m->sync_stream_index = m->stream_index;
2767 static void opt_map_meta_data(const char *arg)
2772 m = &meta_data_maps[nb_meta_data_maps++];
2774 m->out_file = strtol(arg, &p, 0);
2778 m->in_file = strtol(p, &p, 0);
2781 static void opt_input_ts_scale(const char *arg)
2783 unsigned int stream;
2787 stream = strtol(arg, &p, 0);
2790 scale= strtod(p, &p);
2792 if(stream >= MAX_STREAMS)
2795 input_files_ts_scale[nb_input_files][stream]= scale;
2798 static int opt_recording_time(const char *opt, const char *arg)
2800 recording_time = parse_time_or_die(opt, arg, 1);
2804 static int opt_start_time(const char *opt, const char *arg)
2806 start_time = parse_time_or_die(opt, arg, 1);
2810 static int opt_rec_timestamp(const char *opt, const char *arg)
2812 rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2816 static int opt_input_ts_offset(const char *opt, const char *arg)
2818 input_ts_offset = parse_time_or_die(opt, arg, 1);
2822 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2824 const char *codec_string = encoder ? "encoder" : "decoder";
2828 return CODEC_ID_NONE;
2830 avcodec_find_encoder_by_name(name) :
2831 avcodec_find_decoder_by_name(name);
2833 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2836 if(codec->type != type) {
2837 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2843 static void opt_input_file(const char *filename)
2845 AVFormatContext *ic;
2846 AVFormatParameters params, *ap = ¶ms;
2847 AVInputFormat *file_iformat = NULL;
2848 int err, i, ret, rfps, rfps_base;
2851 if (last_asked_format) {
2852 file_iformat = av_find_input_format(last_asked_format);
2853 last_asked_format = NULL;
2856 if (!strcmp(filename, "-"))
2859 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2860 !strcmp(filename, "/dev/stdin");
2862 /* get default parameters from command line */
2863 ic = avformat_alloc_context();
2865 print_error(filename, AVERROR(ENOMEM));
2869 memset(ap, 0, sizeof(*ap));
2870 ap->prealloced_context = 1;
2871 ap->sample_rate = audio_sample_rate;
2872 ap->channels = audio_channels;
2873 ap->time_base.den = frame_rate.num;
2874 ap->time_base.num = frame_rate.den;
2875 ap->width = frame_width + frame_padleft + frame_padright;
2876 ap->height = frame_height + frame_padtop + frame_padbottom;
2877 ap->pix_fmt = frame_pix_fmt;
2878 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2879 ap->channel = video_channel;
2880 ap->standard = video_standard;
2881 ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2882 ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2883 if(pgmyuv_compatibility_hack)
2884 ap->video_codec_id= CODEC_ID_PGMYUV;
2886 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2888 ic->video_codec_id = find_codec_or_die(video_codec_name , CODEC_TYPE_VIDEO , 0);
2889 ic->audio_codec_id = find_codec_or_die(audio_codec_name , CODEC_TYPE_AUDIO , 0);
2890 ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2891 ic->flags |= AVFMT_FLAG_NONBLOCK;
2893 /* open the input file with generic libav function */
2894 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2896 print_error(filename, err);
2901 for(i=0; i<ic->nb_programs; i++)
2902 if(ic->programs[i]->id != opt_programid)
2903 ic->programs[i]->discard = AVDISCARD_ALL;
2906 ic->loop_input = loop_input;
2908 /* If not enough info to get the stream parameters, we decode the
2909 first frames to get it. (used in mpeg case for example) */
2910 ret = av_find_stream_info(ic);
2911 if (ret < 0 && verbose >= 0) {
2912 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2916 timestamp = start_time;
2917 /* add the stream start time */
2918 if (ic->start_time != AV_NOPTS_VALUE)
2919 timestamp += ic->start_time;
2921 /* if seeking requested, we execute it */
2922 if (start_time != 0) {
2923 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2925 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2926 filename, (double)timestamp / AV_TIME_BASE);
2928 /* reset seek info */
2932 /* update the current parameters so that they match the one of the input stream */
2933 for(i=0;i<ic->nb_streams;i++) {
2934 AVCodecContext *enc = ic->streams[i]->codec;
2936 avcodec_thread_init(enc, thread_count);
2937 enc->thread_count= thread_count;
2938 switch(enc->codec_type) {
2939 case CODEC_TYPE_AUDIO:
2940 set_context_opts(enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2941 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2942 channel_layout = enc->channel_layout;
2943 audio_channels = enc->channels;
2944 audio_sample_rate = enc->sample_rate;
2945 audio_sample_fmt = enc->sample_fmt;
2946 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
2948 ic->streams[i]->discard= AVDISCARD_ALL;
2950 case CODEC_TYPE_VIDEO:
2951 set_context_opts(enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2952 frame_height = enc->height;
2953 frame_width = enc->width;
2954 if(ic->streams[i]->sample_aspect_ratio.num)
2955 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
2957 frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
2958 frame_aspect_ratio *= (float) enc->width / enc->height;
2959 frame_pix_fmt = enc->pix_fmt;
2960 rfps = ic->streams[i]->r_frame_rate.num;
2961 rfps_base = ic->streams[i]->r_frame_rate.den;
2963 enc->flags |= CODEC_FLAG_EMU_EDGE;
2964 frame_height >>= enc->lowres;
2965 frame_width >>= enc->lowres;
2968 enc->debug |= FF_DEBUG_MV;
2970 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2973 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2974 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2976 (float)rfps / rfps_base, rfps, rfps_base);
2978 /* update the current frame rate to match the stream frame rate */
2979 frame_rate.num = rfps;
2980 frame_rate.den = rfps_base;
2982 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2984 ic->streams[i]->discard= AVDISCARD_ALL;
2985 else if(video_discard)
2986 ic->streams[i]->discard= video_discard;
2988 case CODEC_TYPE_DATA:
2990 case CODEC_TYPE_SUBTITLE:
2991 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
2992 if(subtitle_disable)
2993 ic->streams[i]->discard = AVDISCARD_ALL;
2995 case CODEC_TYPE_ATTACHMENT:
2996 case CODEC_TYPE_UNKNOWN:
3004 input_files[nb_input_files] = ic;
3005 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3006 /* dump the file content */
3008 dump_format(ic, nb_input_files, filename, 0);
3014 av_freep(&video_codec_name);
3015 av_freep(&audio_codec_name);
3016 av_freep(&subtitle_codec_name);
3019 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3020 int *has_subtitle_ptr)
3022 int has_video, has_audio, has_subtitle, i, j;
3023 AVFormatContext *ic;
3028 for(j=0;j<nb_input_files;j++) {
3029 ic = input_files[j];
3030 for(i=0;i<ic->nb_streams;i++) {
3031 AVCodecContext *enc = ic->streams[i]->codec;
3032 switch(enc->codec_type) {
3033 case CODEC_TYPE_AUDIO:
3036 case CODEC_TYPE_VIDEO:
3039 case CODEC_TYPE_SUBTITLE:
3042 case CODEC_TYPE_DATA:
3043 case CODEC_TYPE_ATTACHMENT:
3044 case CODEC_TYPE_UNKNOWN:
3051 *has_video_ptr = has_video;
3052 *has_audio_ptr = has_audio;
3053 *has_subtitle_ptr = has_subtitle;
3056 static void new_video_stream(AVFormatContext *oc)
3059 AVCodecContext *video_enc;
3060 enum CodecID codec_id;
3062 st = av_new_stream(oc, oc->nb_streams);
3064 fprintf(stderr, "Could not alloc stream\n");
3067 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
3068 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3069 video_bitstream_filters= NULL;
3072 avcodec_thread_init(st->codec, thread_count);
3074 video_enc = st->codec;
3077 video_enc->codec_tag= video_codec_tag;
3079 if( (video_global_header&1)
3080 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3081 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3082 avcodec_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3084 if(video_global_header&2){
3085 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3086 avcodec_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3089 if (video_stream_copy) {
3090 st->stream_copy = 1;
3091 video_enc->codec_type = CODEC_TYPE_VIDEO;
3092 video_enc->sample_aspect_ratio =
3093 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3098 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3100 if (video_codec_name) {
3101 codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3102 codec = avcodec_find_encoder_by_name(video_codec_name);
3103 output_codecs[nb_ocodecs] = codec;
3105 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3106 codec = avcodec_find_encoder(codec_id);
3109 video_enc->codec_id = codec_id;
3111 set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3113 if (codec && codec->supported_framerates && !force_fps)
3114 fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3115 video_enc->time_base.den = fps.num;
3116 video_enc->time_base.num = fps.den;
3118 video_enc->width = frame_width + frame_padright + frame_padleft;
3119 video_enc->height = frame_height + frame_padtop + frame_padbottom;
3120 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3121 video_enc->pix_fmt = frame_pix_fmt;
3122 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3124 if(codec && codec->pix_fmts){
3125 const enum PixelFormat *p= codec->pix_fmts;
3127 if(*p == video_enc->pix_fmt)
3131 video_enc->pix_fmt = codec->pix_fmts[0];
3135 video_enc->gop_size = 0;
3136 if (video_qscale || same_quality) {
3137 video_enc->flags |= CODEC_FLAG_QSCALE;
3138 video_enc->global_quality=
3139 st->quality = FF_QP2LAMBDA * video_qscale;
3143 video_enc->intra_matrix = intra_matrix;
3145 video_enc->inter_matrix = inter_matrix;
3147 video_enc->thread_count = thread_count;
3148 p= video_rc_override_string;
3151 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3153 fprintf(stderr, "error parsing rc_override\n");
3156 video_enc->rc_override=
3157 av_realloc(video_enc->rc_override,
3158 sizeof(RcOverride)*(i+1));
3159 video_enc->rc_override[i].start_frame= start;
3160 video_enc->rc_override[i].end_frame = end;
3162 video_enc->rc_override[i].qscale= q;
3163 video_enc->rc_override[i].quality_factor= 1.0;
3166 video_enc->rc_override[i].qscale= 0;
3167 video_enc->rc_override[i].quality_factor= -q/100.0;
3172 video_enc->rc_override_count=i;
3173 if (!video_enc->rc_initial_buffer_occupancy)
3174 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3175 video_enc->me_threshold= me_threshold;
3176 video_enc->intra_dc_precision= intra_dc_precision - 8;
3179 video_enc->flags|= CODEC_FLAG_PSNR;
3184 video_enc->flags |= CODEC_FLAG_PASS1;
3186 video_enc->flags |= CODEC_FLAG_PASS2;
3192 /* reset some key parameters */
3194 av_freep(&video_codec_name);
3195 video_stream_copy = 0;
3198 static void new_audio_stream(AVFormatContext *oc)
3201 AVCodecContext *audio_enc;
3202 enum CodecID codec_id;
3204 st = av_new_stream(oc, oc->nb_streams);
3206 fprintf(stderr, "Could not alloc stream\n");
3209 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3211 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3212 audio_bitstream_filters= NULL;
3215 avcodec_thread_init(st->codec, thread_count);
3217 audio_enc = st->codec;
3218 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3221 audio_enc->codec_tag= audio_codec_tag;
3223 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3224 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3225 avcodec_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3227 if (audio_stream_copy) {
3228 st->stream_copy = 1;
3229 audio_enc->channels = audio_channels;
3233 set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3235 if (audio_codec_name) {
3236 codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3237 codec = avcodec_find_encoder_by_name(audio_codec_name);
3238 output_codecs[nb_ocodecs] = codec;
3240 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3241 codec = avcodec_find_encoder(codec_id);
3243 audio_enc->codec_id = codec_id;
3245 if (audio_qscale > QSCALE_NONE) {
3246 audio_enc->flags |= CODEC_FLAG_QSCALE;
3247 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3249 audio_enc->thread_count = thread_count;
3250 audio_enc->channels = audio_channels;
3251 audio_enc->sample_fmt = audio_sample_fmt;
3252 audio_enc->channel_layout = channel_layout;
3253 if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3254 audio_enc->channel_layout = 0;
3256 if(codec && codec->sample_fmts){
3257 const enum SampleFormat *p= codec->sample_fmts;
3259 if(*p == audio_enc->sample_fmt)
3263 audio_enc->sample_fmt = codec->sample_fmts[0];
3267 audio_enc->sample_rate = audio_sample_rate;
3268 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3269 if (audio_language) {
3270 av_metadata_set(&st->metadata, "language", audio_language);
3271 av_free(audio_language);
3272 audio_language = NULL;
3275 /* reset some key parameters */
3277 av_freep(&audio_codec_name);
3278 audio_stream_copy = 0;
3281 static void new_subtitle_stream(AVFormatContext *oc)
3284 AVCodecContext *subtitle_enc;
3286 st = av_new_stream(oc, oc->nb_streams);
3288 fprintf(stderr, "Could not alloc stream\n");
3291 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3293 bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3294 subtitle_bitstream_filters= NULL;
3296 subtitle_enc = st->codec;
3297 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3299 if(subtitle_codec_tag)
3300 subtitle_enc->codec_tag= subtitle_codec_tag;
3302 if (subtitle_stream_copy) {
3303 st->stream_copy = 1;
3305 set_context_opts(avcodec_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3306 subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3307 output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3311 if (subtitle_language) {
3312 av_metadata_set(&st->metadata, "language", subtitle_language);
3313 av_free(subtitle_language);
3314 subtitle_language = NULL;
3317 subtitle_disable = 0;
3318 av_freep(&subtitle_codec_name);
3319 subtitle_stream_copy = 0;
3322 static void opt_new_audio_stream(void)
3324 AVFormatContext *oc;
3325 if (nb_output_files <= 0) {
3326 fprintf(stderr, "At least one output file must be specified\n");
3329 oc = output_files[nb_output_files - 1];
3330 new_audio_stream(oc);
3333 static void opt_new_video_stream(void)
3335 AVFormatContext *oc;
3336 if (nb_output_files <= 0) {
3337 fprintf(stderr, "At least one output file must be specified\n");
3340 oc = output_files[nb_output_files - 1];
3341 new_video_stream(oc);
3344 static void opt_new_subtitle_stream(void)
3346 AVFormatContext *oc;
3347 if (nb_output_files <= 0) {
3348 fprintf(stderr, "At least one output file must be specified\n");
3351 oc = output_files[nb_output_files - 1];
3352 new_subtitle_stream(oc);
3355 static void opt_output_file(const char *filename)
3357 AVFormatContext *oc;
3358 int use_video, use_audio, use_subtitle;
3359 int input_has_video, input_has_audio, input_has_subtitle;
3360 AVFormatParameters params, *ap = ¶ms;
3361 AVOutputFormat *file_oformat;
3363 if (!strcmp(filename, "-"))
3366 oc = avformat_alloc_context();
3368 print_error(filename, AVERROR(ENOMEM));
3372 if (last_asked_format) {
3373 file_oformat = guess_format(last_asked_format, NULL, NULL);
3374 if (!file_oformat) {
3375 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3378 last_asked_format = NULL;
3380 file_oformat = guess_format(NULL, filename, NULL);
3381 if (!file_oformat) {
3382 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3388 oc->oformat = file_oformat;
3389 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3391 if (!strcmp(file_oformat->name, "ffm") &&
3392 av_strstart(filename, "http:", NULL)) {
3393 /* special case for files sent to ffserver: we get the stream
3394 parameters from ffserver */
3395 int err = read_ffserver_streams(oc, filename);
3397 print_error(filename, err);
3401 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3402 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3403 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3405 /* disable if no corresponding type found and at least one
3407 if (nb_input_files > 0) {
3408 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3409 &input_has_subtitle);
3410 if (!input_has_video)
3412 if (!input_has_audio)
3414 if (!input_has_subtitle)
3418 /* manual disable */
3419 if (audio_disable) {
3422 if (video_disable) {
3425 if (subtitle_disable) {
3430 new_video_stream(oc);
3434 new_audio_stream(oc);
3438 new_subtitle_stream(oc);
3441 oc->timestamp = rec_timestamp;
3443 for(; metadata_count>0; metadata_count--){
3444 av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3445 metadata[metadata_count-1].value);
3447 av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3450 output_files[nb_output_files++] = oc;
3452 /* check filename in case of an image number is expected */
3453 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3454 if (!av_filename_number_test(oc->filename)) {
3455 print_error(oc->filename, AVERROR_NUMEXPECTED);
3460 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3461 /* test if it already exists to avoid loosing precious files */
3462 if (!file_overwrite &&
3463 (strchr(filename, ':') == NULL ||
3464 filename[1] == ':' ||
3465 av_strstart(filename, "file:", NULL))) {
3466 if (url_exist(filename)) {
3468 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3470 if (!read_yesno()) {
3471 fprintf(stderr, "Not overwriting - exiting\n");
3476 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3483 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3484 fprintf(stderr, "Could not open '%s'\n", filename);
3489 memset(ap, 0, sizeof(*ap));
3490 if (av_set_parameters(oc, ap) < 0) {
3491 fprintf(stderr, "%s: Invalid encoding parameters\n",
3496 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3497 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3498 oc->loop_output = loop_output;
3499 oc->flags |= AVFMT_FLAG_NONBLOCK;
3501 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3504 /* same option as mencoder */
3505 static void opt_pass(const char *pass_str)
3508 pass = atoi(pass_str);
3509 if (pass != 1 && pass != 2) {
3510 fprintf(stderr, "pass number can be only 1 or 2\n");
3516 static int64_t getutime(void)
3519 struct rusage rusage;
3521 getrusage(RUSAGE_SELF, &rusage);
3522 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3523 #elif HAVE_GETPROCESSTIMES
3525 FILETIME c, e, k, u;
3526 proc = GetCurrentProcess();
3527 GetProcessTimes(proc, &c, &e, &k, &u);
3528 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3530 return av_gettime();
3534 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3537 const char *p = str;
3544 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3551 static void opt_inter_matrix(const char *arg)
3553 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3554 parse_matrix_coeffs(inter_matrix, arg);
3557 static void opt_intra_matrix(const char *arg)
3559 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3560 parse_matrix_coeffs(intra_matrix, arg);
3564 * Trivial log callback.
3565 * Only suitable for show_help and similar since it lacks prefix handling.
3567 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3569 vfprintf(stdout, fmt, vl);
3572 static void show_help(void)
3574 av_log_set_callback(log_callback_help);
3575 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3576 "Hyper fast Audio and Video encoder\n");
3578 show_help_options(options, "Main options:\n",
3579 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3580 show_help_options(options, "\nAdvanced options:\n",
3581 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3583 show_help_options(options, "\nVideo options:\n",
3584 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3586 show_help_options(options, "\nAdvanced Video options:\n",
3587 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3588 OPT_VIDEO | OPT_EXPERT);
3589 show_help_options(options, "\nAudio options:\n",
3590 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3592 show_help_options(options, "\nAdvanced Audio options:\n",
3593 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3594 OPT_AUDIO | OPT_EXPERT);
3595 show_help_options(options, "\nSubtitle options:\n",
3596 OPT_SUBTITLE | OPT_GRAB,
3598 show_help_options(options, "\nAudio/Video grab options:\n",
3602 av_opt_show(avcodec_opts[0], NULL);
3604 av_opt_show(avformat_opts, NULL);
3606 av_opt_show(sws_opts, NULL);
3609 static void opt_target(const char *arg)
3612 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3614 if(!strncmp(arg, "pal-", 4)) {
3617 } else if(!strncmp(arg, "ntsc-", 5)) {
3620 } else if(!strncmp(arg, "film-", 5)) {
3625 /* Calculate FR via float to avoid int overflow */
3626 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3629 } else if((fr == 29970) || (fr == 23976)) {
3632 /* Try to determine PAL/NTSC by peeking in the input files */
3633 if(nb_input_files) {
3635 for(j = 0; j < nb_input_files; j++) {
3636 for(i = 0; i < input_files[j]->nb_streams; i++) {
3637 AVCodecContext *c = input_files[j]->streams[i]->codec;
3638 if(c->codec_type != CODEC_TYPE_VIDEO)
3640 fr = c->time_base.den * 1000 / c->time_base.num;
3644 } else if((fr == 29970) || (fr == 23976)) {
3654 if(verbose && norm >= 0)
3655 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3659 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3660 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3661 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3665 if(!strcmp(arg, "vcd")) {
3667 opt_video_codec("mpeg1video");
3668 opt_audio_codec("mp2");
3671 opt_frame_size(norm ? "352x240" : "352x288");
3672 opt_frame_rate(NULL, frame_rates[norm]);
3673 opt_default("g", norm ? "18" : "15");
3675 opt_default("b", "1150000");
3676 opt_default("maxrate", "1150000");
3677 opt_default("minrate", "1150000");
3678 opt_default("bufsize", "327680"); // 40*1024*8;
3680 opt_default("ab", "224000");
3681 audio_sample_rate = 44100;
3684 opt_default("packetsize", "2324");
3685 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3687 /* We have to offset the PTS, so that it is consistent with the SCR.
3688 SCR starts at 36000, but the first two packs contain only padding
3689 and the first pack from the other stream, respectively, may also have
3690 been written before.
3691 So the real data starts at SCR 36000+3*1200. */
3692 mux_preload= (36000+3*1200) / 90000.0; //0.44
3693 } else if(!strcmp(arg, "svcd")) {
3695 opt_video_codec("mpeg2video");
3696 opt_audio_codec("mp2");
3699 opt_frame_size(norm ? "480x480" : "480x576");
3700 opt_frame_rate(NULL, frame_rates[norm]);
3701 opt_default("g", norm ? "18" : "15");
3703 opt_default("b", "2040000");
3704 opt_default("maxrate", "2516000");
3705 opt_default("minrate", "0"); //1145000;
3706 opt_default("bufsize", "1835008"); //224*1024*8;
3707 opt_default("flags", "+scan_offset");
3710 opt_default("ab", "224000");
3711 audio_sample_rate = 44100;
3713 opt_default("packetsize", "2324");
3715 } else if(!strcmp(arg, "dvd")) {
3717 opt_video_codec("mpeg2video");
3718 opt_audio_codec("ac3");
3721 opt_frame_size(norm ? "720x480" : "720x576");
3722 opt_frame_rate(NULL, frame_rates[norm]);
3723 opt_default("g", norm ? "18" : "15");
3725 opt_default("b", "6000000");
3726 opt_default("maxrate", "9000000");
3727 opt_default("minrate", "0"); //1500000;
3728 opt_default("bufsize", "1835008"); //224*1024*8;
3730 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3731 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3733 opt_default("ab", "448000");
3734 audio_sample_rate = 48000;
3736 } else if(!strncmp(arg, "dv", 2)) {
3740 opt_frame_size(norm ? "720x480" : "720x576");
3741 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3742 (norm ? "yuv411p" : "yuv420p"));
3743 opt_frame_rate(NULL, frame_rates[norm]);
3745 audio_sample_rate = 48000;
3749 fprintf(stderr, "Unknown target: %s\n", arg);
3754 static void opt_vstats_file (const char *arg)
3756 av_free (vstats_filename);
3757 vstats_filename=av_strdup (arg);
3760 static void opt_vstats (void)
3763 time_t today2 = time(NULL);
3764 struct tm *today = localtime(&today2);
3766 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3768 opt_vstats_file(filename);
3771 static int opt_bsf(const char *opt, const char *arg)
3773 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3774 AVBitStreamFilterContext **bsfp;
3777 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3781 bsfp= *opt == 'v' ? &video_bitstream_filters :
3782 *opt == 'a' ? &audio_bitstream_filters :
3783 &subtitle_bitstream_filters;
3785 bsfp= &(*bsfp)->next;
3792 static int opt_preset(const char *opt, const char *arg)
3795 char filename[1000], tmp[1000], tmp2[1000], line[1000];
3797 const char *base[2]= { getenv("HOME"),
3802 for(i=!base[0]; i<2 && !f; i++){
3803 snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
3804 f= fopen(filename, "r");
3806 char *codec_name= *opt == 'v' ? video_codec_name :
3807 *opt == 'a' ? audio_codec_name :
3808 subtitle_codec_name;
3809 snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i], i ? "" : "/.ffmpeg", codec_name, arg);
3810 f= fopen(filename, "r");
3814 av_strlcpy(filename, arg, sizeof(filename));
3815 f= fopen(filename, "r");
3819 fprintf(stderr, "File for preset '%s' not found\n", arg);
3824 int e= fscanf(f, "%999[^\n]\n", line) - 1;
3825 if(line[0] == '#' && !e)
3827 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3829 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3832 if(!strcmp(tmp, "acodec")){
3833 opt_audio_codec(tmp2);
3834 }else if(!strcmp(tmp, "vcodec")){
3835 opt_video_codec(tmp2);
3836 }else if(!strcmp(tmp, "scodec")){
3837 opt_subtitle_codec(tmp2);
3838 }else if(opt_default(tmp, tmp2) < 0){
3839 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3849 static const OptionDef options[] = {
3851 #include "cmdutils_common_opts.h"
3852 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3853 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3854 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3855 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3856 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3857 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3858 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3859 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3860 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3861 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
3862 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_rec_timestamp}, "set the timestamp ('now' to set the current time)", "time" },
3863 { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
3864 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3865 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3866 "add timings for benchmarking" },
3867 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3868 "dump each input packet" },
3869 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3870 "when dumping packets, also dump the payload" },
3871 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3872 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3873 { "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)", "" },
3874 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
3875 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3876 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3877 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3878 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3879 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3880 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3881 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3882 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3883 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3884 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3885 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
3886 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
3889 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3890 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3891 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3892 { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3893 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3894 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3895 { "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" },
3896 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3897 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3898 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3899 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3900 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3901 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3902 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3903 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3904 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3905 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3906 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3907 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3908 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3909 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3910 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3911 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
3912 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3913 "use same video quality as source (implies VBR)" },
3914 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3915 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
3916 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3917 "deinterlace pictures" },
3918 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3919 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3920 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3921 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3922 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3923 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3924 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3925 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3926 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3927 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3928 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
3931 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3932 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3933 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3934 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3935 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3936 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3937 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3938 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3939 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3940 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3941 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3942 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_sample_fmt}, "set sample format, 'list' as argument shows all the sample formats supported", "format" },
3944 /* subtitle options */
3945 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3946 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3947 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3948 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3949 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
3952 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3953 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3954 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3957 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3958 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3960 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3961 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3962 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3964 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3965 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3966 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3967 { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
3969 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3973 int main(int argc, char **argv)
3978 avcodec_register_all();
3979 avdevice_register_all();
3983 if(isatty(STDIN_FILENO))
3984 url_set_interrupt_cb(decode_interrupt_cb);
3987 for(i=0; i<CODEC_TYPE_NB; i++){
3988 avcodec_opts[i]= avcodec_alloc_context2(i);
3990 avformat_opts = avformat_alloc_context();
3991 sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3996 parse_options(argc, argv, options, opt_output_file);
3998 /* file converter / grab */
3999 if (nb_output_files <= 0) {
4000 fprintf(stderr, "At least one output file must be specified\n");
4004 if (nb_input_files == 0) {
4005 fprintf(stderr, "At least one input file must be specified\n");
4010 if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
4011 stream_maps, nb_stream_maps) < 0)
4013 ti = getutime() - ti;
4015 printf("bench: utime=%0.3fs\n", ti / 1000000.0);