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 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 static uint8_t *audio_out2;
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);
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 const int audio_out_size= 4*MAX_AUDIO_PACKET_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;
568 /* SC: dynamic allocation of buffers */
570 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
572 audio_out = av_malloc(audio_out_size);
573 if (!audio_buf || !audio_out)
574 return; /* Should signal an error ! */
576 if (enc->channels != dec->channels)
577 ost->audio_resample = 1;
579 if (ost->audio_resample && !ost->resample) {
580 if (dec->sample_fmt != SAMPLE_FMT_S16)
581 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
582 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
583 enc->sample_rate, dec->sample_rate,
584 enc->sample_fmt, dec->sample_fmt,
586 if (!ost->resample) {
587 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
588 dec->channels, dec->sample_rate,
589 enc->channels, enc->sample_rate);
594 #define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
595 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
596 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
598 audio_out2 = av_malloc(audio_out_size);
601 if (ost->reformat_ctx)
602 av_audio_convert_free(ost->reformat_ctx);
603 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
604 dec->sample_fmt, 1, NULL, 0);
605 if (!ost->reformat_ctx) {
606 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
607 avcodec_get_sample_fmt_name(dec->sample_fmt),
608 avcodec_get_sample_fmt_name(enc->sample_fmt));
611 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
614 if(audio_sync_method){
615 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
616 - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2);
617 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
618 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
620 //FIXME resample delay
621 if(fabs(delta) > 50){
622 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
624 byte_delta= FFMAX(byte_delta, -size);
628 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
633 static uint8_t *input_tmp= NULL;
634 input_tmp= av_realloc(input_tmp, byte_delta + size);
636 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
639 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
641 memset(input_tmp, 0, byte_delta);
642 memcpy(input_tmp + byte_delta, buf, size);
646 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
648 }else if(audio_sync_method>1){
649 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
650 assert(ost->audio_resample);
652 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
653 // 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));
654 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
658 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
659 - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
661 if (ost->audio_resample) {
663 size_out = audio_resample(ost->resample,
664 (short *)buftmp, (short *)buf,
665 size / (ist->st->codec->channels * isize));
666 size_out = size_out * enc->channels * osize;
672 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
673 const void *ibuf[6]= {buftmp};
674 void *obuf[6]= {audio_out2};
675 int istride[6]= {isize};
676 int ostride[6]= {osize};
677 int len= size_out/istride[0];
678 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
679 printf("av_audio_convert() failed\n");
685 size_out = len*osize;
688 /* now encode as many frames as possible */
689 if (enc->frame_size > 1) {
690 /* output resampled raw samples */
691 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
692 fprintf(stderr, "av_fifo_realloc2() failed\n");
695 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
697 frame_bytes = enc->frame_size * osize * enc->channels;
699 while (av_fifo_size(ost->fifo) >= frame_bytes) {
701 av_init_packet(&pkt);
703 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
705 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
707 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
710 fprintf(stderr, "Audio encoding failed\n");
714 pkt.stream_index= ost->index;
717 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
718 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
719 pkt.flags |= PKT_FLAG_KEY;
720 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
722 ost->sync_opts += enc->frame_size;
726 int coded_bps = av_get_bits_per_sample(enc->codec->id)/8;
727 av_init_packet(&pkt);
729 ost->sync_opts += size_out / (osize * enc->channels);
731 /* output a pcm frame */
732 /* determine the size of the coded buffer */
735 size_out *= coded_bps;
737 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
738 ret = avcodec_encode_audio(enc, audio_out, size_out,
741 fprintf(stderr, "Audio encoding failed\n");
745 pkt.stream_index= ost->index;
748 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
749 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
750 pkt.flags |= PKT_FLAG_KEY;
751 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
755 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
759 AVPicture picture_tmp;
762 dec = ist->st->codec;
764 /* deinterlace : must be done before any resize */
765 if (do_deinterlace) {
768 /* create temporary picture */
769 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
770 buf = av_malloc(size);
774 picture2 = &picture_tmp;
775 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
777 if(avpicture_deinterlace(picture2, picture,
778 dec->pix_fmt, dec->width, dec->height) < 0) {
779 /* if error, do not deinterlace */
780 fprintf(stderr, "Deinterlacing failed\n");
789 if (picture != picture2)
790 *picture = *picture2;
794 /* we begin to correct av delay at this threshold */
795 #define AV_DELAY_MAX 0.100
797 static void do_subtitle_out(AVFormatContext *s,
803 static uint8_t *subtitle_out = NULL;
804 int subtitle_out_max_size = 1024 * 1024;
805 int subtitle_out_size, nb, i;
809 if (pts == AV_NOPTS_VALUE) {
810 fprintf(stderr, "Subtitle packets must have a pts\n");
816 enc = ost->st->codec;
819 subtitle_out = av_malloc(subtitle_out_max_size);
822 /* Note: DVB subtitle need one packet to draw them and one other
823 packet to clear them */
824 /* XXX: signal it in the codec context ? */
825 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
830 for(i = 0; i < nb; i++) {
831 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
832 // start_display_time is required to be 0
833 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
834 sub->end_display_time -= sub->start_display_time;
835 sub->start_display_time = 0;
836 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
837 subtitle_out_max_size, sub);
838 if (subtitle_out_size < 0) {
839 fprintf(stderr, "Subtitle encoding failed\n");
843 av_init_packet(&pkt);
844 pkt.stream_index = ost->index;
845 pkt.data = subtitle_out;
846 pkt.size = subtitle_out_size;
847 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
848 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
849 /* XXX: the pts correction is handled here. Maybe handling
850 it in the codec would be better */
852 pkt.pts += 90 * sub->start_display_time;
854 pkt.pts += 90 * sub->end_display_time;
856 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
860 static int bit_buffer_size= 1024*256;
861 static uint8_t *bit_buffer= NULL;
863 static void do_video_out(AVFormatContext *s,
869 int nb_frames, i, ret;
870 int64_t topBand, bottomBand, leftBand, rightBand;
871 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
872 AVFrame picture_crop_temp, picture_pad_temp;
873 AVCodecContext *enc, *dec;
875 avcodec_get_frame_defaults(&picture_crop_temp);
876 avcodec_get_frame_defaults(&picture_pad_temp);
878 enc = ost->st->codec;
879 dec = ist->st->codec;
881 /* by default, we output a single frame */
886 if(video_sync_method){
888 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
889 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
892 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
896 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
897 }else if (vdelta > 1.1)
898 nb_frames = lrintf(vdelta);
899 //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);
903 fprintf(stderr, "*** drop!\n");
904 }else if (nb_frames > 1) {
905 nb_frames_dup += nb_frames;
907 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
910 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
912 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
916 if (ost->video_crop) {
917 if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
918 fprintf(stderr, "error cropping picture\n");
923 formatted_picture = &picture_crop_temp;
925 formatted_picture = in_picture;
928 final_picture = formatted_picture;
929 padding_src = formatted_picture;
930 resampling_dst = &ost->pict_tmp;
931 if (ost->video_pad) {
932 final_picture = &ost->pict_tmp;
933 if (ost->video_resample) {
934 if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
935 fprintf(stderr, "error padding picture\n");
940 resampling_dst = &picture_pad_temp;
944 if( (ost->resample_height != (ist->st->codec->height - (ost->topBand + ost->bottomBand)))
945 || (ost->resample_width != (ist->st->codec->width - (ost->leftBand + ost->rightBand)))
946 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
948 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));
949 if(!ost->video_resample)
953 if (ost->video_resample) {
955 final_picture = &ost->pict_tmp;
956 if( (ost->resample_height != (ist->st->codec->height - (ost->topBand + ost->bottomBand)))
957 || (ost->resample_width != (ist->st->codec->width - (ost->leftBand + ost->rightBand)))
958 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
960 /* keep bands proportional to the frame size */
961 topBand = ((int64_t)ist->st->codec->height * ost->original_topBand / ost->original_height) & ~1;
962 bottomBand = ((int64_t)ist->st->codec->height * ost->original_bottomBand / ost->original_height) & ~1;
963 leftBand = ((int64_t)ist->st->codec->width * ost->original_leftBand / ost->original_width) & ~1;
964 rightBand = ((int64_t)ist->st->codec->width * ost->original_rightBand / ost->original_width) & ~1;
966 /* sanity check to ensure no bad band sizes sneak in */
967 assert(topBand <= INT_MAX && topBand >= 0);
968 assert(bottomBand <= INT_MAX && bottomBand >= 0);
969 assert(leftBand <= INT_MAX && leftBand >= 0);
970 assert(rightBand <= INT_MAX && rightBand >= 0);
972 ost->topBand = topBand;
973 ost->bottomBand = bottomBand;
974 ost->leftBand = leftBand;
975 ost->rightBand = rightBand;
977 ost->resample_height = ist->st->codec->height - (ost->topBand + ost->bottomBand);
978 ost->resample_width = ist->st->codec->width - (ost->leftBand + ost->rightBand);
979 ost->resample_pix_fmt= ist->st->codec->pix_fmt;
981 /* initialize a new scaler context */
982 sws_freeContext(ost->img_resample_ctx);
983 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
984 ost->img_resample_ctx = sws_getContext(
985 ist->st->codec->width - (ost->leftBand + ost->rightBand),
986 ist->st->codec->height - (ost->topBand + ost->bottomBand),
987 ist->st->codec->pix_fmt,
988 ost->st->codec->width - (ost->padleft + ost->padright),
989 ost->st->codec->height - (ost->padtop + ost->padbottom),
990 ost->st->codec->pix_fmt,
991 sws_flags, NULL, NULL, NULL);
992 if (ost->img_resample_ctx == NULL) {
993 fprintf(stderr, "Cannot get resampling context\n");
997 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
998 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1001 if (ost->video_pad) {
1002 av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
1003 enc->height, enc->width, enc->pix_fmt,
1004 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
1007 /* duplicates frame if needed */
1008 for(i=0;i<nb_frames;i++) {
1010 av_init_packet(&pkt);
1011 pkt.stream_index= ost->index;
1013 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1014 /* raw pictures are written as AVPicture structure to
1015 avoid any copies. We support temorarily the older
1017 AVFrame* old_frame = enc->coded_frame;
1018 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1019 pkt.data= (uint8_t *)final_picture;
1020 pkt.size= sizeof(AVPicture);
1021 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1022 pkt.flags |= PKT_FLAG_KEY;
1024 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1025 enc->coded_frame = old_frame;
1027 AVFrame big_picture;
1029 big_picture= *final_picture;
1030 /* better than nothing: use input picture interlaced
1032 big_picture.interlaced_frame = in_picture->interlaced_frame;
1033 if(avcodec_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1034 if(top_field_first == -1)
1035 big_picture.top_field_first = in_picture->top_field_first;
1037 big_picture.top_field_first = top_field_first;
1040 /* handles sameq here. This is not correct because it may
1041 not be a global option */
1043 big_picture.quality = ist->st->quality;
1045 big_picture.quality = ost->st->quality;
1047 big_picture.pict_type = 0;
1048 // big_picture.pts = AV_NOPTS_VALUE;
1049 big_picture.pts= ost->sync_opts;
1050 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1051 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1052 ret = avcodec_encode_video(enc,
1053 bit_buffer, bit_buffer_size,
1056 fprintf(stderr, "Video encoding failed\n");
1061 pkt.data= bit_buffer;
1063 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1064 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1065 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1066 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1067 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1069 if(enc->coded_frame->key_frame)
1070 pkt.flags |= PKT_FLAG_KEY;
1071 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1074 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1075 // enc->frame_number-1, ret, enc->pict_type);
1076 /* if two pass, output log */
1077 if (ost->logfile && enc->stats_out) {
1078 fprintf(ost->logfile, "%s", enc->stats_out);
1083 ost->frame_number++;
1087 static double psnr(double d){
1088 return -10.0*log(d)/log(10.0);
1091 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1094 AVCodecContext *enc;
1096 double ti1, bitrate, avg_bitrate;
1098 /* this is executed just the first time do_video_stats is called */
1100 vstats_file = fopen(vstats_filename, "w");
1107 enc = ost->st->codec;
1108 if (enc->codec_type == CODEC_TYPE_VIDEO) {
1109 frame_number = ost->frame_number;
1110 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1111 if (enc->flags&CODEC_FLAG_PSNR)
1112 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1114 fprintf(vstats_file,"f_size= %6d ", frame_size);
1115 /* compute pts value */
1116 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1120 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1121 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1122 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1123 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1124 fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1128 static void print_report(AVFormatContext **output_files,
1129 AVOutputStream **ost_table, int nb_ostreams,
1133 AVOutputStream *ost;
1134 AVFormatContext *oc;
1136 AVCodecContext *enc;
1137 int frame_number, vid, i;
1138 double bitrate, ti1, pts;
1139 static int64_t last_time = -1;
1140 static int qp_histogram[52];
1142 if (!is_last_report) {
1144 /* display the report every 0.5 seconds */
1145 cur_time = av_gettime();
1146 if (last_time == -1) {
1147 last_time = cur_time;
1150 if ((cur_time - last_time) < 500000)
1152 last_time = cur_time;
1156 oc = output_files[0];
1158 total_size = url_fsize(oc->pb);
1159 if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1160 total_size= url_ftell(oc->pb);
1165 for(i=0;i<nb_ostreams;i++) {
1167 enc = ost->st->codec;
1168 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1169 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1170 !ost->st->stream_copy ?
1171 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1173 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1174 float t = (av_gettime()-timer_start) / 1000000.0;
1176 frame_number = ost->frame_number;
1177 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1178 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1179 !ost->st->stream_copy ?
1180 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1182 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1185 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1186 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1189 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1191 if (enc->flags&CODEC_FLAG_PSNR){
1193 double error, error_sum=0;
1194 double scale, scale_sum=0;
1195 char type[3]= {'Y','U','V'};
1196 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1199 error= enc->error[j];
1200 scale= enc->width*enc->height*255.0*255.0*frame_number;
1202 error= enc->coded_frame->error[j];
1203 scale= enc->width*enc->height*255.0*255.0;
1208 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1210 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1214 /* compute min output value */
1215 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1216 if ((pts < ti1) && (pts > 0))
1222 if (verbose || is_last_report) {
1223 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1225 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1226 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1227 (double)total_size / 1024, ti1, bitrate);
1230 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1231 nb_frames_dup, nb_frames_drop);
1234 fprintf(stderr, "%s \r", buf);
1239 if (is_last_report && verbose >= 0){
1240 int64_t raw= audio_size + video_size + extra_size;
1241 fprintf(stderr, "\n");
1242 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1246 100.0*(total_size - raw)/raw
1251 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1252 static int output_packet(AVInputStream *ist, int ist_index,
1253 AVOutputStream **ost_table, int nb_ostreams,
1254 const AVPacket *pkt)
1256 AVFormatContext *os;
1257 AVOutputStream *ost;
1260 int data_size, got_picture;
1262 void *buffer_to_free;
1263 static unsigned int samples_size= 0;
1264 AVSubtitle subtitle, *subtitle_to_free;
1267 int bps = av_get_bits_per_sample_format(ist->st->codec->sample_fmt)>>3;
1269 if(ist->next_pts == AV_NOPTS_VALUE)
1270 ist->next_pts= ist->pts;
1274 av_init_packet(&avpkt);
1282 if(pkt->dts != AV_NOPTS_VALUE)
1283 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1285 //while we have more to decode or while the decoder did output something on EOF
1286 while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1288 ist->pts= ist->next_pts;
1290 if(avpkt.size && avpkt.size != pkt->size &&
1291 !(ist->st->codec->codec->capabilities & CODEC_CAP_SUBFRAMES) && verbose>0)
1292 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1294 /* decode the packet if needed */
1295 data_buf = NULL; /* fail safe */
1297 subtitle_to_free = NULL;
1298 if (ist->decoding_needed) {
1299 switch(ist->st->codec->codec_type) {
1300 case CODEC_TYPE_AUDIO:{
1301 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1302 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1304 samples= av_malloc(samples_size);
1306 data_size= samples_size;
1307 /* XXX: could avoid copy if PCM 16 bits with same
1308 endianness as CPU */
1309 ret = avcodec_decode_audio3(ist->st->codec, samples, &data_size,
1315 /* Some bug in mpeg audio decoder gives */
1316 /* data_size < 0, it seems they are overflows */
1317 if (data_size <= 0) {
1318 /* no audio frame */
1321 data_buf = (uint8_t *)samples;
1322 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * data_size) /
1323 (ist->st->codec->sample_rate * ist->st->codec->channels);
1325 case CODEC_TYPE_VIDEO:
1326 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1327 /* XXX: allocate picture correctly */
1328 avcodec_get_frame_defaults(&picture);
1330 ret = avcodec_decode_video2(ist->st->codec,
1331 &picture, &got_picture, &avpkt);
1332 ist->st->quality= picture.quality;
1336 /* no picture yet */
1337 goto discard_packet;
1339 if (ist->st->codec->time_base.num != 0) {
1340 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1341 ist->next_pts += ((int64_t)AV_TIME_BASE *
1342 ist->st->codec->time_base.num * ticks) /
1343 ist->st->codec->time_base.den;
1347 case CODEC_TYPE_SUBTITLE:
1348 ret = avcodec_decode_subtitle2(ist->st->codec,
1349 &subtitle, &got_subtitle, &avpkt);
1352 if (!got_subtitle) {
1353 goto discard_packet;
1355 subtitle_to_free = &subtitle;
1362 switch(ist->st->codec->codec_type) {
1363 case CODEC_TYPE_AUDIO:
1364 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1365 ist->st->codec->sample_rate;
1367 case CODEC_TYPE_VIDEO:
1368 if (ist->st->codec->time_base.num != 0) {
1369 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1370 ist->next_pts += ((int64_t)AV_TIME_BASE *
1371 ist->st->codec->time_base.num * ticks) /
1372 ist->st->codec->time_base.den;
1376 data_buf = avpkt.data;
1377 data_size = avpkt.size;
1382 buffer_to_free = NULL;
1383 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1384 pre_process_video_frame(ist, (AVPicture *)&picture,
1388 // preprocess audio (volume)
1389 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1390 if (audio_volume != 256) {
1393 for(i=0;i<(data_size / sizeof(short));i++) {
1394 int v = ((*volp) * audio_volume + 128) >> 8;
1395 if (v < -32768) v = -32768;
1396 if (v > 32767) v = 32767;
1402 /* frame rate emulation */
1404 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1405 int64_t now = av_gettime() - ist->start;
1410 /* if output time reached then transcode raw format,
1411 encode packets and output them */
1412 if (start_time == 0 || ist->pts >= start_time)
1413 for(i=0;i<nb_ostreams;i++) {
1417 if (ost->source_index == ist_index) {
1418 os = output_files[ost->file_index];
1420 /* set the input output pts pairs */
1421 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1423 if (ost->encoding_needed) {
1424 switch(ost->st->codec->codec_type) {
1425 case CODEC_TYPE_AUDIO:
1426 do_audio_out(os, ost, ist, data_buf, data_size);
1428 case CODEC_TYPE_VIDEO:
1429 do_video_out(os, ost, ist, &picture, &frame_size);
1430 if (vstats_filename && frame_size)
1431 do_video_stats(os, ost, frame_size);
1433 case CODEC_TYPE_SUBTITLE:
1434 do_subtitle_out(os, ost, ist, &subtitle,
1441 AVFrame avframe; //FIXME/XXX remove this
1443 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1445 av_init_packet(&opkt);
1447 if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1450 /* no reencoding needed : output the packet directly */
1451 /* force the input stream PTS */
1453 avcodec_get_frame_defaults(&avframe);
1454 ost->st->codec->coded_frame= &avframe;
1455 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1457 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1458 audio_size += data_size;
1459 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1460 video_size += data_size;
1464 opkt.stream_index= ost->index;
1465 if(pkt->pts != AV_NOPTS_VALUE)
1466 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1468 opkt.pts= AV_NOPTS_VALUE;
1470 if (pkt->dts == AV_NOPTS_VALUE)
1471 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1473 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1474 opkt.dts -= ost_tb_start_time;
1476 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1477 opkt.flags= pkt->flags;
1479 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1480 if(ost->st->codec->codec_id != CODEC_ID_H264) {
1481 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1482 opkt.destruct= av_destruct_packet;
1484 opkt.data = data_buf;
1485 opkt.size = data_size;
1488 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1489 ost->st->codec->frame_number++;
1490 ost->frame_number++;
1491 av_free_packet(&opkt);
1495 av_free(buffer_to_free);
1496 /* XXX: allocate the subtitles in the codec ? */
1497 if (subtitle_to_free) {
1498 if (subtitle_to_free->rects != NULL) {
1499 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1500 av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1501 av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1502 av_freep(&subtitle_to_free->rects[i]);
1504 av_freep(&subtitle_to_free->rects);
1506 subtitle_to_free->num_rects = 0;
1507 subtitle_to_free = NULL;
1514 for(i=0;i<nb_ostreams;i++) {
1516 if (ost->source_index == ist_index) {
1517 AVCodecContext *enc= ost->st->codec;
1518 os = output_files[ost->file_index];
1520 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1522 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1525 if (ost->encoding_needed) {
1529 av_init_packet(&pkt);
1530 pkt.stream_index= ost->index;
1532 switch(ost->st->codec->codec_type) {
1533 case CODEC_TYPE_AUDIO:
1534 fifo_bytes = av_fifo_size(ost->fifo);
1536 /* encode any samples remaining in fifo */
1537 if (fifo_bytes > 0) {
1538 int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
1539 int fs_tmp = enc->frame_size;
1541 av_fifo_generic_read(ost->fifo, samples, fifo_bytes, NULL);
1542 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1543 enc->frame_size = fifo_bytes / (osize * enc->channels);
1545 int frame_bytes = enc->frame_size*osize*enc->channels;
1546 if (samples_size < frame_bytes)
1548 memset((uint8_t*)samples+fifo_bytes, 0, frame_bytes - fifo_bytes);
1551 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1552 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1553 ost->st->time_base.num, enc->sample_rate);
1554 enc->frame_size = fs_tmp;
1557 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1560 fprintf(stderr, "Audio encoding failed\n");
1564 pkt.flags |= PKT_FLAG_KEY;
1566 case CODEC_TYPE_VIDEO:
1567 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1569 fprintf(stderr, "Video encoding failed\n");
1573 if(enc->coded_frame && enc->coded_frame->key_frame)
1574 pkt.flags |= PKT_FLAG_KEY;
1575 if (ost->logfile && enc->stats_out) {
1576 fprintf(ost->logfile, "%s", enc->stats_out);
1585 pkt.data= bit_buffer;
1587 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1588 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1589 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1601 static void print_sdp(AVFormatContext **avc, int n)
1605 avf_sdp_create(avc, n, sdp, sizeof(sdp));
1606 printf("SDP:\n%s\n", sdp);
1610 static int stream_index_from_inputs(AVFormatContext **input_files,
1612 AVInputFile *file_table,
1613 AVInputStream **ist_table,
1614 enum CodecType type,
1618 for(z=0; z<nb_input_files; z++) {
1619 AVFormatContext *ic = input_files[z];
1620 for(p=0; p<ic->nb_programs; p++) {
1621 AVProgram *program = ic->programs[p];
1622 if(program->id != programid)
1624 for(q=0; q<program->nb_stream_indexes; q++) {
1625 int sidx = program->stream_index[q];
1626 int ris = file_table[z].ist_index + sidx;
1627 if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1637 * The following code is the main loop of the file converter
1639 static int av_encode(AVFormatContext **output_files,
1640 int nb_output_files,
1641 AVFormatContext **input_files,
1643 AVStreamMap *stream_maps, int nb_stream_maps)
1645 int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1646 AVFormatContext *is, *os;
1647 AVCodecContext *codec, *icodec;
1648 AVOutputStream *ost, **ost_table = NULL;
1649 AVInputStream *ist, **ist_table = NULL;
1650 AVInputFile *file_table;
1654 uint8_t no_packet[MAX_FILES]={0};
1655 int no_packet_count=0;
1657 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1661 /* input stream init */
1663 for(i=0;i<nb_input_files;i++) {
1664 is = input_files[i];
1665 file_table[i].ist_index = j;
1666 file_table[i].nb_streams = is->nb_streams;
1667 j += is->nb_streams;
1671 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1675 for(i=0;i<nb_istreams;i++) {
1676 ist = av_mallocz(sizeof(AVInputStream));
1682 for(i=0;i<nb_input_files;i++) {
1683 is = input_files[i];
1684 for(k=0;k<is->nb_streams;k++) {
1685 ist = ist_table[j++];
1686 ist->st = is->streams[k];
1687 ist->file_index = i;
1689 ist->discard = 1; /* the stream is discarded by default
1693 ist->start = av_gettime();
1698 /* output stream init */
1700 for(i=0;i<nb_output_files;i++) {
1701 os = output_files[i];
1702 if (!os->nb_streams) {
1703 dump_format(output_files[i], i, output_files[i]->filename, 1);
1704 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1707 nb_ostreams += os->nb_streams;
1709 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1710 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1714 /* Sanity check the mapping args -- do the input files & streams exist? */
1715 for(i=0;i<nb_stream_maps;i++) {
1716 int fi = stream_maps[i].file_index;
1717 int si = stream_maps[i].stream_index;
1719 if (fi < 0 || fi > nb_input_files - 1 ||
1720 si < 0 || si > file_table[fi].nb_streams - 1) {
1721 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1724 fi = stream_maps[i].sync_file_index;
1725 si = stream_maps[i].sync_stream_index;
1726 if (fi < 0 || fi > nb_input_files - 1 ||
1727 si < 0 || si > file_table[fi].nb_streams - 1) {
1728 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1733 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1736 for(i=0;i<nb_ostreams;i++) {
1737 ost = av_mallocz(sizeof(AVOutputStream));
1744 for(k=0;k<nb_output_files;k++) {
1745 os = output_files[k];
1746 for(i=0;i<os->nb_streams;i++,n++) {
1749 ost->file_index = k;
1751 ost->st = os->streams[i];
1752 if (nb_stream_maps > 0) {
1753 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1754 stream_maps[n].stream_index;
1756 /* Sanity check that the stream types match */
1757 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1758 int i= ost->file_index;
1759 dump_format(output_files[i], i, output_files[i]->filename, 1);
1760 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1761 stream_maps[n].file_index, stream_maps[n].stream_index,
1762 ost->file_index, ost->index);
1769 j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1771 ost->source_index = j;
1775 /* get corresponding input stream index : we select the first one with the right type */
1777 for(j=0;j<nb_istreams;j++) {
1780 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1781 ost->source_index = j;
1789 if(! opt_programid) {
1790 /* try again and reuse existing stream */
1791 for(j=0;j<nb_istreams;j++) {
1793 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1794 ost->source_index = j;
1800 int i= ost->file_index;
1801 dump_format(output_files[i], i, output_files[i]->filename, 1);
1802 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1803 ost->file_index, ost->index);
1808 ist = ist_table[ost->source_index];
1810 ost->sync_ist = (nb_stream_maps > 0) ?
1811 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
1812 stream_maps[n].sync_stream_index] : ist;
1816 /* for each output stream, we compute the right encoding parameters */
1817 for(i=0;i<nb_ostreams;i++) {
1818 AVMetadataTag *lang;
1820 os = output_files[ost->file_index];
1821 ist = ist_table[ost->source_index];
1823 codec = ost->st->codec;
1824 icodec = ist->st->codec;
1826 if ((lang=av_metadata_get(ist->st->metadata, "language", NULL, 0))
1827 && !av_metadata_get(ost->st->metadata, "language", NULL, 0))
1828 av_metadata_set(&ost->st->metadata, "language", lang->value);
1830 ost->st->disposition = ist->st->disposition;
1831 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1832 codec->chroma_sample_location = icodec->chroma_sample_location;
1834 if (ost->st->stream_copy) {
1835 /* if stream_copy is selected, no need to decode or encode */
1836 codec->codec_id = icodec->codec_id;
1837 codec->codec_type = icodec->codec_type;
1839 if(!codec->codec_tag){
1840 if( !os->oformat->codec_tag
1841 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1842 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1843 codec->codec_tag = icodec->codec_tag;
1846 codec->bit_rate = icodec->bit_rate;
1847 codec->extradata= icodec->extradata;
1848 codec->extradata_size= icodec->extradata_size;
1849 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){
1850 codec->time_base = icodec->time_base;
1851 codec->time_base.num *= icodec->ticks_per_frame;
1853 codec->time_base = ist->st->time_base;
1854 switch(codec->codec_type) {
1855 case CODEC_TYPE_AUDIO:
1856 if(audio_volume != 256) {
1857 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1860 codec->channel_layout = icodec->channel_layout;
1861 codec->sample_rate = icodec->sample_rate;
1862 codec->channels = icodec->channels;
1863 codec->frame_size = icodec->frame_size;
1864 codec->block_align= icodec->block_align;
1865 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1866 codec->block_align= 0;
1867 if(codec->codec_id == CODEC_ID_AC3)
1868 codec->block_align= 0;
1870 case CODEC_TYPE_VIDEO:
1871 codec->pix_fmt = icodec->pix_fmt;
1872 codec->width = icodec->width;
1873 codec->height = icodec->height;
1874 codec->has_b_frames = icodec->has_b_frames;
1876 case CODEC_TYPE_SUBTITLE:
1877 codec->width = icodec->width;
1878 codec->height = icodec->height;
1884 switch(codec->codec_type) {
1885 case CODEC_TYPE_AUDIO:
1886 ost->fifo= av_fifo_alloc(1024);
1889 ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
1890 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1891 icodec->request_channels = codec->channels;
1892 ist->decoding_needed = 1;
1893 ost->encoding_needed = 1;
1895 case CODEC_TYPE_VIDEO:
1896 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
1897 fprintf(stderr, "Video pixel format is unknown, stream cannot be decoded\n");
1900 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1901 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1902 ost->video_resample = ((codec->width != icodec->width -
1903 (frame_leftBand + frame_rightBand) +
1904 (frame_padleft + frame_padright)) ||
1905 (codec->height != icodec->height -
1906 (frame_topBand + frame_bottomBand) +
1907 (frame_padtop + frame_padbottom)) ||
1908 (codec->pix_fmt != icodec->pix_fmt));
1909 if (ost->video_crop) {
1910 ost->topBand = ost->original_topBand = frame_topBand;
1911 ost->bottomBand = ost->original_bottomBand = frame_bottomBand;
1912 ost->leftBand = ost->original_leftBand = frame_leftBand;
1913 ost->rightBand = ost->original_rightBand = frame_rightBand;
1915 if (ost->video_pad) {
1916 ost->padtop = frame_padtop;
1917 ost->padleft = frame_padleft;
1918 ost->padbottom = frame_padbottom;
1919 ost->padright = frame_padright;
1920 if (!ost->video_resample) {
1921 avcodec_get_frame_defaults(&ost->pict_tmp);
1922 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1923 codec->width, codec->height))
1927 if (ost->video_resample) {
1928 avcodec_get_frame_defaults(&ost->pict_tmp);
1929 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1930 codec->width, codec->height)) {
1931 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1934 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1935 ost->img_resample_ctx = sws_getContext(
1936 icodec->width - (frame_leftBand + frame_rightBand),
1937 icodec->height - (frame_topBand + frame_bottomBand),
1939 codec->width - (frame_padleft + frame_padright),
1940 codec->height - (frame_padtop + frame_padbottom),
1942 sws_flags, NULL, NULL, NULL);
1943 if (ost->img_resample_ctx == NULL) {
1944 fprintf(stderr, "Cannot get resampling context\n");
1948 ost->original_height = icodec->height;
1949 ost->original_width = icodec->width;
1951 codec->bits_per_raw_sample= 0;
1953 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1954 ost->resample_width = icodec->width - (frame_leftBand + frame_rightBand);
1955 ost->resample_pix_fmt= icodec->pix_fmt;
1956 ost->encoding_needed = 1;
1957 ist->decoding_needed = 1;
1959 case CODEC_TYPE_SUBTITLE:
1960 ost->encoding_needed = 1;
1961 ist->decoding_needed = 1;
1968 if (ost->encoding_needed &&
1969 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1970 char logfilename[1024];
1975 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1976 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
1978 if (codec->flags & CODEC_FLAG_PASS1) {
1979 f = fopen(logfilename, "w");
1981 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
1986 /* read the log file */
1987 f = fopen(logfilename, "r");
1989 fprintf(stderr, "Cannot read log file '%s' for pass-2 encoding: %s\n", logfilename, strerror(errno));
1992 fseek(f, 0, SEEK_END);
1994 fseek(f, 0, SEEK_SET);
1995 logbuffer = av_malloc(size + 1);
1997 fprintf(stderr, "Could not allocate log buffer\n");
2000 size = fread(logbuffer, 1, size, f);
2002 logbuffer[size] = '\0';
2003 codec->stats_in = logbuffer;
2007 if(codec->codec_type == CODEC_TYPE_VIDEO){
2008 int size= codec->width * codec->height;
2009 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2014 bit_buffer = av_malloc(bit_buffer_size);
2016 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2018 ret = AVERROR(ENOMEM);
2022 /* open each encoder */
2023 for(i=0;i<nb_ostreams;i++) {
2025 if (ost->encoding_needed) {
2026 AVCodec *codec = output_codecs[i];
2028 codec = avcodec_find_encoder(ost->st->codec->codec_id);
2030 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2031 ost->st->codec->codec_id, ost->file_index, ost->index);
2032 ret = AVERROR(EINVAL);
2035 if (avcodec_open(ost->st->codec, codec) < 0) {
2036 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2037 ost->file_index, ost->index);
2038 ret = AVERROR(EINVAL);
2041 extra_size += ost->st->codec->extradata_size;
2045 /* open each decoder */
2046 for(i=0;i<nb_istreams;i++) {
2048 if (ist->decoding_needed) {
2049 AVCodec *codec = input_codecs[i];
2051 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2053 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2054 ist->st->codec->codec_id, ist->file_index, ist->index);
2055 ret = AVERROR(EINVAL);
2058 if (avcodec_open(ist->st->codec, codec) < 0) {
2059 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2060 ist->file_index, ist->index);
2061 ret = AVERROR(EINVAL);
2064 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
2065 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2070 for(i=0;i<nb_istreams;i++) {
2073 ist->next_pts = AV_NOPTS_VALUE;
2077 /* set meta data information from input file if required */
2078 for (i=0;i<nb_meta_data_maps;i++) {
2079 AVFormatContext *out_file;
2080 AVFormatContext *in_file;
2081 AVMetadataTag *mtag;
2083 int out_file_index = meta_data_maps[i].out_file;
2084 int in_file_index = meta_data_maps[i].in_file;
2085 if (out_file_index < 0 || out_file_index >= nb_output_files) {
2086 snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
2087 out_file_index, out_file_index, in_file_index);
2088 ret = AVERROR(EINVAL);
2091 if (in_file_index < 0 || in_file_index >= nb_input_files) {
2092 snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
2093 in_file_index, out_file_index, in_file_index);
2094 ret = AVERROR(EINVAL);
2098 out_file = output_files[out_file_index];
2099 in_file = input_files[in_file_index];
2103 while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2104 av_metadata_set(&out_file->metadata, mtag->key, mtag->value);
2105 av_metadata_conv(out_file, out_file->oformat->metadata_conv,
2106 in_file->iformat->metadata_conv);
2109 /* open files and write file headers */
2110 for(i=0;i<nb_output_files;i++) {
2111 os = output_files[i];
2112 if (av_write_header(os) < 0) {
2113 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2114 ret = AVERROR(EINVAL);
2117 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2123 /* dump the file output parameters - cannot be done before in case
2125 for(i=0;i<nb_output_files;i++) {
2126 dump_format(output_files[i], i, output_files[i]->filename, 1);
2129 /* dump the stream mapping */
2131 fprintf(stderr, "Stream mapping:\n");
2132 for(i=0;i<nb_ostreams;i++) {
2134 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2135 ist_table[ost->source_index]->file_index,
2136 ist_table[ost->source_index]->index,
2139 if (ost->sync_ist != ist_table[ost->source_index])
2140 fprintf(stderr, " [sync #%d.%d]",
2141 ost->sync_ist->file_index,
2142 ost->sync_ist->index);
2143 fprintf(stderr, "\n");
2148 fprintf(stderr, "%s\n", error);
2153 print_sdp(output_files, nb_output_files);
2156 if (!using_stdin && verbose >= 0) {
2157 fprintf(stderr, "Press [q] to stop encoding\n");
2158 url_set_interrupt_cb(decode_interrupt_cb);
2162 timer_start = av_gettime();
2164 for(; received_sigterm == 0;) {
2165 int file_index, ist_index;
2173 /* if 'q' pressed, exits */
2177 /* read_key() returns 0 on EOF */
2183 /* select the stream that we must read now by looking at the
2184 smallest output pts */
2186 for(i=0;i<nb_ostreams;i++) {
2189 os = output_files[ost->file_index];
2190 ist = ist_table[ost->source_index];
2191 if(no_packet[ist->file_index])
2193 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2194 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2196 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2197 ipts = (double)ist->pts;
2198 if (!file_table[ist->file_index].eof_reached){
2199 if(ipts < ipts_min) {
2201 if(input_sync ) file_index = ist->file_index;
2203 if(opts < opts_min) {
2205 if(!input_sync) file_index = ist->file_index;
2208 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2213 /* if none, if is finished */
2214 if (file_index < 0) {
2215 if(no_packet_count){
2217 memset(no_packet, 0, sizeof(no_packet));
2224 /* finish if recording time exhausted */
2225 if (opts_min >= (recording_time / 1000000.0))
2228 /* finish if limit size exhausted */
2229 if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2232 /* read a frame from it and output it in the fifo */
2233 is = input_files[file_index];
2234 ret= av_read_frame(is, &pkt);
2235 if(ret == AVERROR(EAGAIN)){
2236 no_packet[file_index]=1;
2241 file_table[file_index].eof_reached = 1;
2249 memset(no_packet, 0, sizeof(no_packet));
2252 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2254 /* the following test is needed in case new streams appear
2255 dynamically in stream : we ignore them */
2256 if (pkt.stream_index >= file_table[file_index].nb_streams)
2257 goto discard_packet;
2258 ist_index = file_table[file_index].ist_index + pkt.stream_index;
2259 ist = ist_table[ist_index];
2261 goto discard_packet;
2263 if (pkt.dts != AV_NOPTS_VALUE)
2264 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2265 if (pkt.pts != AV_NOPTS_VALUE)
2266 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2268 if(input_files_ts_scale[file_index][pkt.stream_index]){
2269 if(pkt.pts != AV_NOPTS_VALUE)
2270 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2271 if(pkt.dts != AV_NOPTS_VALUE)
2272 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2275 // 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);
2276 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2277 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2278 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2279 int64_t delta= pkt_dts - ist->next_pts;
2280 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2281 input_files_ts_offset[ist->file_index]-= delta;
2283 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2284 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2285 if(pkt.pts != AV_NOPTS_VALUE)
2286 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2290 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2291 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2294 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2295 ist->file_index, ist->index);
2298 av_free_packet(&pkt);
2303 av_free_packet(&pkt);
2305 /* dump report by using the output first video and audio streams */
2306 print_report(output_files, ost_table, nb_ostreams, 0);
2309 /* at the end of stream, we must flush the decoder buffers */
2310 for(i=0;i<nb_istreams;i++) {
2312 if (ist->decoding_needed) {
2313 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2319 /* write the trailer if needed and close file */
2320 for(i=0;i<nb_output_files;i++) {
2321 os = output_files[i];
2322 av_write_trailer(os);
2325 /* dump report by using the first video and audio streams */
2326 print_report(output_files, ost_table, nb_ostreams, 1);
2328 /* close each encoder */
2329 for(i=0;i<nb_ostreams;i++) {
2331 if (ost->encoding_needed) {
2332 av_freep(&ost->st->codec->stats_in);
2333 avcodec_close(ost->st->codec);
2337 /* close each decoder */
2338 for(i=0;i<nb_istreams;i++) {
2340 if (ist->decoding_needed) {
2341 avcodec_close(ist->st->codec);
2349 av_freep(&bit_buffer);
2350 av_free(file_table);
2353 for(i=0;i<nb_istreams;i++) {
2360 for(i=0;i<nb_ostreams;i++) {
2364 fclose(ost->logfile);
2365 ost->logfile = NULL;
2367 av_fifo_free(ost->fifo); /* works even if fifo is not
2368 initialized but set to zero */
2369 av_free(ost->pict_tmp.data[0]);
2370 if (ost->video_resample)
2371 sws_freeContext(ost->img_resample_ctx);
2373 audio_resample_close(ost->resample);
2374 if (ost->reformat_ctx)
2375 av_audio_convert_free(ost->reformat_ctx);
2384 static void opt_format(const char *arg)
2386 /* compatibility stuff for pgmyuv */
2387 if (!strcmp(arg, "pgmyuv")) {
2388 pgmyuv_compatibility_hack=1;
2389 // opt_image_format(arg);
2391 fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2394 last_asked_format = arg;
2397 static void opt_video_rc_override_string(const char *arg)
2399 video_rc_override_string = arg;
2402 static int opt_me_threshold(const char *opt, const char *arg)
2404 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2408 static int opt_verbose(const char *opt, const char *arg)
2410 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2414 static int opt_frame_rate(const char *opt, const char *arg)
2416 if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2417 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2423 static int opt_bitrate(const char *opt, const char *arg)
2425 int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2427 opt_default(opt, arg);
2429 if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2430 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2435 static void opt_frame_crop_top(const char *arg)
2437 frame_topBand = atoi(arg);
2438 if (frame_topBand < 0) {
2439 fprintf(stderr, "Incorrect top crop size\n");
2442 if ((frame_topBand) >= frame_height){
2443 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2446 frame_height -= frame_topBand;
2449 static void opt_frame_crop_bottom(const char *arg)
2451 frame_bottomBand = atoi(arg);
2452 if (frame_bottomBand < 0) {
2453 fprintf(stderr, "Incorrect bottom crop size\n");
2456 if ((frame_bottomBand) >= frame_height){
2457 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2460 frame_height -= frame_bottomBand;
2463 static void opt_frame_crop_left(const char *arg)
2465 frame_leftBand = atoi(arg);
2466 if (frame_leftBand < 0) {
2467 fprintf(stderr, "Incorrect left crop size\n");
2470 if ((frame_leftBand) >= frame_width){
2471 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2474 frame_width -= frame_leftBand;
2477 static void opt_frame_crop_right(const char *arg)
2479 frame_rightBand = atoi(arg);
2480 if (frame_rightBand < 0) {
2481 fprintf(stderr, "Incorrect right crop size\n");
2484 if ((frame_rightBand) >= frame_width){
2485 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2488 frame_width -= frame_rightBand;
2491 static void opt_frame_size(const char *arg)
2493 if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2494 fprintf(stderr, "Incorrect frame size\n");
2499 static void opt_pad_color(const char *arg) {
2500 /* Input is expected to be six hex digits similar to
2501 how colors are expressed in html tags (but without the #) */
2502 int rgb = strtol(arg, NULL, 16);
2506 g = ((rgb >> 8) & 255);
2509 padcolor[0] = RGB_TO_Y(r,g,b);
2510 padcolor[1] = RGB_TO_U(r,g,b,0);
2511 padcolor[2] = RGB_TO_V(r,g,b,0);
2514 static void opt_frame_pad_top(const char *arg)
2516 frame_padtop = atoi(arg);
2517 if (frame_padtop < 0) {
2518 fprintf(stderr, "Incorrect top pad size\n");
2523 static void opt_frame_pad_bottom(const char *arg)
2525 frame_padbottom = atoi(arg);
2526 if (frame_padbottom < 0) {
2527 fprintf(stderr, "Incorrect bottom pad size\n");
2533 static void opt_frame_pad_left(const char *arg)
2535 frame_padleft = atoi(arg);
2536 if (frame_padleft < 0) {
2537 fprintf(stderr, "Incorrect left pad size\n");
2543 static void opt_frame_pad_right(const char *arg)
2545 frame_padright = atoi(arg);
2546 if (frame_padright < 0) {
2547 fprintf(stderr, "Incorrect right pad size\n");
2552 static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2556 for (i=-1; i < nb_fmts; i++) {
2557 get_fmt_string (fmt_str, sizeof(fmt_str), i);
2558 fprintf(stdout, "%s\n", fmt_str);
2562 static void opt_frame_pix_fmt(const char *arg)
2564 if (strcmp(arg, "list")) {
2565 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2566 if (frame_pix_fmt == PIX_FMT_NONE) {
2567 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2571 list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2576 static void opt_frame_aspect_ratio(const char *arg)
2583 p = strchr(arg, ':');
2585 x = strtol(arg, &end, 10);
2587 y = strtol(end+1, &end, 10);
2589 ar = (double)x / (double)y;
2591 ar = strtod(arg, NULL);
2594 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2597 frame_aspect_ratio = ar;
2600 static int opt_metadata(const char *opt, const char *arg)
2602 char *mid= strchr(arg, '=');
2605 fprintf(stderr, "Missing =\n");
2611 metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2612 metadata[metadata_count-1].key = av_strdup(arg);
2613 metadata[metadata_count-1].value= av_strdup(mid);
2618 static void opt_qscale(const char *arg)
2620 video_qscale = atof(arg);
2621 if (video_qscale <= 0 ||
2622 video_qscale > 255) {
2623 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2628 static void opt_top_field_first(const char *arg)
2630 top_field_first= atoi(arg);
2633 static int opt_thread_count(const char *opt, const char *arg)
2635 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2638 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2643 static void opt_audio_sample_fmt(const char *arg)
2645 if (strcmp(arg, "list"))
2646 audio_sample_fmt = avcodec_get_sample_fmt(arg);
2648 list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2653 static int opt_audio_rate(const char *opt, const char *arg)
2655 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2659 static int opt_audio_channels(const char *opt, const char *arg)
2661 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2665 static void opt_video_channel(const char *arg)
2667 video_channel = strtol(arg, NULL, 0);
2670 static void opt_video_standard(const char *arg)
2672 video_standard = av_strdup(arg);
2675 static void opt_codec(int *pstream_copy, char **pcodec_name,
2676 int codec_type, const char *arg)
2678 av_freep(pcodec_name);
2679 if (!strcmp(arg, "copy")) {
2682 *pcodec_name = av_strdup(arg);
2686 static void opt_audio_codec(const char *arg)
2688 opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2691 static void opt_audio_tag(const char *arg)
2694 audio_codec_tag= strtol(arg, &tail, 0);
2697 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2700 static void opt_video_tag(const char *arg)
2703 video_codec_tag= strtol(arg, &tail, 0);
2706 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2709 static void opt_video_codec(const char *arg)
2711 opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2714 static void opt_subtitle_codec(const char *arg)
2716 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2719 static void opt_subtitle_tag(const char *arg)
2722 subtitle_codec_tag= strtol(arg, &tail, 0);
2725 subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2728 static void opt_map(const char *arg)
2733 m = &stream_maps[nb_stream_maps++];
2735 m->file_index = strtol(arg, &p, 0);
2739 m->stream_index = strtol(p, &p, 0);
2742 m->sync_file_index = strtol(p, &p, 0);
2745 m->sync_stream_index = strtol(p, &p, 0);
2747 m->sync_file_index = m->file_index;
2748 m->sync_stream_index = m->stream_index;
2752 static void opt_map_meta_data(const char *arg)
2757 m = &meta_data_maps[nb_meta_data_maps++];
2759 m->out_file = strtol(arg, &p, 0);
2763 m->in_file = strtol(p, &p, 0);
2766 static void opt_input_ts_scale(const char *arg)
2768 unsigned int stream;
2772 stream = strtol(arg, &p, 0);
2775 scale= strtod(p, &p);
2777 if(stream >= MAX_STREAMS)
2780 input_files_ts_scale[nb_input_files][stream]= scale;
2783 static int opt_recording_time(const char *opt, const char *arg)
2785 recording_time = parse_time_or_die(opt, arg, 1);
2789 static int opt_start_time(const char *opt, const char *arg)
2791 start_time = parse_time_or_die(opt, arg, 1);
2795 static int opt_rec_timestamp(const char *opt, const char *arg)
2797 rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2801 static int opt_input_ts_offset(const char *opt, const char *arg)
2803 input_ts_offset = parse_time_or_die(opt, arg, 1);
2807 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2809 const char *codec_string = encoder ? "encoder" : "decoder";
2813 return CODEC_ID_NONE;
2815 avcodec_find_encoder_by_name(name) :
2816 avcodec_find_decoder_by_name(name);
2818 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2821 if(codec->type != type) {
2822 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2828 static void opt_input_file(const char *filename)
2830 AVFormatContext *ic;
2831 AVFormatParameters params, *ap = ¶ms;
2832 AVInputFormat *file_iformat = NULL;
2833 int err, i, ret, rfps, rfps_base;
2836 if (last_asked_format) {
2837 file_iformat = av_find_input_format(last_asked_format);
2838 last_asked_format = NULL;
2841 if (!strcmp(filename, "-"))
2844 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2845 !strcmp(filename, "/dev/stdin");
2847 /* get default parameters from command line */
2848 ic = avformat_alloc_context();
2850 print_error(filename, AVERROR(ENOMEM));
2854 memset(ap, 0, sizeof(*ap));
2855 ap->prealloced_context = 1;
2856 ap->sample_rate = audio_sample_rate;
2857 ap->channels = audio_channels;
2858 ap->time_base.den = frame_rate.num;
2859 ap->time_base.num = frame_rate.den;
2860 ap->width = frame_width + frame_padleft + frame_padright;
2861 ap->height = frame_height + frame_padtop + frame_padbottom;
2862 ap->pix_fmt = frame_pix_fmt;
2863 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2864 ap->channel = video_channel;
2865 ap->standard = video_standard;
2866 ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2867 ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2868 if(pgmyuv_compatibility_hack)
2869 ap->video_codec_id= CODEC_ID_PGMYUV;
2871 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2873 ic->video_codec_id = find_codec_or_die(video_codec_name , CODEC_TYPE_VIDEO , 0);
2874 ic->audio_codec_id = find_codec_or_die(audio_codec_name , CODEC_TYPE_AUDIO , 0);
2875 ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2876 ic->flags |= AVFMT_FLAG_NONBLOCK;
2878 /* open the input file with generic libav function */
2879 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2881 print_error(filename, err);
2886 for(i=0; i<ic->nb_programs; i++)
2887 if(ic->programs[i]->id != opt_programid)
2888 ic->programs[i]->discard = AVDISCARD_ALL;
2891 ic->loop_input = loop_input;
2893 /* If not enough info to get the stream parameters, we decode the
2894 first frames to get it. (used in mpeg case for example) */
2895 ret = av_find_stream_info(ic);
2896 if (ret < 0 && verbose >= 0) {
2897 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2901 timestamp = start_time;
2902 /* add the stream start time */
2903 if (ic->start_time != AV_NOPTS_VALUE)
2904 timestamp += ic->start_time;
2906 /* if seeking requested, we execute it */
2907 if (start_time != 0) {
2908 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2910 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2911 filename, (double)timestamp / AV_TIME_BASE);
2913 /* reset seek info */
2917 /* update the current parameters so that they match the one of the input stream */
2918 for(i=0;i<ic->nb_streams;i++) {
2919 AVCodecContext *enc = ic->streams[i]->codec;
2921 avcodec_thread_init(enc, thread_count);
2922 enc->thread_count= thread_count;
2923 switch(enc->codec_type) {
2924 case CODEC_TYPE_AUDIO:
2925 set_context_opts(enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2926 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2927 channel_layout = enc->channel_layout;
2928 audio_channels = enc->channels;
2929 audio_sample_rate = enc->sample_rate;
2930 audio_sample_fmt = enc->sample_fmt;
2931 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
2933 ic->streams[i]->discard= AVDISCARD_ALL;
2935 case CODEC_TYPE_VIDEO:
2936 set_context_opts(enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2937 frame_height = enc->height;
2938 frame_width = enc->width;
2939 if(ic->streams[i]->sample_aspect_ratio.num)
2940 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
2942 frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
2943 frame_aspect_ratio *= (float) enc->width / enc->height;
2944 frame_pix_fmt = enc->pix_fmt;
2945 rfps = ic->streams[i]->r_frame_rate.num;
2946 rfps_base = ic->streams[i]->r_frame_rate.den;
2947 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2949 enc->debug |= FF_DEBUG_MV;
2951 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2954 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2955 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2957 (float)rfps / rfps_base, rfps, rfps_base);
2959 /* update the current frame rate to match the stream frame rate */
2960 frame_rate.num = rfps;
2961 frame_rate.den = rfps_base;
2963 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2965 ic->streams[i]->discard= AVDISCARD_ALL;
2966 else if(video_discard)
2967 ic->streams[i]->discard= video_discard;
2969 case CODEC_TYPE_DATA:
2971 case CODEC_TYPE_SUBTITLE:
2972 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
2973 if(subtitle_disable)
2974 ic->streams[i]->discard = AVDISCARD_ALL;
2976 case CODEC_TYPE_ATTACHMENT:
2977 case CODEC_TYPE_UNKNOWN:
2985 input_files[nb_input_files] = ic;
2986 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2987 /* dump the file content */
2989 dump_format(ic, nb_input_files, filename, 0);
2995 av_freep(&video_codec_name);
2996 av_freep(&audio_codec_name);
2997 av_freep(&subtitle_codec_name);
3000 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3001 int *has_subtitle_ptr)
3003 int has_video, has_audio, has_subtitle, i, j;
3004 AVFormatContext *ic;
3009 for(j=0;j<nb_input_files;j++) {
3010 ic = input_files[j];
3011 for(i=0;i<ic->nb_streams;i++) {
3012 AVCodecContext *enc = ic->streams[i]->codec;
3013 switch(enc->codec_type) {
3014 case CODEC_TYPE_AUDIO:
3017 case CODEC_TYPE_VIDEO:
3020 case CODEC_TYPE_SUBTITLE:
3023 case CODEC_TYPE_DATA:
3024 case CODEC_TYPE_ATTACHMENT:
3025 case CODEC_TYPE_UNKNOWN:
3032 *has_video_ptr = has_video;
3033 *has_audio_ptr = has_audio;
3034 *has_subtitle_ptr = has_subtitle;
3037 static void new_video_stream(AVFormatContext *oc)
3040 AVCodecContext *video_enc;
3041 enum CodecID codec_id;
3043 st = av_new_stream(oc, oc->nb_streams);
3045 fprintf(stderr, "Could not alloc stream\n");
3048 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
3049 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3050 video_bitstream_filters= NULL;
3053 avcodec_thread_init(st->codec, thread_count);
3055 video_enc = st->codec;
3058 video_enc->codec_tag= video_codec_tag;
3060 if( (video_global_header&1)
3061 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3062 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3063 avcodec_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3065 if(video_global_header&2){
3066 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3067 avcodec_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3070 if (video_stream_copy) {
3071 st->stream_copy = 1;
3072 video_enc->codec_type = CODEC_TYPE_VIDEO;
3073 video_enc->sample_aspect_ratio =
3074 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3079 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3081 if (video_codec_name) {
3082 codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3083 codec = avcodec_find_encoder_by_name(video_codec_name);
3084 output_codecs[nb_ocodecs] = codec;
3086 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3087 codec = avcodec_find_encoder(codec_id);
3090 video_enc->codec_id = codec_id;
3092 set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3094 if (codec && codec->supported_framerates && !force_fps)
3095 fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3096 video_enc->time_base.den = fps.num;
3097 video_enc->time_base.num = fps.den;
3099 video_enc->width = frame_width + frame_padright + frame_padleft;
3100 video_enc->height = frame_height + frame_padtop + frame_padbottom;
3101 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3102 video_enc->pix_fmt = frame_pix_fmt;
3103 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3105 if(codec && codec->pix_fmts){
3106 const enum PixelFormat *p= codec->pix_fmts;
3108 if(*p == video_enc->pix_fmt)
3112 video_enc->pix_fmt = codec->pix_fmts[0];
3116 video_enc->gop_size = 0;
3117 if (video_qscale || same_quality) {
3118 video_enc->flags |= CODEC_FLAG_QSCALE;
3119 video_enc->global_quality=
3120 st->quality = FF_QP2LAMBDA * video_qscale;
3124 video_enc->intra_matrix = intra_matrix;
3126 video_enc->inter_matrix = inter_matrix;
3128 video_enc->thread_count = thread_count;
3129 p= video_rc_override_string;
3132 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3134 fprintf(stderr, "error parsing rc_override\n");
3137 video_enc->rc_override=
3138 av_realloc(video_enc->rc_override,
3139 sizeof(RcOverride)*(i+1));
3140 video_enc->rc_override[i].start_frame= start;
3141 video_enc->rc_override[i].end_frame = end;
3143 video_enc->rc_override[i].qscale= q;
3144 video_enc->rc_override[i].quality_factor= 1.0;
3147 video_enc->rc_override[i].qscale= 0;
3148 video_enc->rc_override[i].quality_factor= -q/100.0;
3153 video_enc->rc_override_count=i;
3154 if (!video_enc->rc_initial_buffer_occupancy)
3155 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3156 video_enc->me_threshold= me_threshold;
3157 video_enc->intra_dc_precision= intra_dc_precision - 8;
3160 video_enc->flags|= CODEC_FLAG_PSNR;
3165 video_enc->flags |= CODEC_FLAG_PASS1;
3167 video_enc->flags |= CODEC_FLAG_PASS2;
3173 /* reset some key parameters */
3175 av_freep(&video_codec_name);
3176 video_stream_copy = 0;
3179 static void new_audio_stream(AVFormatContext *oc)
3182 AVCodecContext *audio_enc;
3183 enum CodecID codec_id;
3185 st = av_new_stream(oc, oc->nb_streams);
3187 fprintf(stderr, "Could not alloc stream\n");
3190 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3192 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3193 audio_bitstream_filters= NULL;
3196 avcodec_thread_init(st->codec, thread_count);
3198 audio_enc = st->codec;
3199 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3202 audio_enc->codec_tag= audio_codec_tag;
3204 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3205 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3206 avcodec_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3208 if (audio_stream_copy) {
3209 st->stream_copy = 1;
3210 audio_enc->channels = audio_channels;
3214 set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3216 if (audio_codec_name) {
3217 codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3218 codec = avcodec_find_encoder_by_name(audio_codec_name);
3219 output_codecs[nb_ocodecs] = codec;
3221 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3222 codec = avcodec_find_encoder(codec_id);
3224 audio_enc->codec_id = codec_id;
3226 if (audio_qscale > QSCALE_NONE) {
3227 audio_enc->flags |= CODEC_FLAG_QSCALE;
3228 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3230 audio_enc->thread_count = thread_count;
3231 audio_enc->channels = audio_channels;
3232 audio_enc->sample_fmt = audio_sample_fmt;
3233 audio_enc->channel_layout = channel_layout;
3234 if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3235 audio_enc->channel_layout = 0;
3237 if(codec && codec->sample_fmts){
3238 const enum SampleFormat *p= codec->sample_fmts;
3240 if(*p == audio_enc->sample_fmt)
3244 audio_enc->sample_fmt = codec->sample_fmts[0];
3248 audio_enc->sample_rate = audio_sample_rate;
3249 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3250 if (audio_language) {
3251 av_metadata_set(&st->metadata, "language", audio_language);
3252 av_free(audio_language);
3253 audio_language = NULL;
3256 /* reset some key parameters */
3258 av_freep(&audio_codec_name);
3259 audio_stream_copy = 0;
3262 static void new_subtitle_stream(AVFormatContext *oc)
3265 AVCodecContext *subtitle_enc;
3267 st = av_new_stream(oc, oc->nb_streams);
3269 fprintf(stderr, "Could not alloc stream\n");
3272 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3274 bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3275 subtitle_bitstream_filters= NULL;
3277 subtitle_enc = st->codec;
3278 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3280 if(subtitle_codec_tag)
3281 subtitle_enc->codec_tag= subtitle_codec_tag;
3283 if (subtitle_stream_copy) {
3284 st->stream_copy = 1;
3286 set_context_opts(avcodec_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3287 subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3288 output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3292 if (subtitle_language) {
3293 av_metadata_set(&st->metadata, "language", subtitle_language);
3294 av_free(subtitle_language);
3295 subtitle_language = NULL;
3298 subtitle_disable = 0;
3299 av_freep(&subtitle_codec_name);
3300 subtitle_stream_copy = 0;
3303 static void opt_new_audio_stream(void)
3305 AVFormatContext *oc;
3306 if (nb_output_files <= 0) {
3307 fprintf(stderr, "At least one output file must be specified\n");
3310 oc = output_files[nb_output_files - 1];
3311 new_audio_stream(oc);
3314 static void opt_new_video_stream(void)
3316 AVFormatContext *oc;
3317 if (nb_output_files <= 0) {
3318 fprintf(stderr, "At least one output file must be specified\n");
3321 oc = output_files[nb_output_files - 1];
3322 new_video_stream(oc);
3325 static void opt_new_subtitle_stream(void)
3327 AVFormatContext *oc;
3328 if (nb_output_files <= 0) {
3329 fprintf(stderr, "At least one output file must be specified\n");
3332 oc = output_files[nb_output_files - 1];
3333 new_subtitle_stream(oc);
3336 static void opt_output_file(const char *filename)
3338 AVFormatContext *oc;
3339 int use_video, use_audio, use_subtitle;
3340 int input_has_video, input_has_audio, input_has_subtitle;
3341 AVFormatParameters params, *ap = ¶ms;
3342 AVOutputFormat *file_oformat;
3344 if (!strcmp(filename, "-"))
3347 oc = avformat_alloc_context();
3349 print_error(filename, AVERROR(ENOMEM));
3353 if (last_asked_format) {
3354 file_oformat = guess_format(last_asked_format, NULL, NULL);
3355 if (!file_oformat) {
3356 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3359 last_asked_format = NULL;
3361 file_oformat = guess_format(NULL, filename, NULL);
3362 if (!file_oformat) {
3363 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3369 oc->oformat = file_oformat;
3370 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3372 if (!strcmp(file_oformat->name, "ffm") &&
3373 av_strstart(filename, "http:", NULL)) {
3374 /* special case for files sent to ffserver: we get the stream
3375 parameters from ffserver */
3376 int err = read_ffserver_streams(oc, filename);
3378 print_error(filename, err);
3382 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3383 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3384 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3386 /* disable if no corresponding type found and at least one
3388 if (nb_input_files > 0) {
3389 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3390 &input_has_subtitle);
3391 if (!input_has_video)
3393 if (!input_has_audio)
3395 if (!input_has_subtitle)
3399 /* manual disable */
3400 if (audio_disable) {
3403 if (video_disable) {
3406 if (subtitle_disable) {
3411 new_video_stream(oc);
3415 new_audio_stream(oc);
3419 new_subtitle_stream(oc);
3422 oc->timestamp = rec_timestamp;
3424 for(; metadata_count>0; metadata_count--){
3425 av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3426 metadata[metadata_count-1].value);
3428 av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3431 output_files[nb_output_files++] = oc;
3433 /* check filename in case of an image number is expected */
3434 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3435 if (!av_filename_number_test(oc->filename)) {
3436 print_error(oc->filename, AVERROR_NUMEXPECTED);
3441 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3442 /* test if it already exists to avoid loosing precious files */
3443 if (!file_overwrite &&
3444 (strchr(filename, ':') == NULL ||
3445 filename[1] == ':' ||
3446 av_strstart(filename, "file:", NULL))) {
3447 if (url_exist(filename)) {
3449 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3451 if (!read_yesno()) {
3452 fprintf(stderr, "Not overwriting - exiting\n");
3457 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3464 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3465 fprintf(stderr, "Could not open '%s'\n", filename);
3470 memset(ap, 0, sizeof(*ap));
3471 if (av_set_parameters(oc, ap) < 0) {
3472 fprintf(stderr, "%s: Invalid encoding parameters\n",
3477 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3478 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3479 oc->loop_output = loop_output;
3480 oc->flags |= AVFMT_FLAG_NONBLOCK;
3482 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3485 /* same option as mencoder */
3486 static void opt_pass(const char *pass_str)
3489 pass = atoi(pass_str);
3490 if (pass != 1 && pass != 2) {
3491 fprintf(stderr, "pass number can be only 1 or 2\n");
3497 static int64_t getutime(void)
3500 struct rusage rusage;
3502 getrusage(RUSAGE_SELF, &rusage);
3503 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3504 #elif HAVE_GETPROCESSTIMES
3506 FILETIME c, e, k, u;
3507 proc = GetCurrentProcess();
3508 GetProcessTimes(proc, &c, &e, &k, &u);
3509 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3511 return av_gettime();
3515 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3518 const char *p = str;
3525 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3532 static void opt_inter_matrix(const char *arg)
3534 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3535 parse_matrix_coeffs(inter_matrix, arg);
3538 static void opt_intra_matrix(const char *arg)
3540 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3541 parse_matrix_coeffs(intra_matrix, arg);
3545 * Trivial log callback.
3546 * Only suitable for show_help and similar since it lacks prefix handling.
3548 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3550 vfprintf(stdout, fmt, vl);
3553 static void show_help(void)
3555 av_log_set_callback(log_callback_help);
3556 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3557 "Hyper fast Audio and Video encoder\n");
3559 show_help_options(options, "Main options:\n",
3560 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3561 show_help_options(options, "\nAdvanced options:\n",
3562 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3564 show_help_options(options, "\nVideo options:\n",
3565 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3567 show_help_options(options, "\nAdvanced Video options:\n",
3568 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3569 OPT_VIDEO | OPT_EXPERT);
3570 show_help_options(options, "\nAudio options:\n",
3571 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3573 show_help_options(options, "\nAdvanced Audio options:\n",
3574 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3575 OPT_AUDIO | OPT_EXPERT);
3576 show_help_options(options, "\nSubtitle options:\n",
3577 OPT_SUBTITLE | OPT_GRAB,
3579 show_help_options(options, "\nAudio/Video grab options:\n",
3583 av_opt_show(avcodec_opts[0], NULL);
3585 av_opt_show(avformat_opts, NULL);
3587 av_opt_show(sws_opts, NULL);
3590 static void opt_target(const char *arg)
3593 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3595 if(!strncmp(arg, "pal-", 4)) {
3598 } else if(!strncmp(arg, "ntsc-", 5)) {
3601 } else if(!strncmp(arg, "film-", 5)) {
3606 /* Calculate FR via float to avoid int overflow */
3607 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3610 } else if((fr == 29970) || (fr == 23976)) {
3613 /* Try to determine PAL/NTSC by peeking in the input files */
3614 if(nb_input_files) {
3616 for(j = 0; j < nb_input_files; j++) {
3617 for(i = 0; i < input_files[j]->nb_streams; i++) {
3618 AVCodecContext *c = input_files[j]->streams[i]->codec;
3619 if(c->codec_type != CODEC_TYPE_VIDEO)
3621 fr = c->time_base.den * 1000 / c->time_base.num;
3625 } else if((fr == 29970) || (fr == 23976)) {
3635 if(verbose && norm >= 0)
3636 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3640 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3641 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3642 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3646 if(!strcmp(arg, "vcd")) {
3648 opt_video_codec("mpeg1video");
3649 opt_audio_codec("mp2");
3652 opt_frame_size(norm ? "352x240" : "352x288");
3653 opt_frame_rate(NULL, frame_rates[norm]);
3654 opt_default("g", norm ? "18" : "15");
3656 opt_default("b", "1150000");
3657 opt_default("maxrate", "1150000");
3658 opt_default("minrate", "1150000");
3659 opt_default("bufsize", "327680"); // 40*1024*8;
3661 opt_default("ab", "224000");
3662 audio_sample_rate = 44100;
3665 opt_default("packetsize", "2324");
3666 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3668 /* We have to offset the PTS, so that it is consistent with the SCR.
3669 SCR starts at 36000, but the first two packs contain only padding
3670 and the first pack from the other stream, respectively, may also have
3671 been written before.
3672 So the real data starts at SCR 36000+3*1200. */
3673 mux_preload= (36000+3*1200) / 90000.0; //0.44
3674 } else if(!strcmp(arg, "svcd")) {
3676 opt_video_codec("mpeg2video");
3677 opt_audio_codec("mp2");
3680 opt_frame_size(norm ? "480x480" : "480x576");
3681 opt_frame_rate(NULL, frame_rates[norm]);
3682 opt_default("g", norm ? "18" : "15");
3684 opt_default("b", "2040000");
3685 opt_default("maxrate", "2516000");
3686 opt_default("minrate", "0"); //1145000;
3687 opt_default("bufsize", "1835008"); //224*1024*8;
3688 opt_default("flags", "+scan_offset");
3691 opt_default("ab", "224000");
3692 audio_sample_rate = 44100;
3694 opt_default("packetsize", "2324");
3696 } else if(!strcmp(arg, "dvd")) {
3698 opt_video_codec("mpeg2video");
3699 opt_audio_codec("ac3");
3702 opt_frame_size(norm ? "720x480" : "720x576");
3703 opt_frame_rate(NULL, frame_rates[norm]);
3704 opt_default("g", norm ? "18" : "15");
3706 opt_default("b", "6000000");
3707 opt_default("maxrate", "9000000");
3708 opt_default("minrate", "0"); //1500000;
3709 opt_default("bufsize", "1835008"); //224*1024*8;
3711 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3712 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3714 opt_default("ab", "448000");
3715 audio_sample_rate = 48000;
3717 } else if(!strncmp(arg, "dv", 2)) {
3721 opt_frame_size(norm ? "720x480" : "720x576");
3722 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3723 (norm ? "yuv411p" : "yuv420p"));
3724 opt_frame_rate(NULL, frame_rates[norm]);
3726 audio_sample_rate = 48000;
3730 fprintf(stderr, "Unknown target: %s\n", arg);
3735 static void opt_vstats_file (const char *arg)
3737 av_free (vstats_filename);
3738 vstats_filename=av_strdup (arg);
3741 static void opt_vstats (void)
3744 time_t today2 = time(NULL);
3745 struct tm *today = localtime(&today2);
3747 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3749 opt_vstats_file(filename);
3752 static int opt_bsf(const char *opt, const char *arg)
3754 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3755 AVBitStreamFilterContext **bsfp;
3758 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3762 bsfp= *opt == 'v' ? &video_bitstream_filters :
3763 *opt == 'a' ? &audio_bitstream_filters :
3764 &subtitle_bitstream_filters;
3766 bsfp= &(*bsfp)->next;
3773 static int opt_preset(const char *opt, const char *arg)
3776 char filename[1000], tmp[1000], tmp2[1000], line[1000];
3778 const char *base[2]= { getenv("HOME"),
3783 for(i=!base[0]; i<2 && !f; i++){
3784 snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
3785 f= fopen(filename, "r");
3787 char *codec_name= *opt == 'v' ? video_codec_name :
3788 *opt == 'a' ? audio_codec_name :
3789 subtitle_codec_name;
3790 snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i], i ? "" : "/.ffmpeg", codec_name, arg);
3791 f= fopen(filename, "r");
3795 av_strlcpy(filename, arg, sizeof(filename));
3796 f= fopen(filename, "r");
3800 fprintf(stderr, "File for preset '%s' not found\n", arg);
3805 int e= fscanf(f, "%999[^\n]\n", line) - 1;
3806 if(line[0] == '#' && !e)
3808 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3810 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3813 if(!strcmp(tmp, "acodec")){
3814 opt_audio_codec(tmp2);
3815 }else if(!strcmp(tmp, "vcodec")){
3816 opt_video_codec(tmp2);
3817 }else if(!strcmp(tmp, "scodec")){
3818 opt_subtitle_codec(tmp2);
3819 }else if(opt_default(tmp, tmp2) < 0){
3820 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3830 static const OptionDef options[] = {
3832 #include "cmdutils_common_opts.h"
3833 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3834 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3835 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3836 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3837 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3838 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3839 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3840 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3841 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3842 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
3843 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_rec_timestamp}, "set the timestamp ('now' to set the current time)", "time" },
3844 { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
3845 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3846 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3847 "add timings for benchmarking" },
3848 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3849 "dump each input packet" },
3850 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3851 "when dumping packets, also dump the payload" },
3852 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3853 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3854 { "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)", "" },
3855 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
3856 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3857 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3858 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3859 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3860 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3861 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3862 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3863 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3864 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3865 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3866 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
3867 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
3870 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3871 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3872 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3873 { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3874 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3875 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3876 { "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" },
3877 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3878 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3879 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3880 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3881 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3882 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3883 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3884 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3885 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3886 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3887 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3888 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3889 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3890 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3891 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3892 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
3893 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3894 "use same video quality as source (implies VBR)" },
3895 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3896 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
3897 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3898 "deinterlace pictures" },
3899 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3900 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3901 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3902 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3903 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3904 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3905 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3906 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3907 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3908 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3909 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
3912 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3913 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3914 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3915 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3916 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3917 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3918 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3919 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3920 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3921 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3922 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3923 { "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" },
3925 /* subtitle options */
3926 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3927 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3928 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3929 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3930 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
3933 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3934 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3935 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3938 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3939 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3941 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3942 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3943 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3945 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3946 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3947 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3948 { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
3950 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3954 int main(int argc, char **argv)
3959 avcodec_register_all();
3960 avdevice_register_all();
3964 if(isatty(STDIN_FILENO))
3965 url_set_interrupt_cb(decode_interrupt_cb);
3968 for(i=0; i<CODEC_TYPE_NB; i++){
3969 avcodec_opts[i]= avcodec_alloc_context2(i);
3971 avformat_opts = avformat_alloc_context();
3972 sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3977 parse_options(argc, argv, options, opt_output_file);
3979 /* file converter / grab */
3980 if (nb_output_files <= 0) {
3981 fprintf(stderr, "At least one output file must be specified\n");
3985 if (nb_input_files == 0) {
3986 fprintf(stderr, "At least one input file must be specified\n");
3991 if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
3992 stream_maps, nb_stream_maps) < 0)
3994 ti = getutime() - ti;
3996 printf("bench: utime=%0.3fs\n", ti / 1000000.0);