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 "libavutil/fifo.h"
40 #include "libavutil/avstring.h"
41 #include "libavformat/os_support.h"
43 #if HAVE_SYS_RESOURCE_H
44 #include <sys/types.h>
45 #include <sys/resource.h>
46 #elif HAVE_GETPROCESSTIMES
51 #include <sys/select.h>
56 #include <sys/ioctl.h>
62 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
72 const char program_name[] = "FFmpeg";
73 const int program_birth_year = 2000;
75 /* select an input stream for an output stream */
76 typedef struct AVStreamMap {
80 int sync_stream_index;
83 /** select an input file for an output file */
84 typedef struct AVMetaDataMap {
89 static const OptionDef options[];
93 static AVFormatContext *input_files[MAX_FILES];
94 static int64_t input_files_ts_offset[MAX_FILES];
95 static double input_files_ts_scale[MAX_FILES][MAX_STREAMS];
96 static AVCodec *input_codecs[MAX_FILES*MAX_STREAMS];
97 static int nb_input_files = 0;
98 static int nb_icodecs;
100 static AVFormatContext *output_files[MAX_FILES];
101 static AVCodec *output_codecs[MAX_FILES*MAX_STREAMS];
102 static int nb_output_files = 0;
103 static int nb_ocodecs;
105 static AVStreamMap stream_maps[MAX_FILES*MAX_STREAMS];
106 static int nb_stream_maps;
108 static AVMetaDataMap meta_data_maps[MAX_FILES];
109 static int nb_meta_data_maps;
111 static AVInputFormat *file_iformat;
112 static AVOutputFormat *file_oformat;
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 #if 0 //experimental, (can be removed)
133 static float video_rc_qsquish=1.0;
134 static float video_rc_qmod_amp=0;
135 static int video_rc_qmod_freq=0;
137 static const char *video_rc_override_string=NULL;
138 static int video_disable = 0;
139 static int video_discard = 0;
140 static char *video_codec_name = NULL;
141 static int video_codec_tag = 0;
142 static int same_quality = 0;
143 static int do_deinterlace = 0;
144 static int top_field_first = -1;
145 static int me_threshold = 0;
146 static int intra_dc_precision = 8;
147 static int loop_input = 0;
148 static int loop_output = AVFMT_NOOUTPUTLOOP;
149 static int qp_hist = 0;
151 static int intra_only = 0;
152 static int audio_sample_rate = 44100;
153 static int64_t channel_layout = 0;
154 #define QSCALE_NONE -99999
155 static float audio_qscale = QSCALE_NONE;
156 static int audio_disable = 0;
157 static int audio_channels = 1;
158 static char *audio_codec_name = NULL;
159 static int audio_codec_tag = 0;
160 static char *audio_language = NULL;
162 static int subtitle_disable = 0;
163 static char *subtitle_codec_name = NULL;
164 static char *subtitle_language = NULL;
165 static int subtitle_codec_tag = 0;
167 static float mux_preload= 0.5;
168 static float mux_max_delay= 0.7;
170 static int64_t recording_time = INT64_MAX;
171 static int64_t start_time = 0;
172 static int64_t rec_timestamp = 0;
173 static int64_t input_ts_offset = 0;
174 static int file_overwrite = 0;
175 static int metadata_count;
176 static AVMetadataTag *metadata;
177 static int do_benchmark = 0;
178 static int do_hex_dump = 0;
179 static int do_pkt_dump = 0;
180 static int do_psnr = 0;
181 static int do_pass = 0;
182 static char *pass_logfilename_prefix = NULL;
183 static int audio_stream_copy = 0;
184 static int video_stream_copy = 0;
185 static int subtitle_stream_copy = 0;
186 static int video_sync_method= -1;
187 static int audio_sync_method= 0;
188 static float audio_drift_threshold= 0.1;
189 static int copy_ts= 0;
190 static int opt_shortest = 0;
191 static int video_global_header = 0;
192 static char *vstats_filename;
193 static FILE *vstats_file;
194 static int opt_programid = 0;
195 static int copy_initial_nonkeyframes = 0;
197 static int rate_emu = 0;
199 static int video_channel = 0;
200 static char *video_standard;
202 static int audio_volume = 256;
204 static int exit_on_error = 0;
205 static int using_stdin = 0;
206 static int verbose = 1;
207 static int thread_count= 1;
208 static int q_pressed = 0;
209 static int64_t video_size = 0;
210 static int64_t audio_size = 0;
211 static int64_t extra_size = 0;
212 static int nb_frames_dup = 0;
213 static int nb_frames_drop = 0;
214 static int input_sync;
215 static uint64_t limit_filesize = 0;
216 static int force_fps = 0;
218 static int pgmyuv_compatibility_hack=0;
219 static float dts_delta_threshold = 10;
221 static unsigned int sws_flags = SWS_BICUBIC;
223 static int64_t timer_start;
225 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
226 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
227 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
228 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
230 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
232 struct AVInputStream;
234 typedef struct AVOutputStream {
235 int file_index; /* file index */
236 int index; /* stream index in the output file */
237 int source_index; /* AVInputStream index */
238 AVStream *st; /* stream in the output file */
239 int encoding_needed; /* true if encoding needed for this stream */
241 /* input pts and corresponding output pts
243 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
244 struct AVInputStream *sync_ist; /* input stream to sync against */
245 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
248 AVFrame pict_tmp; /* temporary image for resampling */
249 struct SwsContext *img_resample_ctx; /* for image resampling */
253 int topBand; /* cropping area sizes */
257 int padtop; /* padding area sizes */
264 ReSampleContext *resample; /* for audio resampling */
266 AVAudioConvert *reformat_ctx;
267 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
271 typedef struct AVInputStream {
275 int discard; /* true if stream data should be discarded */
276 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
277 int64_t sample_index; /* current sample */
279 int64_t start; /* time when read started */
280 int64_t next_pts; /* synthetic pts for cases where pkt.pts
282 int64_t pts; /* current pts */
283 int is_start; /* is 1 at the start and after a discontinuity */
286 typedef struct AVInputFile {
287 int eof_reached; /* true if eof reached */
288 int ist_index; /* index of first stream in ist_table */
289 int buffer_size; /* current total buffer size */
290 int nb_streams; /* nb streams we are aware of */
295 /* init terminal so that we can grab keys */
296 static struct termios oldtty;
299 static void term_exit(void)
302 tcsetattr (0, TCSANOW, &oldtty);
306 static volatile sig_atomic_t received_sigterm = 0;
309 sigterm_handler(int sig)
311 received_sigterm = sig;
315 static void term_init(void)
323 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
324 |INLCR|IGNCR|ICRNL|IXON);
325 tty.c_oflag |= OPOST;
326 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
327 tty.c_cflag &= ~(CSIZE|PARENB);
332 tcsetattr (0, TCSANOW, &tty);
333 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
336 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
337 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
339 register a function to be called at normal program termination
342 #if CONFIG_BEOS_NETSERVER
343 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
347 /* read a key without blocking */
348 static int read_key(void)
353 #if !CONFIG_BEOS_NETSERVER
361 n = select(1, &rfds, NULL, NULL, &tv);
377 static int decode_interrupt_cb(void)
379 return q_pressed || (q_pressed = read_key() == 'q');
382 static int av_exit(int ret)
387 for(i=0;i<nb_output_files;i++) {
388 /* maybe av_close_output_file ??? */
389 AVFormatContext *s = output_files[i];
391 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
393 for(j=0;j<s->nb_streams;j++) {
394 av_metadata_free(&s->streams[j]->metadata);
395 av_free(s->streams[j]->codec);
396 av_free(s->streams[j]);
398 for(j=0;j<s->nb_programs;j++) {
399 av_metadata_free(&s->programs[j]->metadata);
401 for(j=0;j<s->nb_chapters;j++) {
402 av_metadata_free(&s->chapters[j]->metadata);
404 av_metadata_free(&s->metadata);
407 for(i=0;i<nb_input_files;i++)
408 av_close_input_file(input_files[i]);
410 av_free(intra_matrix);
411 av_free(inter_matrix);
415 av_free(vstats_filename);
419 av_free(video_codec_name);
420 av_free(audio_codec_name);
421 av_free(subtitle_codec_name);
423 av_free(video_standard);
425 #if CONFIG_POWERPC_PERF
426 void powerpc_display_perf_report(void);
427 powerpc_display_perf_report();
428 #endif /* CONFIG_POWERPC_PERF */
430 if (received_sigterm) {
432 "Received signal %d: terminating.\n",
433 (int) received_sigterm);
437 exit(ret); /* not all OS-es handle main() return value */
441 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
447 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
450 /* copy stream format */
451 s->nb_streams = ic->nb_streams;
452 for(i=0;i<ic->nb_streams;i++) {
455 // FIXME: a more elegant solution is needed
456 st = av_mallocz(sizeof(AVStream));
457 memcpy(st, ic->streams[i], sizeof(AVStream));
458 st->codec = avcodec_alloc_context();
459 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
462 if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
464 else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
467 if(!st->codec->thread_count)
468 st->codec->thread_count = 1;
469 if(st->codec->thread_count>1)
470 avcodec_thread_init(st->codec, st->codec->thread_count);
472 if(st->codec->flags & CODEC_FLAG_BITEXACT)
477 s->timestamp = av_gettime();
479 av_close_input_file(ic);
484 get_sync_ipts(const AVOutputStream *ost)
486 const AVInputStream *ist = ost->sync_ist;
487 return (double)(ist->pts - start_time)/AV_TIME_BASE;
490 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
494 AVPacket new_pkt= *pkt;
495 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
496 &new_pkt.data, &new_pkt.size,
497 pkt->data, pkt->size,
498 pkt->flags & PKT_FLAG_KEY);
501 new_pkt.destruct= av_destruct_packet;
503 fprintf(stderr, "%s failed for stream %d, codec %s",
504 bsfc->filter->name, pkt->stream_index,
505 avctx->codec ? avctx->codec->name : "copy");
515 ret= av_interleaved_write_frame(s, pkt);
517 print_error("av_interleaved_write_frame()", ret);
522 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
524 static void do_audio_out(AVFormatContext *s,
527 unsigned char *buf, int size)
530 static uint8_t *audio_buf = NULL;
531 static uint8_t *audio_out = NULL;
532 static uint8_t *audio_out2 = NULL;
533 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
535 int size_out, frame_bytes, ret;
536 AVCodecContext *enc= ost->st->codec;
537 AVCodecContext *dec= ist->st->codec;
538 int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
539 int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
541 /* SC: dynamic allocation of buffers */
543 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
545 audio_out = av_malloc(audio_out_size);
546 if (!audio_buf || !audio_out)
547 return; /* Should signal an error ! */
549 if (enc->channels != dec->channels)
550 ost->audio_resample = 1;
552 if (ost->audio_resample && !ost->resample) {
553 if (dec->sample_fmt != SAMPLE_FMT_S16)
554 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
555 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
556 enc->sample_rate, dec->sample_rate,
557 enc->sample_fmt, dec->sample_fmt,
559 if (!ost->resample) {
560 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
561 dec->channels, dec->sample_rate,
562 enc->channels, enc->sample_rate);
567 #define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
568 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
569 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
571 audio_out2 = av_malloc(audio_out_size);
574 if (ost->reformat_ctx)
575 av_audio_convert_free(ost->reformat_ctx);
576 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
577 dec->sample_fmt, 1, NULL, 0);
578 if (!ost->reformat_ctx) {
579 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
580 avcodec_get_sample_fmt_name(dec->sample_fmt),
581 avcodec_get_sample_fmt_name(enc->sample_fmt));
584 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
587 if(audio_sync_method){
588 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
589 - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2);
590 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
591 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
593 //FIXME resample delay
594 if(fabs(delta) > 50){
595 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
597 byte_delta= FFMAX(byte_delta, -size);
601 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
606 static uint8_t *input_tmp= NULL;
607 input_tmp= av_realloc(input_tmp, byte_delta + size);
609 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
612 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
614 memset(input_tmp, 0, byte_delta);
615 memcpy(input_tmp + byte_delta, buf, size);
619 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
621 }else if(audio_sync_method>1){
622 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
623 assert(ost->audio_resample);
625 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
626 // 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));
627 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
631 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
632 - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
634 if (ost->audio_resample) {
636 size_out = audio_resample(ost->resample,
637 (short *)buftmp, (short *)buf,
638 size / (ist->st->codec->channels * isize));
639 size_out = size_out * enc->channels * osize;
645 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
646 const void *ibuf[6]= {buftmp};
647 void *obuf[6]= {audio_out2};
648 int istride[6]= {isize};
649 int ostride[6]= {osize};
650 int len= size_out/istride[0];
651 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
652 printf("av_audio_convert() failed\n");
658 size_out = len*osize;
661 /* now encode as many frames as possible */
662 if (enc->frame_size > 1) {
663 /* output resampled raw samples */
664 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
665 fprintf(stderr, "av_fifo_realloc2() failed\n");
668 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
670 frame_bytes = enc->frame_size * osize * enc->channels;
672 while (av_fifo_size(ost->fifo) >= frame_bytes) {
674 av_init_packet(&pkt);
676 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
678 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
680 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
683 fprintf(stderr, "Audio encoding failed\n");
687 pkt.stream_index= ost->index;
690 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
691 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
692 pkt.flags |= PKT_FLAG_KEY;
693 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
695 ost->sync_opts += enc->frame_size;
699 int coded_bps = av_get_bits_per_sample(enc->codec->id)/8;
700 av_init_packet(&pkt);
702 ost->sync_opts += size_out / (osize * enc->channels);
704 /* output a pcm frame */
705 /* determine the size of the coded buffer */
708 size_out *= coded_bps;
710 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
711 ret = avcodec_encode_audio(enc, audio_out, size_out,
714 fprintf(stderr, "Audio encoding failed\n");
718 pkt.stream_index= ost->index;
721 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
722 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
723 pkt.flags |= PKT_FLAG_KEY;
724 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
728 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
732 AVPicture picture_tmp;
735 dec = ist->st->codec;
737 /* deinterlace : must be done before any resize */
738 if (do_deinterlace) {
741 /* create temporary picture */
742 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
743 buf = av_malloc(size);
747 picture2 = &picture_tmp;
748 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
751 if(avpicture_deinterlace(picture2, picture,
752 dec->pix_fmt, dec->width, dec->height) < 0) {
753 /* if error, do not deinterlace */
754 fprintf(stderr, "Deinterlacing failed\n");
760 av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
766 if (picture != picture2)
767 *picture = *picture2;
771 /* we begin to correct av delay at this threshold */
772 #define AV_DELAY_MAX 0.100
774 static void do_subtitle_out(AVFormatContext *s,
780 static uint8_t *subtitle_out = NULL;
781 int subtitle_out_max_size = 65536;
782 int subtitle_out_size, nb, i;
786 if (pts == AV_NOPTS_VALUE) {
787 fprintf(stderr, "Subtitle packets must have a pts\n");
793 enc = ost->st->codec;
796 subtitle_out = av_malloc(subtitle_out_max_size);
799 /* Note: DVB subtitle need one packet to draw them and one other
800 packet to clear them */
801 /* XXX: signal it in the codec context ? */
802 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
807 for(i = 0; i < nb; i++) {
808 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
809 subtitle_out_max_size, sub);
811 av_init_packet(&pkt);
812 pkt.stream_index = ost->index;
813 pkt.data = subtitle_out;
814 pkt.size = subtitle_out_size;
815 pkt.pts = av_rescale_q(pts, ist->st->time_base, ost->st->time_base);
816 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
817 /* XXX: the pts correction is handled here. Maybe handling
818 it in the codec would be better */
820 pkt.pts += 90 * sub->start_display_time;
822 pkt.pts += 90 * sub->end_display_time;
824 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
828 static int bit_buffer_size= 1024*256;
829 static uint8_t *bit_buffer= NULL;
831 static void do_video_out(AVFormatContext *s,
837 int nb_frames, i, ret;
838 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
839 AVFrame picture_crop_temp, picture_pad_temp;
840 AVCodecContext *enc, *dec;
842 avcodec_get_frame_defaults(&picture_crop_temp);
843 avcodec_get_frame_defaults(&picture_pad_temp);
845 enc = ost->st->codec;
846 dec = ist->st->codec;
848 /* by default, we output a single frame */
853 if(video_sync_method>0 || (video_sync_method && av_q2d(enc->time_base) > 0.001)){
855 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
856 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
859 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
863 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
864 }else if (vdelta > 1.1)
865 nb_frames = lrintf(vdelta);
866 //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);
870 fprintf(stderr, "*** drop!\n");
871 }else if (nb_frames > 1) {
872 nb_frames_dup += nb_frames;
874 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
877 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
879 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
883 if (ost->video_crop) {
884 if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
885 fprintf(stderr, "error cropping picture\n");
890 formatted_picture = &picture_crop_temp;
892 formatted_picture = in_picture;
895 final_picture = formatted_picture;
896 padding_src = formatted_picture;
897 resampling_dst = &ost->pict_tmp;
898 if (ost->video_pad) {
899 final_picture = &ost->pict_tmp;
900 if (ost->video_resample) {
901 if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
902 fprintf(stderr, "error padding picture\n");
907 resampling_dst = &picture_pad_temp;
911 if (ost->video_resample) {
913 final_picture = &ost->pict_tmp;
914 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
915 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
918 if (ost->video_pad) {
919 av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
920 enc->height, enc->width, enc->pix_fmt,
921 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
924 /* duplicates frame if needed */
925 for(i=0;i<nb_frames;i++) {
927 av_init_packet(&pkt);
928 pkt.stream_index= ost->index;
930 if (s->oformat->flags & AVFMT_RAWPICTURE) {
931 /* raw pictures are written as AVPicture structure to
932 avoid any copies. We support temorarily the older
934 AVFrame* old_frame = enc->coded_frame;
935 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
936 pkt.data= (uint8_t *)final_picture;
937 pkt.size= sizeof(AVPicture);
938 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
939 pkt.flags |= PKT_FLAG_KEY;
941 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
942 enc->coded_frame = old_frame;
946 big_picture= *final_picture;
947 /* better than nothing: use input picture interlaced
949 big_picture.interlaced_frame = in_picture->interlaced_frame;
950 if(avcodec_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
951 if(top_field_first == -1)
952 big_picture.top_field_first = in_picture->top_field_first;
954 big_picture.top_field_first = top_field_first;
957 /* handles sameq here. This is not correct because it may
958 not be a global option */
960 big_picture.quality = ist->st->quality;
962 big_picture.quality = ost->st->quality;
964 big_picture.pict_type = 0;
965 // big_picture.pts = AV_NOPTS_VALUE;
966 big_picture.pts= ost->sync_opts;
967 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
968 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
969 ret = avcodec_encode_video(enc,
970 bit_buffer, bit_buffer_size,
973 fprintf(stderr, "Video encoding failed\n");
976 //enc->frame_number = enc->real_pict_num;
978 pkt.data= bit_buffer;
980 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
981 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
982 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
983 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
984 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
986 if(enc->coded_frame->key_frame)
987 pkt.flags |= PKT_FLAG_KEY;
988 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
991 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
992 // enc->frame_number-1, enc->real_pict_num, ret,
994 /* if two pass, output log */
995 if (ost->logfile && enc->stats_out) {
996 fprintf(ost->logfile, "%s", enc->stats_out);
1001 ost->frame_number++;
1005 static double psnr(double d){
1006 return -10.0*log(d)/log(10.0);
1009 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1012 AVCodecContext *enc;
1014 double ti1, bitrate, avg_bitrate;
1016 /* this is executed just the first time do_video_stats is called */
1018 vstats_file = fopen(vstats_filename, "w");
1025 enc = ost->st->codec;
1026 if (enc->codec_type == CODEC_TYPE_VIDEO) {
1027 frame_number = ost->frame_number;
1028 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1029 if (enc->flags&CODEC_FLAG_PSNR)
1030 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1032 fprintf(vstats_file,"f_size= %6d ", frame_size);
1033 /* compute pts value */
1034 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1038 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1039 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1040 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1041 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1042 fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1046 static void print_report(AVFormatContext **output_files,
1047 AVOutputStream **ost_table, int nb_ostreams,
1051 AVOutputStream *ost;
1052 AVFormatContext *oc, *os;
1054 AVCodecContext *enc;
1055 int frame_number, vid, i;
1056 double bitrate, ti1, pts;
1057 static int64_t last_time = -1;
1058 static int qp_histogram[52];
1060 if (!is_last_report) {
1062 /* display the report every 0.5 seconds */
1063 cur_time = av_gettime();
1064 if (last_time == -1) {
1065 last_time = cur_time;
1068 if ((cur_time - last_time) < 500000)
1070 last_time = cur_time;
1074 oc = output_files[0];
1076 total_size = url_fsize(oc->pb);
1077 if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1078 total_size= url_ftell(oc->pb);
1083 for(i=0;i<nb_ostreams;i++) {
1085 os = output_files[ost->file_index];
1086 enc = ost->st->codec;
1087 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1088 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1089 !ost->st->stream_copy ?
1090 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1092 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1093 float t = (av_gettime()-timer_start) / 1000000.0;
1095 frame_number = ost->frame_number;
1096 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1097 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1098 !ost->st->stream_copy ?
1099 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1101 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1104 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1105 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1108 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1110 if (enc->flags&CODEC_FLAG_PSNR){
1112 double error, error_sum=0;
1113 double scale, scale_sum=0;
1114 char type[3]= {'Y','U','V'};
1115 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1118 error= enc->error[j];
1119 scale= enc->width*enc->height*255.0*255.0*frame_number;
1121 error= enc->coded_frame->error[j];
1122 scale= enc->width*enc->height*255.0*255.0;
1127 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1129 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1133 /* compute min output value */
1134 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1135 if ((pts < ti1) && (pts > 0))
1141 if (verbose || is_last_report) {
1142 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1144 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1145 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1146 (double)total_size / 1024, ti1, bitrate);
1149 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1150 nb_frames_dup, nb_frames_drop);
1153 fprintf(stderr, "%s \r", buf);
1158 if (is_last_report && verbose >= 0){
1159 int64_t raw= audio_size + video_size + extra_size;
1160 fprintf(stderr, "\n");
1161 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1165 100.0*(total_size - raw)/raw
1170 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1171 static int output_packet(AVInputStream *ist, int ist_index,
1172 AVOutputStream **ost_table, int nb_ostreams,
1173 const AVPacket *pkt)
1175 AVFormatContext *os;
1176 AVOutputStream *ost;
1179 int data_size, got_picture;
1181 void *buffer_to_free;
1182 static unsigned int samples_size= 0;
1183 static short *samples= NULL;
1184 AVSubtitle subtitle, *subtitle_to_free;
1188 if(ist->next_pts == AV_NOPTS_VALUE)
1189 ist->next_pts= ist->pts;
1193 av_init_packet(&avpkt);
1201 if(pkt->dts != AV_NOPTS_VALUE)
1202 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1204 //while we have more to decode or while the decoder did output something on EOF
1205 while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1207 ist->pts= ist->next_pts;
1209 if(avpkt.size && avpkt.size != pkt->size && verbose>0)
1210 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1212 /* decode the packet if needed */
1213 data_buf = NULL; /* fail safe */
1215 subtitle_to_free = NULL;
1216 if (ist->decoding_needed) {
1217 switch(ist->st->codec->codec_type) {
1218 case CODEC_TYPE_AUDIO:{
1219 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1220 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1222 samples= av_malloc(samples_size);
1224 data_size= samples_size;
1225 /* XXX: could avoid copy if PCM 16 bits with same
1226 endianness as CPU */
1227 ret = avcodec_decode_audio3(ist->st->codec, samples, &data_size,
1233 /* Some bug in mpeg audio decoder gives */
1234 /* data_size < 0, it seems they are overflows */
1235 if (data_size <= 0) {
1236 /* no audio frame */
1239 data_buf = (uint8_t *)samples;
1240 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1241 (ist->st->codec->sample_rate * ist->st->codec->channels);
1243 case CODEC_TYPE_VIDEO:
1244 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1245 /* XXX: allocate picture correctly */
1246 avcodec_get_frame_defaults(&picture);
1248 ret = avcodec_decode_video2(ist->st->codec,
1249 &picture, &got_picture, &avpkt);
1250 ist->st->quality= picture.quality;
1254 /* no picture yet */
1255 goto discard_packet;
1257 if (ist->st->codec->time_base.num != 0) {
1258 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1259 ist->next_pts += ((int64_t)AV_TIME_BASE *
1260 ist->st->codec->time_base.num * ticks) /
1261 ist->st->codec->time_base.den;
1265 case CODEC_TYPE_SUBTITLE:
1266 ret = avcodec_decode_subtitle2(ist->st->codec,
1267 &subtitle, &got_subtitle, &avpkt);
1270 if (!got_subtitle) {
1271 goto discard_packet;
1273 subtitle_to_free = &subtitle;
1280 switch(ist->st->codec->codec_type) {
1281 case CODEC_TYPE_AUDIO:
1282 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1283 ist->st->codec->sample_rate;
1285 case CODEC_TYPE_VIDEO:
1286 if (ist->st->codec->time_base.num != 0) {
1287 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1288 ist->next_pts += ((int64_t)AV_TIME_BASE *
1289 ist->st->codec->time_base.num * ticks) /
1290 ist->st->codec->time_base.den;
1294 data_buf = avpkt.data;
1295 data_size = avpkt.size;
1300 buffer_to_free = NULL;
1301 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1302 pre_process_video_frame(ist, (AVPicture *)&picture,
1306 // preprocess audio (volume)
1307 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1308 if (audio_volume != 256) {
1311 for(i=0;i<(data_size / sizeof(short));i++) {
1312 int v = ((*volp) * audio_volume + 128) >> 8;
1313 if (v < -32768) v = -32768;
1314 if (v > 32767) v = 32767;
1320 /* frame rate emulation */
1322 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1323 int64_t now = av_gettime() - ist->start;
1328 /* if output time reached then transcode raw format,
1329 encode packets and output them */
1330 if (start_time == 0 || ist->pts >= start_time)
1331 for(i=0;i<nb_ostreams;i++) {
1335 if (ost->source_index == ist_index) {
1336 os = output_files[ost->file_index];
1339 printf("%d: got pts=%0.3f %0.3f\n", i,
1340 (double)pkt->pts / AV_TIME_BASE,
1341 ((double)ist->pts / AV_TIME_BASE) -
1342 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1344 /* set the input output pts pairs */
1345 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1347 if (ost->encoding_needed) {
1348 switch(ost->st->codec->codec_type) {
1349 case CODEC_TYPE_AUDIO:
1350 do_audio_out(os, ost, ist, data_buf, data_size);
1352 case CODEC_TYPE_VIDEO:
1353 do_video_out(os, ost, ist, &picture, &frame_size);
1354 if (vstats_filename && frame_size)
1355 do_video_stats(os, ost, frame_size);
1357 case CODEC_TYPE_SUBTITLE:
1358 do_subtitle_out(os, ost, ist, &subtitle,
1365 AVFrame avframe; //FIXME/XXX remove this
1367 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1369 av_init_packet(&opkt);
1371 if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1374 /* no reencoding needed : output the packet directly */
1375 /* force the input stream PTS */
1377 avcodec_get_frame_defaults(&avframe);
1378 ost->st->codec->coded_frame= &avframe;
1379 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1381 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1382 audio_size += data_size;
1383 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1384 video_size += data_size;
1388 opkt.stream_index= ost->index;
1389 if(pkt->pts != AV_NOPTS_VALUE)
1390 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1392 opkt.pts= AV_NOPTS_VALUE;
1394 if (pkt->dts == AV_NOPTS_VALUE)
1395 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1397 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1398 opkt.dts -= ost_tb_start_time;
1400 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1401 opkt.flags= pkt->flags;
1403 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1404 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1405 opkt.destruct= av_destruct_packet;
1407 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1408 ost->st->codec->frame_number++;
1409 ost->frame_number++;
1410 av_free_packet(&opkt);
1414 av_free(buffer_to_free);
1415 /* XXX: allocate the subtitles in the codec ? */
1416 if (subtitle_to_free) {
1417 if (subtitle_to_free->rects != NULL) {
1418 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1419 av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1420 av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1421 av_freep(&subtitle_to_free->rects[i]);
1423 av_freep(&subtitle_to_free->rects);
1425 subtitle_to_free->num_rects = 0;
1426 subtitle_to_free = NULL;
1433 for(i=0;i<nb_ostreams;i++) {
1435 if (ost->source_index == ist_index) {
1436 AVCodecContext *enc= ost->st->codec;
1437 os = output_files[ost->file_index];
1439 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1441 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1444 if (ost->encoding_needed) {
1448 av_init_packet(&pkt);
1449 pkt.stream_index= ost->index;
1451 switch(ost->st->codec->codec_type) {
1452 case CODEC_TYPE_AUDIO:
1453 fifo_bytes = av_fifo_size(ost->fifo);
1455 /* encode any samples remaining in fifo */
1456 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1457 int fs_tmp = enc->frame_size;
1458 enc->frame_size = fifo_bytes / (2 * enc->channels);
1459 av_fifo_generic_read(ost->fifo, samples, fifo_bytes, NULL);
1460 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1461 enc->frame_size = fs_tmp;
1464 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1467 fprintf(stderr, "Audio encoding failed\n");
1471 pkt.flags |= PKT_FLAG_KEY;
1473 case CODEC_TYPE_VIDEO:
1474 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1476 fprintf(stderr, "Video encoding failed\n");
1480 if(enc->coded_frame && enc->coded_frame->key_frame)
1481 pkt.flags |= PKT_FLAG_KEY;
1482 if (ost->logfile && enc->stats_out) {
1483 fprintf(ost->logfile, "%s", enc->stats_out);
1492 pkt.data= bit_buffer;
1494 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1495 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1496 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1508 static void print_sdp(AVFormatContext **avc, int n)
1512 avf_sdp_create(avc, n, sdp, sizeof(sdp));
1513 printf("SDP:\n%s\n", sdp);
1517 static int stream_index_from_inputs(AVFormatContext **input_files,
1519 AVInputFile *file_table,
1520 AVInputStream **ist_table,
1521 enum CodecType type,
1525 for(z=0; z<nb_input_files; z++) {
1526 AVFormatContext *ic = input_files[z];
1527 for(p=0; p<ic->nb_programs; p++) {
1528 AVProgram *program = ic->programs[p];
1529 if(program->id != programid)
1531 for(q=0; q<program->nb_stream_indexes; q++) {
1532 int sidx = program->stream_index[q];
1533 int ris = file_table[z].ist_index + sidx;
1534 if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1544 * The following code is the main loop of the file converter
1546 static int av_encode(AVFormatContext **output_files,
1547 int nb_output_files,
1548 AVFormatContext **input_files,
1550 AVStreamMap *stream_maps, int nb_stream_maps)
1552 int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1553 AVFormatContext *is, *os;
1554 AVCodecContext *codec, *icodec;
1555 AVOutputStream *ost, **ost_table = NULL;
1556 AVInputStream *ist, **ist_table = NULL;
1557 AVInputFile *file_table;
1561 uint8_t no_packet[MAX_FILES]={0};
1562 int no_packet_count=0;
1564 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1568 /* input stream init */
1570 for(i=0;i<nb_input_files;i++) {
1571 is = input_files[i];
1572 file_table[i].ist_index = j;
1573 file_table[i].nb_streams = is->nb_streams;
1574 j += is->nb_streams;
1578 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1582 for(i=0;i<nb_istreams;i++) {
1583 ist = av_mallocz(sizeof(AVInputStream));
1589 for(i=0;i<nb_input_files;i++) {
1590 is = input_files[i];
1591 for(k=0;k<is->nb_streams;k++) {
1592 ist = ist_table[j++];
1593 ist->st = is->streams[k];
1594 ist->file_index = i;
1596 ist->discard = 1; /* the stream is discarded by default
1600 ist->start = av_gettime();
1605 /* output stream init */
1607 for(i=0;i<nb_output_files;i++) {
1608 os = output_files[i];
1609 if (!os->nb_streams) {
1610 dump_format(output_files[i], i, output_files[i]->filename, 1);
1611 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1614 nb_ostreams += os->nb_streams;
1616 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1617 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1621 /* Sanity check the mapping args -- do the input files & streams exist? */
1622 for(i=0;i<nb_stream_maps;i++) {
1623 int fi = stream_maps[i].file_index;
1624 int si = stream_maps[i].stream_index;
1626 if (fi < 0 || fi > nb_input_files - 1 ||
1627 si < 0 || si > file_table[fi].nb_streams - 1) {
1628 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1631 fi = stream_maps[i].sync_file_index;
1632 si = stream_maps[i].sync_stream_index;
1633 if (fi < 0 || fi > nb_input_files - 1 ||
1634 si < 0 || si > file_table[fi].nb_streams - 1) {
1635 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1640 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1643 for(i=0;i<nb_ostreams;i++) {
1644 ost = av_mallocz(sizeof(AVOutputStream));
1651 for(k=0;k<nb_output_files;k++) {
1652 os = output_files[k];
1653 for(i=0;i<os->nb_streams;i++,n++) {
1656 ost->file_index = k;
1658 ost->st = os->streams[i];
1659 if (nb_stream_maps > 0) {
1660 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1661 stream_maps[n].stream_index;
1663 /* Sanity check that the stream types match */
1664 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1665 int i= ost->file_index;
1666 dump_format(output_files[i], i, output_files[i]->filename, 1);
1667 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1668 stream_maps[n].file_index, stream_maps[n].stream_index,
1669 ost->file_index, ost->index);
1676 j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1678 ost->source_index = j;
1682 /* get corresponding input stream index : we select the first one with the right type */
1684 for(j=0;j<nb_istreams;j++) {
1687 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1688 ost->source_index = j;
1696 if(! opt_programid) {
1697 /* try again and reuse existing stream */
1698 for(j=0;j<nb_istreams;j++) {
1700 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1701 ost->source_index = j;
1707 int i= ost->file_index;
1708 dump_format(output_files[i], i, output_files[i]->filename, 1);
1709 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1710 ost->file_index, ost->index);
1715 ist = ist_table[ost->source_index];
1717 ost->sync_ist = (nb_stream_maps > 0) ?
1718 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
1719 stream_maps[n].sync_stream_index] : ist;
1723 /* for each output stream, we compute the right encoding parameters */
1724 for(i=0;i<nb_ostreams;i++) {
1725 AVMetadataTag *lang;
1727 os = output_files[ost->file_index];
1728 ist = ist_table[ost->source_index];
1730 codec = ost->st->codec;
1731 icodec = ist->st->codec;
1733 if ((lang=av_metadata_get(ist->st->metadata, "language", NULL, 0))
1734 && !av_metadata_get(ost->st->metadata, "language", NULL, 0))
1735 av_metadata_set(&ost->st->metadata, "language", lang->value);
1737 ost->st->disposition = ist->st->disposition;
1739 if (ost->st->stream_copy) {
1740 /* if stream_copy is selected, no need to decode or encode */
1741 codec->codec_id = icodec->codec_id;
1742 codec->codec_type = icodec->codec_type;
1744 if(!codec->codec_tag){
1745 if( !os->oformat->codec_tag
1746 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1747 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1748 codec->codec_tag = icodec->codec_tag;
1751 codec->bit_rate = icodec->bit_rate;
1752 codec->extradata= icodec->extradata;
1753 codec->extradata_size= icodec->extradata_size;
1754 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){
1755 codec->time_base = icodec->time_base;
1756 codec->time_base.num *= icodec->ticks_per_frame;
1758 codec->time_base = ist->st->time_base;
1759 switch(codec->codec_type) {
1760 case CODEC_TYPE_AUDIO:
1761 if(audio_volume != 256) {
1762 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1765 codec->channel_layout = icodec->channel_layout;
1766 codec->sample_rate = icodec->sample_rate;
1767 codec->channels = icodec->channels;
1768 codec->frame_size = icodec->frame_size;
1769 codec->block_align= icodec->block_align;
1770 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1771 codec->block_align= 0;
1772 if(codec->codec_id == CODEC_ID_AC3)
1773 codec->block_align= 0;
1775 case CODEC_TYPE_VIDEO:
1776 codec->pix_fmt = icodec->pix_fmt;
1777 codec->width = icodec->width;
1778 codec->height = icodec->height;
1779 codec->has_b_frames = icodec->has_b_frames;
1781 case CODEC_TYPE_SUBTITLE:
1782 codec->width = icodec->width;
1783 codec->height = icodec->height;
1789 switch(codec->codec_type) {
1790 case CODEC_TYPE_AUDIO:
1791 ost->fifo= av_fifo_alloc(1024);
1794 ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
1795 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1796 icodec->request_channels = codec->channels;
1797 ist->decoding_needed = 1;
1798 ost->encoding_needed = 1;
1800 case CODEC_TYPE_VIDEO:
1801 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1802 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1803 ost->video_resample = ((codec->width != icodec->width -
1804 (frame_leftBand + frame_rightBand) +
1805 (frame_padleft + frame_padright)) ||
1806 (codec->height != icodec->height -
1807 (frame_topBand + frame_bottomBand) +
1808 (frame_padtop + frame_padbottom)) ||
1809 (codec->pix_fmt != icodec->pix_fmt));
1810 if (ost->video_crop) {
1811 ost->topBand = frame_topBand;
1812 ost->leftBand = frame_leftBand;
1814 if (ost->video_pad) {
1815 ost->padtop = frame_padtop;
1816 ost->padleft = frame_padleft;
1817 ost->padbottom = frame_padbottom;
1818 ost->padright = frame_padright;
1819 if (!ost->video_resample) {
1820 avcodec_get_frame_defaults(&ost->pict_tmp);
1821 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1822 codec->width, codec->height))
1826 if (ost->video_resample) {
1827 avcodec_get_frame_defaults(&ost->pict_tmp);
1828 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1829 codec->width, codec->height)) {
1830 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1833 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1834 ost->img_resample_ctx = sws_getContext(
1835 icodec->width - (frame_leftBand + frame_rightBand),
1836 icodec->height - (frame_topBand + frame_bottomBand),
1838 codec->width - (frame_padleft + frame_padright),
1839 codec->height - (frame_padtop + frame_padbottom),
1841 sws_flags, NULL, NULL, NULL);
1842 if (ost->img_resample_ctx == NULL) {
1843 fprintf(stderr, "Cannot get resampling context\n");
1846 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1848 ost->encoding_needed = 1;
1849 ist->decoding_needed = 1;
1851 case CODEC_TYPE_SUBTITLE:
1852 ost->encoding_needed = 1;
1853 ist->decoding_needed = 1;
1860 if (ost->encoding_needed &&
1861 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1862 char logfilename[1024];
1867 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1868 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
1870 if (codec->flags & CODEC_FLAG_PASS1) {
1871 f = fopen(logfilename, "w");
1873 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
1878 /* read the log file */
1879 f = fopen(logfilename, "r");
1881 fprintf(stderr, "Cannot read log file '%s' for pass-2 encoding: %s\n", logfilename, strerror(errno));
1884 fseek(f, 0, SEEK_END);
1886 fseek(f, 0, SEEK_SET);
1887 logbuffer = av_malloc(size + 1);
1889 fprintf(stderr, "Could not allocate log buffer\n");
1892 size = fread(logbuffer, 1, size, f);
1894 logbuffer[size] = '\0';
1895 codec->stats_in = logbuffer;
1899 if(codec->codec_type == CODEC_TYPE_VIDEO){
1900 int size= codec->width * codec->height;
1901 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
1906 bit_buffer = av_malloc(bit_buffer_size);
1908 ret = AVERROR(ENOMEM);
1912 /* open each encoder */
1913 for(i=0;i<nb_ostreams;i++) {
1915 if (ost->encoding_needed) {
1916 AVCodec *codec = output_codecs[i];
1918 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1920 snprintf(error, sizeof(error), "Unsupported codec for output stream #%d.%d",
1921 ost->file_index, ost->index);
1922 ret = AVERROR(EINVAL);
1925 if (avcodec_open(ost->st->codec, codec) < 0) {
1926 snprintf(error, sizeof(error), "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
1927 ost->file_index, ost->index);
1928 ret = AVERROR(EINVAL);
1931 extra_size += ost->st->codec->extradata_size;
1935 /* open each decoder */
1936 for(i=0;i<nb_istreams;i++) {
1938 if (ist->decoding_needed) {
1939 AVCodec *codec = input_codecs[i];
1941 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1943 snprintf(error, sizeof(error), "Unsupported codec (id=%d) for input stream #%d.%d",
1944 ist->st->codec->codec_id, ist->file_index, ist->index);
1945 ret = AVERROR(EINVAL);
1948 if (avcodec_open(ist->st->codec, codec) < 0) {
1949 snprintf(error, sizeof(error), "Error while opening codec for input stream #%d.%d",
1950 ist->file_index, ist->index);
1951 ret = AVERROR(EINVAL);
1954 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1955 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1960 for(i=0;i<nb_istreams;i++) {
1962 is = input_files[ist->file_index];
1964 ist->next_pts = AV_NOPTS_VALUE;
1968 /* set meta data information from input file if required */
1969 for (i=0;i<nb_meta_data_maps;i++) {
1970 AVFormatContext *out_file;
1971 AVFormatContext *in_file;
1972 AVMetadataTag *mtag;
1974 int out_file_index = meta_data_maps[i].out_file;
1975 int in_file_index = meta_data_maps[i].in_file;
1976 if (out_file_index < 0 || out_file_index >= nb_output_files) {
1977 snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
1978 out_file_index, out_file_index, in_file_index);
1979 ret = AVERROR(EINVAL);
1982 if (in_file_index < 0 || in_file_index >= nb_input_files) {
1983 snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
1984 in_file_index, out_file_index, in_file_index);
1985 ret = AVERROR(EINVAL);
1989 out_file = output_files[out_file_index];
1990 in_file = input_files[in_file_index];
1994 while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
1995 av_metadata_set(&out_file->metadata, mtag->key, mtag->value);
1996 av_metadata_conv(out_file, out_file->oformat->metadata_conv,
1997 in_file->iformat->metadata_conv);
2000 /* open files and write file headers */
2001 for(i=0;i<nb_output_files;i++) {
2002 os = output_files[i];
2003 if (av_write_header(os) < 0) {
2004 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2005 ret = AVERROR(EINVAL);
2008 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2014 /* dump the file output parameters - cannot be done before in case
2016 for(i=0;i<nb_output_files;i++) {
2017 dump_format(output_files[i], i, output_files[i]->filename, 1);
2020 /* dump the stream mapping */
2022 fprintf(stderr, "Stream mapping:\n");
2023 for(i=0;i<nb_ostreams;i++) {
2025 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2026 ist_table[ost->source_index]->file_index,
2027 ist_table[ost->source_index]->index,
2030 if (ost->sync_ist != ist_table[ost->source_index])
2031 fprintf(stderr, " [sync #%d.%d]",
2032 ost->sync_ist->file_index,
2033 ost->sync_ist->index);
2034 fprintf(stderr, "\n");
2039 fprintf(stderr, "%s\n", error);
2044 print_sdp(output_files, nb_output_files);
2047 if (!using_stdin && verbose >= 0) {
2048 fprintf(stderr, "Press [q] to stop encoding\n");
2049 url_set_interrupt_cb(decode_interrupt_cb);
2054 timer_start = av_gettime();
2056 for(; received_sigterm == 0;) {
2057 int file_index, ist_index;
2065 /* if 'q' pressed, exits */
2069 /* read_key() returns 0 on EOF */
2075 /* select the stream that we must read now by looking at the
2076 smallest output pts */
2078 for(i=0;i<nb_ostreams;i++) {
2081 os = output_files[ost->file_index];
2082 ist = ist_table[ost->source_index];
2083 if(no_packet[ist->file_index])
2085 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2086 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2088 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2089 ipts = (double)ist->pts;
2090 if (!file_table[ist->file_index].eof_reached){
2091 if(ipts < ipts_min) {
2093 if(input_sync ) file_index = ist->file_index;
2095 if(opts < opts_min) {
2097 if(!input_sync) file_index = ist->file_index;
2100 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2105 /* if none, if is finished */
2106 if (file_index < 0) {
2107 if(no_packet_count){
2109 memset(no_packet, 0, sizeof(no_packet));
2116 /* finish if recording time exhausted */
2117 if (opts_min >= (recording_time / 1000000.0))
2120 /* finish if limit size exhausted */
2121 if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2124 /* read a frame from it and output it in the fifo */
2125 is = input_files[file_index];
2126 ret= av_read_frame(is, &pkt);
2127 if(ret == AVERROR(EAGAIN)){
2128 no_packet[file_index]=1;
2133 file_table[file_index].eof_reached = 1;
2141 memset(no_packet, 0, sizeof(no_packet));
2144 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2146 /* the following test is needed in case new streams appear
2147 dynamically in stream : we ignore them */
2148 if (pkt.stream_index >= file_table[file_index].nb_streams)
2149 goto discard_packet;
2150 ist_index = file_table[file_index].ist_index + pkt.stream_index;
2151 ist = ist_table[ist_index];
2153 goto discard_packet;
2155 if (pkt.dts != AV_NOPTS_VALUE)
2156 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2157 if (pkt.pts != AV_NOPTS_VALUE)
2158 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2160 if(input_files_ts_scale[file_index][pkt.stream_index]){
2161 if(pkt.pts != AV_NOPTS_VALUE)
2162 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2163 if(pkt.dts != AV_NOPTS_VALUE)
2164 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2167 // 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);
2168 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2169 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2170 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2171 int64_t delta= pkt_dts - ist->next_pts;
2172 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2173 input_files_ts_offset[ist->file_index]-= delta;
2175 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2176 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2177 if(pkt.pts != AV_NOPTS_VALUE)
2178 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2182 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2183 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2186 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2187 ist->file_index, ist->index);
2190 av_free_packet(&pkt);
2195 av_free_packet(&pkt);
2197 /* dump report by using the output first video and audio streams */
2198 print_report(output_files, ost_table, nb_ostreams, 0);
2201 /* at the end of stream, we must flush the decoder buffers */
2202 for(i=0;i<nb_istreams;i++) {
2204 if (ist->decoding_needed) {
2205 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2211 /* write the trailer if needed and close file */
2212 for(i=0;i<nb_output_files;i++) {
2213 os = output_files[i];
2214 av_write_trailer(os);
2217 /* dump report by using the first video and audio streams */
2218 print_report(output_files, ost_table, nb_ostreams, 1);
2220 /* close each encoder */
2221 for(i=0;i<nb_ostreams;i++) {
2223 if (ost->encoding_needed) {
2224 av_freep(&ost->st->codec->stats_in);
2225 avcodec_close(ost->st->codec);
2229 /* close each decoder */
2230 for(i=0;i<nb_istreams;i++) {
2232 if (ist->decoding_needed) {
2233 avcodec_close(ist->st->codec);
2241 av_freep(&bit_buffer);
2242 av_free(file_table);
2245 for(i=0;i<nb_istreams;i++) {
2252 for(i=0;i<nb_ostreams;i++) {
2256 fclose(ost->logfile);
2257 ost->logfile = NULL;
2259 av_fifo_free(ost->fifo); /* works even if fifo is not
2260 initialized but set to zero */
2261 av_free(ost->pict_tmp.data[0]);
2262 if (ost->video_resample)
2263 sws_freeContext(ost->img_resample_ctx);
2265 audio_resample_close(ost->resample);
2266 if (ost->reformat_ctx)
2267 av_audio_convert_free(ost->reformat_ctx);
2277 int file_read(const char *filename)
2280 unsigned char buffer[1024];
2283 if (url_open(&h, filename, O_RDONLY) < 0) {
2284 printf("could not open '%s'\n", filename);
2288 len = url_read(h, buffer, sizeof(buffer));
2291 for(i=0;i<len;i++) putchar(buffer[i]);
2298 static void opt_format(const char *arg)
2300 /* compatibility stuff for pgmyuv */
2301 if (!strcmp(arg, "pgmyuv")) {
2302 pgmyuv_compatibility_hack=1;
2303 // opt_image_format(arg);
2305 fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2308 file_iformat = av_find_input_format(arg);
2309 file_oformat = guess_format(arg, NULL, NULL);
2310 if (!file_iformat && !file_oformat) {
2311 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2316 static void opt_video_rc_override_string(const char *arg)
2318 video_rc_override_string = arg;
2321 static int opt_me_threshold(const char *opt, const char *arg)
2323 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2327 static void opt_loglevel(const char *opt, const char *arg)
2329 int level = parse_number_or_die(opt, arg, OPT_INT, INT_MIN, INT_MAX);
2330 av_log_set_level(level);
2333 static int opt_verbose(const char *opt, const char *arg)
2335 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2339 static int opt_frame_rate(const char *opt, const char *arg)
2341 if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2342 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2348 static int opt_bitrate(const char *opt, const char *arg)
2350 int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2352 opt_default(opt, arg);
2354 if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2355 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2360 static void opt_frame_crop_top(const char *arg)
2362 frame_topBand = atoi(arg);
2363 if (frame_topBand < 0) {
2364 fprintf(stderr, "Incorrect top crop size\n");
2367 if ((frame_topBand % 2) != 0) {
2368 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2371 if ((frame_topBand) >= frame_height){
2372 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2375 frame_height -= frame_topBand;
2378 static void opt_frame_crop_bottom(const char *arg)
2380 frame_bottomBand = atoi(arg);
2381 if (frame_bottomBand < 0) {
2382 fprintf(stderr, "Incorrect bottom crop size\n");
2385 if ((frame_bottomBand % 2) != 0) {
2386 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2389 if ((frame_bottomBand) >= frame_height){
2390 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2393 frame_height -= frame_bottomBand;
2396 static void opt_frame_crop_left(const char *arg)
2398 frame_leftBand = atoi(arg);
2399 if (frame_leftBand < 0) {
2400 fprintf(stderr, "Incorrect left crop size\n");
2403 if ((frame_leftBand % 2) != 0) {
2404 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2407 if ((frame_leftBand) >= frame_width){
2408 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2411 frame_width -= frame_leftBand;
2414 static void opt_frame_crop_right(const char *arg)
2416 frame_rightBand = atoi(arg);
2417 if (frame_rightBand < 0) {
2418 fprintf(stderr, "Incorrect right crop size\n");
2421 if ((frame_rightBand % 2) != 0) {
2422 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2425 if ((frame_rightBand) >= frame_width){
2426 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2429 frame_width -= frame_rightBand;
2432 static void opt_frame_size(const char *arg)
2434 if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2435 fprintf(stderr, "Incorrect frame size\n");
2438 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2439 fprintf(stderr, "Frame size must be a multiple of 2\n");
2445 #define SCALEBITS 10
2446 #define ONE_HALF (1 << (SCALEBITS - 1))
2447 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2449 #define RGB_TO_Y(r, g, b) \
2450 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2451 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2453 #define RGB_TO_U(r1, g1, b1, shift)\
2454 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2455 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2457 #define RGB_TO_V(r1, g1, b1, shift)\
2458 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2459 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2461 static void opt_pad_color(const char *arg) {
2462 /* Input is expected to be six hex digits similar to
2463 how colors are expressed in html tags (but without the #) */
2464 int rgb = strtol(arg, NULL, 16);
2468 g = ((rgb >> 8) & 255);
2471 padcolor[0] = RGB_TO_Y(r,g,b);
2472 padcolor[1] = RGB_TO_U(r,g,b,0);
2473 padcolor[2] = RGB_TO_V(r,g,b,0);
2476 static void opt_frame_pad_top(const char *arg)
2478 frame_padtop = atoi(arg);
2479 if (frame_padtop < 0) {
2480 fprintf(stderr, "Incorrect top pad size\n");
2483 if ((frame_padtop % 2) != 0) {
2484 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2489 static void opt_frame_pad_bottom(const char *arg)
2491 frame_padbottom = atoi(arg);
2492 if (frame_padbottom < 0) {
2493 fprintf(stderr, "Incorrect bottom pad size\n");
2496 if ((frame_padbottom % 2) != 0) {
2497 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2503 static void opt_frame_pad_left(const char *arg)
2505 frame_padleft = atoi(arg);
2506 if (frame_padleft < 0) {
2507 fprintf(stderr, "Incorrect left pad size\n");
2510 if ((frame_padleft % 2) != 0) {
2511 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2517 static void opt_frame_pad_right(const char *arg)
2519 frame_padright = atoi(arg);
2520 if (frame_padright < 0) {
2521 fprintf(stderr, "Incorrect right pad size\n");
2524 if ((frame_padright % 2) != 0) {
2525 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2530 static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2534 for (i=-1; i < nb_fmts; i++) {
2535 get_fmt_string (fmt_str, sizeof(fmt_str), i);
2536 fprintf(stdout, "%s\n", fmt_str);
2540 static void opt_frame_pix_fmt(const char *arg)
2542 if (strcmp(arg, "list")) {
2543 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2544 if (frame_pix_fmt == PIX_FMT_NONE) {
2545 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2549 list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2554 static void opt_frame_aspect_ratio(const char *arg)
2561 p = strchr(arg, ':');
2563 x = strtol(arg, &end, 10);
2565 y = strtol(end+1, &end, 10);
2567 ar = (double)x / (double)y;
2569 ar = strtod(arg, NULL);
2572 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2575 frame_aspect_ratio = ar;
2578 static int opt_metadata(const char *opt, const char *arg)
2580 char *mid= strchr(arg, '=');
2583 fprintf(stderr, "Missing =\n");
2589 metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2590 metadata[metadata_count-1].key = av_strdup(arg);
2591 metadata[metadata_count-1].value= av_strdup(mid);
2596 static void opt_qscale(const char *arg)
2598 video_qscale = atof(arg);
2599 if (video_qscale <= 0 ||
2600 video_qscale > 255) {
2601 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2606 static void opt_top_field_first(const char *arg)
2608 top_field_first= atoi(arg);
2611 static int opt_thread_count(const char *opt, const char *arg)
2613 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2616 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2621 static void opt_audio_sample_fmt(const char *arg)
2623 if (strcmp(arg, "list"))
2624 audio_sample_fmt = avcodec_get_sample_fmt(arg);
2626 list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2631 static int opt_audio_rate(const char *opt, const char *arg)
2633 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2637 static int opt_audio_channels(const char *opt, const char *arg)
2639 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2643 static void opt_video_channel(const char *arg)
2645 video_channel = strtol(arg, NULL, 0);
2648 static void opt_video_standard(const char *arg)
2650 video_standard = av_strdup(arg);
2653 static void opt_codec(int *pstream_copy, char **pcodec_name,
2654 int codec_type, const char *arg)
2656 av_freep(pcodec_name);
2657 if (!strcmp(arg, "copy")) {
2660 *pcodec_name = av_strdup(arg);
2664 static void opt_audio_codec(const char *arg)
2666 opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2669 static void opt_audio_tag(const char *arg)
2672 audio_codec_tag= strtol(arg, &tail, 0);
2675 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2678 static void opt_video_tag(const char *arg)
2681 video_codec_tag= strtol(arg, &tail, 0);
2684 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2687 static void opt_video_codec(const char *arg)
2689 opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2692 static void opt_subtitle_codec(const char *arg)
2694 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2697 static void opt_subtitle_tag(const char *arg)
2700 subtitle_codec_tag= strtol(arg, &tail, 0);
2703 subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2706 static void opt_map(const char *arg)
2711 m = &stream_maps[nb_stream_maps++];
2713 m->file_index = strtol(arg, &p, 0);
2717 m->stream_index = strtol(p, &p, 0);
2720 m->sync_file_index = strtol(p, &p, 0);
2723 m->sync_stream_index = strtol(p, &p, 0);
2725 m->sync_file_index = m->file_index;
2726 m->sync_stream_index = m->stream_index;
2730 static void opt_map_meta_data(const char *arg)
2735 m = &meta_data_maps[nb_meta_data_maps++];
2737 m->out_file = strtol(arg, &p, 0);
2741 m->in_file = strtol(p, &p, 0);
2744 static void opt_input_ts_scale(const char *arg)
2746 unsigned int stream;
2750 stream = strtol(arg, &p, 0);
2753 scale= strtod(p, &p);
2755 if(stream >= MAX_STREAMS)
2758 input_files_ts_scale[nb_input_files][stream]= scale;
2761 static int opt_recording_time(const char *opt, const char *arg)
2763 recording_time = parse_time_or_die(opt, arg, 1);
2767 static int opt_start_time(const char *opt, const char *arg)
2769 start_time = parse_time_or_die(opt, arg, 1);
2773 static int opt_rec_timestamp(const char *opt, const char *arg)
2775 rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2779 static int opt_input_ts_offset(const char *opt, const char *arg)
2781 input_ts_offset = parse_time_or_die(opt, arg, 1);
2785 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2787 const char *codec_string = encoder ? "encoder" : "decoder";
2791 return CODEC_ID_NONE;
2793 avcodec_find_encoder_by_name(name) :
2794 avcodec_find_decoder_by_name(name);
2796 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2799 if(codec->type != type) {
2800 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2806 static void opt_input_file(const char *filename)
2808 AVFormatContext *ic;
2809 AVFormatParameters params, *ap = ¶ms;
2810 int err, i, ret, rfps, rfps_base;
2813 if (!strcmp(filename, "-"))
2816 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2817 !strcmp(filename, "/dev/stdin");
2819 /* get default parameters from command line */
2820 ic = avformat_alloc_context();
2822 memset(ap, 0, sizeof(*ap));
2823 ap->prealloced_context = 1;
2824 ap->sample_rate = audio_sample_rate;
2825 ap->channels = audio_channels;
2826 ap->time_base.den = frame_rate.num;
2827 ap->time_base.num = frame_rate.den;
2828 ap->width = frame_width + frame_padleft + frame_padright;
2829 ap->height = frame_height + frame_padtop + frame_padbottom;
2830 ap->pix_fmt = frame_pix_fmt;
2831 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2832 ap->channel = video_channel;
2833 ap->standard = video_standard;
2834 ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2835 ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2836 if(pgmyuv_compatibility_hack)
2837 ap->video_codec_id= CODEC_ID_PGMYUV;
2839 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2841 ic->video_codec_id = find_codec_or_die(video_codec_name , CODEC_TYPE_VIDEO , 0);
2842 ic->audio_codec_id = find_codec_or_die(audio_codec_name , CODEC_TYPE_AUDIO , 0);
2843 ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2844 ic->flags |= AVFMT_FLAG_NONBLOCK;
2846 /* open the input file with generic libav function */
2847 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2849 print_error(filename, err);
2854 for(i=0; i<ic->nb_programs; i++)
2855 if(ic->programs[i]->id != opt_programid)
2856 ic->programs[i]->discard = AVDISCARD_ALL;
2859 ic->loop_input = loop_input;
2861 /* If not enough info to get the stream parameters, we decode the
2862 first frames to get it. (used in mpeg case for example) */
2863 ret = av_find_stream_info(ic);
2864 if (ret < 0 && verbose >= 0) {
2865 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2869 timestamp = start_time;
2870 /* add the stream start time */
2871 if (ic->start_time != AV_NOPTS_VALUE)
2872 timestamp += ic->start_time;
2874 /* if seeking requested, we execute it */
2875 if (start_time != 0) {
2876 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2878 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2879 filename, (double)timestamp / AV_TIME_BASE);
2881 /* reset seek info */
2885 /* update the current parameters so that they match the one of the input stream */
2886 for(i=0;i<ic->nb_streams;i++) {
2887 AVCodecContext *enc = ic->streams[i]->codec;
2889 avcodec_thread_init(enc, thread_count);
2890 enc->thread_count= thread_count;
2891 switch(enc->codec_type) {
2892 case CODEC_TYPE_AUDIO:
2893 set_context_opts(enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2894 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2895 channel_layout = enc->channel_layout;
2896 audio_channels = enc->channels;
2897 audio_sample_rate = enc->sample_rate;
2898 audio_sample_fmt = enc->sample_fmt;
2899 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
2901 ic->streams[i]->discard= AVDISCARD_ALL;
2903 case CODEC_TYPE_VIDEO:
2904 set_context_opts(enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2905 frame_height = enc->height;
2906 frame_width = enc->width;
2907 if(ic->streams[i]->sample_aspect_ratio.num)
2908 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
2910 frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
2911 frame_aspect_ratio *= (float) enc->width / enc->height;
2912 frame_pix_fmt = enc->pix_fmt;
2913 rfps = ic->streams[i]->r_frame_rate.num;
2914 rfps_base = ic->streams[i]->r_frame_rate.den;
2915 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2917 enc->debug |= FF_DEBUG_MV;
2919 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2922 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2923 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2925 (float)rfps / rfps_base, rfps, rfps_base);
2927 /* update the current frame rate to match the stream frame rate */
2928 frame_rate.num = rfps;
2929 frame_rate.den = rfps_base;
2931 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2933 ic->streams[i]->discard= AVDISCARD_ALL;
2934 else if(video_discard)
2935 ic->streams[i]->discard= video_discard;
2937 case CODEC_TYPE_DATA:
2939 case CODEC_TYPE_SUBTITLE:
2940 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
2941 if(subtitle_disable)
2942 ic->streams[i]->discard = AVDISCARD_ALL;
2944 case CODEC_TYPE_ATTACHMENT:
2945 case CODEC_TYPE_UNKNOWN:
2953 input_files[nb_input_files] = ic;
2954 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2955 /* dump the file content */
2957 dump_format(ic, nb_input_files, filename, 0);
2960 file_iformat = NULL;
2961 file_oformat = NULL;
2965 av_freep(&video_codec_name);
2966 av_freep(&audio_codec_name);
2967 av_freep(&subtitle_codec_name);
2970 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2971 int *has_subtitle_ptr)
2973 int has_video, has_audio, has_subtitle, i, j;
2974 AVFormatContext *ic;
2979 for(j=0;j<nb_input_files;j++) {
2980 ic = input_files[j];
2981 for(i=0;i<ic->nb_streams;i++) {
2982 AVCodecContext *enc = ic->streams[i]->codec;
2983 switch(enc->codec_type) {
2984 case CODEC_TYPE_AUDIO:
2987 case CODEC_TYPE_VIDEO:
2990 case CODEC_TYPE_SUBTITLE:
2993 case CODEC_TYPE_DATA:
2994 case CODEC_TYPE_ATTACHMENT:
2995 case CODEC_TYPE_UNKNOWN:
3002 *has_video_ptr = has_video;
3003 *has_audio_ptr = has_audio;
3004 *has_subtitle_ptr = has_subtitle;
3007 static void new_video_stream(AVFormatContext *oc)
3010 AVCodecContext *video_enc;
3013 st = av_new_stream(oc, oc->nb_streams);
3015 fprintf(stderr, "Could not alloc stream\n");
3018 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
3019 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3020 video_bitstream_filters= NULL;
3023 avcodec_thread_init(st->codec, thread_count);
3025 video_enc = st->codec;
3028 video_enc->codec_tag= video_codec_tag;
3030 if( (video_global_header&1)
3031 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3032 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3033 avcodec_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3035 if(video_global_header&2){
3036 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3037 avcodec_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3040 if (video_stream_copy) {
3041 st->stream_copy = 1;
3042 video_enc->codec_type = CODEC_TYPE_VIDEO;
3043 video_enc->sample_aspect_ratio =
3044 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3049 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3051 if (video_codec_name) {
3052 codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3053 codec = avcodec_find_encoder_by_name(video_codec_name);
3054 output_codecs[nb_ocodecs] = codec;
3056 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3057 codec = avcodec_find_encoder(codec_id);
3060 video_enc->codec_id = codec_id;
3062 set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3064 if (codec && codec->supported_framerates && !force_fps)
3065 fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3066 video_enc->time_base.den = fps.num;
3067 video_enc->time_base.num = fps.den;
3069 video_enc->width = frame_width + frame_padright + frame_padleft;
3070 video_enc->height = frame_height + frame_padtop + frame_padbottom;
3071 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3072 video_enc->pix_fmt = frame_pix_fmt;
3073 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3075 if(codec && codec->pix_fmts){
3076 const enum PixelFormat *p= codec->pix_fmts;
3078 if(*p == video_enc->pix_fmt)
3082 video_enc->pix_fmt = codec->pix_fmts[0];
3086 video_enc->gop_size = 0;
3087 if (video_qscale || same_quality) {
3088 video_enc->flags |= CODEC_FLAG_QSCALE;
3089 video_enc->global_quality=
3090 st->quality = FF_QP2LAMBDA * video_qscale;
3094 video_enc->intra_matrix = intra_matrix;
3096 video_enc->inter_matrix = inter_matrix;
3098 video_enc->thread_count = thread_count;
3099 p= video_rc_override_string;
3102 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3104 fprintf(stderr, "error parsing rc_override\n");
3107 video_enc->rc_override=
3108 av_realloc(video_enc->rc_override,
3109 sizeof(RcOverride)*(i+1));
3110 video_enc->rc_override[i].start_frame= start;
3111 video_enc->rc_override[i].end_frame = end;
3113 video_enc->rc_override[i].qscale= q;
3114 video_enc->rc_override[i].quality_factor= 1.0;
3117 video_enc->rc_override[i].qscale= 0;
3118 video_enc->rc_override[i].quality_factor= -q/100.0;
3123 video_enc->rc_override_count=i;
3124 if (!video_enc->rc_initial_buffer_occupancy)
3125 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3126 video_enc->me_threshold= me_threshold;
3127 video_enc->intra_dc_precision= intra_dc_precision - 8;
3130 video_enc->flags|= CODEC_FLAG_PSNR;
3135 video_enc->flags |= CODEC_FLAG_PASS1;
3137 video_enc->flags |= CODEC_FLAG_PASS2;
3143 /* reset some key parameters */
3145 av_freep(&video_codec_name);
3146 video_stream_copy = 0;
3149 static void new_audio_stream(AVFormatContext *oc)
3152 AVCodecContext *audio_enc;
3155 st = av_new_stream(oc, oc->nb_streams);
3157 fprintf(stderr, "Could not alloc stream\n");
3160 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3162 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3163 audio_bitstream_filters= NULL;
3166 avcodec_thread_init(st->codec, thread_count);
3168 audio_enc = st->codec;
3169 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3172 audio_enc->codec_tag= audio_codec_tag;
3174 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3175 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3176 avcodec_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3178 if (audio_stream_copy) {
3179 st->stream_copy = 1;
3180 audio_enc->channels = audio_channels;
3184 set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3186 if (audio_codec_name) {
3187 codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3188 codec = avcodec_find_encoder_by_name(audio_codec_name);
3189 output_codecs[nb_ocodecs] = codec;
3191 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3192 codec = avcodec_find_encoder(codec_id);
3194 audio_enc->codec_id = codec_id;
3196 if (audio_qscale > QSCALE_NONE) {
3197 audio_enc->flags |= CODEC_FLAG_QSCALE;
3198 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3200 audio_enc->thread_count = thread_count;
3201 audio_enc->channels = audio_channels;
3202 audio_enc->sample_fmt = audio_sample_fmt;
3203 audio_enc->channel_layout = channel_layout;
3205 if(codec && codec->sample_fmts){
3206 const enum SampleFormat *p= codec->sample_fmts;
3208 if(*p == audio_enc->sample_fmt)
3212 audio_enc->sample_fmt = codec->sample_fmts[0];
3216 audio_enc->sample_rate = audio_sample_rate;
3217 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3218 if (audio_language) {
3219 av_metadata_set(&st->metadata, "language", audio_language);
3220 av_free(audio_language);
3221 audio_language = NULL;
3224 /* reset some key parameters */
3226 av_freep(&audio_codec_name);
3227 audio_stream_copy = 0;
3230 static void new_subtitle_stream(AVFormatContext *oc)
3233 AVCodecContext *subtitle_enc;
3235 st = av_new_stream(oc, oc->nb_streams);
3237 fprintf(stderr, "Could not alloc stream\n");
3240 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3242 bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3243 subtitle_bitstream_filters= NULL;
3245 subtitle_enc = st->codec;
3246 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3248 if(subtitle_codec_tag)
3249 subtitle_enc->codec_tag= subtitle_codec_tag;
3251 if (subtitle_stream_copy) {
3252 st->stream_copy = 1;
3254 set_context_opts(avcodec_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3255 subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3256 output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3260 if (subtitle_language) {
3261 av_metadata_set(&st->metadata, "language", subtitle_language);
3262 av_free(subtitle_language);
3263 subtitle_language = NULL;
3266 subtitle_disable = 0;
3267 av_freep(&subtitle_codec_name);
3268 subtitle_stream_copy = 0;
3271 static void opt_new_audio_stream(void)
3273 AVFormatContext *oc;
3274 if (nb_output_files <= 0) {
3275 fprintf(stderr, "At least one output file must be specified\n");
3278 oc = output_files[nb_output_files - 1];
3279 new_audio_stream(oc);
3282 static void opt_new_video_stream(void)
3284 AVFormatContext *oc;
3285 if (nb_output_files <= 0) {
3286 fprintf(stderr, "At least one output file must be specified\n");
3289 oc = output_files[nb_output_files - 1];
3290 new_video_stream(oc);
3293 static void opt_new_subtitle_stream(void)
3295 AVFormatContext *oc;
3296 if (nb_output_files <= 0) {
3297 fprintf(stderr, "At least one output file must be specified\n");
3300 oc = output_files[nb_output_files - 1];
3301 new_subtitle_stream(oc);
3304 static void opt_output_file(const char *filename)
3306 AVFormatContext *oc;
3307 int use_video, use_audio, use_subtitle;
3308 int input_has_video, input_has_audio, input_has_subtitle;
3309 AVFormatParameters params, *ap = ¶ms;
3311 if (!strcmp(filename, "-"))
3314 oc = avformat_alloc_context();
3316 if (!file_oformat) {
3317 file_oformat = guess_format(NULL, filename, NULL);
3318 if (!file_oformat) {
3319 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3325 oc->oformat = file_oformat;
3326 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3328 if (!strcmp(file_oformat->name, "ffm") &&
3329 av_strstart(filename, "http:", NULL)) {
3330 /* special case for files sent to ffserver: we get the stream
3331 parameters from ffserver */
3332 int err = read_ffserver_streams(oc, filename);
3334 print_error(filename, err);
3338 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3339 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3340 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3342 /* disable if no corresponding type found and at least one
3344 if (nb_input_files > 0) {
3345 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3346 &input_has_subtitle);
3347 if (!input_has_video)
3349 if (!input_has_audio)
3351 if (!input_has_subtitle)
3355 /* manual disable */
3356 if (audio_disable) {
3359 if (video_disable) {
3362 if (subtitle_disable) {
3367 new_video_stream(oc);
3371 new_audio_stream(oc);
3375 new_subtitle_stream(oc);
3378 oc->timestamp = rec_timestamp;
3380 for(; metadata_count>0; metadata_count--){
3381 av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3382 metadata[metadata_count-1].value);
3384 av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3387 output_files[nb_output_files++] = oc;
3389 /* check filename in case of an image number is expected */
3390 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3391 if (!av_filename_number_test(oc->filename)) {
3392 print_error(oc->filename, AVERROR_NUMEXPECTED);
3397 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3398 /* test if it already exists to avoid loosing precious files */
3399 if (!file_overwrite &&
3400 (strchr(filename, ':') == NULL ||
3401 filename[1] == ':' ||
3402 av_strstart(filename, "file:", NULL))) {
3403 if (url_exist(filename)) {
3405 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3407 if (!read_yesno()) {
3408 fprintf(stderr, "Not overwriting - exiting\n");
3413 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3420 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3421 fprintf(stderr, "Could not open '%s'\n", filename);
3426 memset(ap, 0, sizeof(*ap));
3427 if (av_set_parameters(oc, ap) < 0) {
3428 fprintf(stderr, "%s: Invalid encoding parameters\n",
3433 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3434 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3435 oc->loop_output = loop_output;
3436 oc->flags |= AVFMT_FLAG_NONBLOCK;
3438 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3440 /* reset some options */
3441 file_oformat = NULL;
3442 file_iformat = NULL;
3445 /* same option as mencoder */
3446 static void opt_pass(const char *pass_str)
3449 pass = atoi(pass_str);
3450 if (pass != 1 && pass != 2) {
3451 fprintf(stderr, "pass number can be only 1 or 2\n");
3457 static int64_t getutime(void)
3460 struct rusage rusage;
3462 getrusage(RUSAGE_SELF, &rusage);
3463 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3464 #elif HAVE_GETPROCESSTIMES
3466 FILETIME c, e, k, u;
3467 proc = GetCurrentProcess();
3468 GetProcessTimes(proc, &c, &e, &k, &u);
3469 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3471 return av_gettime();
3475 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3478 const char *p = str;
3485 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3492 static void opt_inter_matrix(const char *arg)
3494 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3495 parse_matrix_coeffs(inter_matrix, arg);
3498 static void opt_intra_matrix(const char *arg)
3500 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3501 parse_matrix_coeffs(intra_matrix, arg);
3505 * Trivial log callback.
3506 * Only suitable for show_help and similar since it lacks prefix handling.
3508 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3510 vfprintf(stdout, fmt, vl);
3513 static void show_help(void)
3515 av_log_set_callback(log_callback_help);
3516 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3517 "Hyper fast Audio and Video encoder\n");
3519 show_help_options(options, "Main options:\n",
3520 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3521 show_help_options(options, "\nAdvanced options:\n",
3522 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3524 show_help_options(options, "\nVideo options:\n",
3525 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3527 show_help_options(options, "\nAdvanced Video options:\n",
3528 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3529 OPT_VIDEO | OPT_EXPERT);
3530 show_help_options(options, "\nAudio options:\n",
3531 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3533 show_help_options(options, "\nAdvanced Audio options:\n",
3534 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3535 OPT_AUDIO | OPT_EXPERT);
3536 show_help_options(options, "\nSubtitle options:\n",
3537 OPT_SUBTITLE | OPT_GRAB,
3539 show_help_options(options, "\nAudio/Video grab options:\n",
3543 av_opt_show(avcodec_opts[0], NULL);
3545 av_opt_show(avformat_opts, NULL);
3547 av_opt_show(sws_opts, NULL);
3550 static void opt_target(const char *arg)
3553 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3555 if(!strncmp(arg, "pal-", 4)) {
3558 } else if(!strncmp(arg, "ntsc-", 5)) {
3561 } else if(!strncmp(arg, "film-", 5)) {
3566 /* Calculate FR via float to avoid int overflow */
3567 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3570 } else if((fr == 29970) || (fr == 23976)) {
3573 /* Try to determine PAL/NTSC by peeking in the input files */
3574 if(nb_input_files) {
3576 for(j = 0; j < nb_input_files; j++) {
3577 for(i = 0; i < input_files[j]->nb_streams; i++) {
3578 AVCodecContext *c = input_files[j]->streams[i]->codec;
3579 if(c->codec_type != CODEC_TYPE_VIDEO)
3581 fr = c->time_base.den * 1000 / c->time_base.num;
3585 } else if((fr == 29970) || (fr == 23976)) {
3595 if(verbose && norm >= 0)
3596 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3600 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3601 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3602 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3606 if(!strcmp(arg, "vcd")) {
3608 opt_video_codec("mpeg1video");
3609 opt_audio_codec("mp2");
3612 opt_frame_size(norm ? "352x240" : "352x288");
3613 opt_frame_rate(NULL, frame_rates[norm]);
3614 opt_default("gop", norm ? "18" : "15");
3616 opt_default("b", "1150000");
3617 opt_default("maxrate", "1150000");
3618 opt_default("minrate", "1150000");
3619 opt_default("bufsize", "327680"); // 40*1024*8;
3621 opt_default("ab", "224000");
3622 audio_sample_rate = 44100;
3625 opt_default("packetsize", "2324");
3626 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3628 /* We have to offset the PTS, so that it is consistent with the SCR.
3629 SCR starts at 36000, but the first two packs contain only padding
3630 and the first pack from the other stream, respectively, may also have
3631 been written before.
3632 So the real data starts at SCR 36000+3*1200. */
3633 mux_preload= (36000+3*1200) / 90000.0; //0.44
3634 } else if(!strcmp(arg, "svcd")) {
3636 opt_video_codec("mpeg2video");
3637 opt_audio_codec("mp2");
3640 opt_frame_size(norm ? "480x480" : "480x576");
3641 opt_frame_rate(NULL, frame_rates[norm]);
3642 opt_default("gop", norm ? "18" : "15");
3644 opt_default("b", "2040000");
3645 opt_default("maxrate", "2516000");
3646 opt_default("minrate", "0"); //1145000;
3647 opt_default("bufsize", "1835008"); //224*1024*8;
3648 opt_default("flags", "+scan_offset");
3651 opt_default("ab", "224000");
3652 audio_sample_rate = 44100;
3654 opt_default("packetsize", "2324");
3656 } else if(!strcmp(arg, "dvd")) {
3658 opt_video_codec("mpeg2video");
3659 opt_audio_codec("ac3");
3662 opt_frame_size(norm ? "720x480" : "720x576");
3663 opt_frame_rate(NULL, frame_rates[norm]);
3664 opt_default("gop", norm ? "18" : "15");
3666 opt_default("b", "6000000");
3667 opt_default("maxrate", "9000000");
3668 opt_default("minrate", "0"); //1500000;
3669 opt_default("bufsize", "1835008"); //224*1024*8;
3671 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3672 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3674 opt_default("ab", "448000");
3675 audio_sample_rate = 48000;
3677 } else if(!strncmp(arg, "dv", 2)) {
3681 opt_frame_size(norm ? "720x480" : "720x576");
3682 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3683 (norm ? "yuv411p" : "yuv420p"));
3684 opt_frame_rate(NULL, frame_rates[norm]);
3686 audio_sample_rate = 48000;
3690 fprintf(stderr, "Unknown target: %s\n", arg);
3695 static void opt_vstats_file (const char *arg)
3697 av_free (vstats_filename);
3698 vstats_filename=av_strdup (arg);
3701 static void opt_vstats (void)
3704 time_t today2 = time(NULL);
3705 struct tm *today = localtime(&today2);
3707 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3709 opt_vstats_file(filename);
3712 static int opt_bsf(const char *opt, const char *arg)
3714 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3715 AVBitStreamFilterContext **bsfp;
3718 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3722 bsfp= *opt == 'v' ? &video_bitstream_filters :
3723 *opt == 'a' ? &audio_bitstream_filters :
3724 &subtitle_bitstream_filters;
3726 bsfp= &(*bsfp)->next;
3733 static int opt_preset(const char *opt, const char *arg)
3736 char filename[1000], tmp[1000], tmp2[1000], line[1000];
3738 const char *base[2]= { getenv("HOME"),
3742 for(i=!base[0]; i<2 && !f; i++){
3743 snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
3744 f= fopen(filename, "r");
3746 char *codec_name= *opt == 'v' ? video_codec_name :
3747 *opt == 'a' ? audio_codec_name :
3748 subtitle_codec_name;
3749 snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i], i ? "" : "/.ffmpeg", codec_name, arg);
3750 f= fopen(filename, "r");
3753 if(!f && ((arg[0]=='.' && arg[1]=='/') || arg[0]=='/' ||
3755 av_strlcpy(filename, arg, sizeof(filename));
3756 f= fopen(filename, "r");
3760 fprintf(stderr, "File for preset '%s' not found\n", arg);
3765 int e= fscanf(f, "%999[^\n]\n", line) - 1;
3766 if(line[0] == '#' && !e)
3768 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3770 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3773 if(!strcmp(tmp, "acodec")){
3774 opt_audio_codec(tmp2);
3775 }else if(!strcmp(tmp, "vcodec")){
3776 opt_video_codec(tmp2);
3777 }else if(!strcmp(tmp, "scodec")){
3778 opt_subtitle_codec(tmp2);
3779 }else if(opt_default(tmp, tmp2) < 0){
3780 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3790 static const OptionDef options[] = {
3792 { "L", OPT_EXIT, {(void*)show_license}, "show license" },
3793 { "h", OPT_EXIT, {(void*)show_help}, "show help" },
3794 { "version", OPT_EXIT, {(void*)show_version}, "show version" },
3795 { "formats", OPT_EXIT, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3796 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3797 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3798 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3799 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3800 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3801 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3802 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3803 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3804 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3805 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
3806 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp ('now' to set the current time)", "time" },
3807 { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)&opt_metadata}, "add metadata", "string=string" },
3808 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3809 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3810 "add timings for benchmarking" },
3811 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3812 "dump each input packet" },
3813 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3814 "when dumping packets, also dump the payload" },
3815 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3816 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3817 { "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)", "" },
3818 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
3819 { "loglevel", HAS_ARG | OPT_FUNC2, {(void*)opt_loglevel}, "set libav* logging level", "number" },
3820 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3821 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3822 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3823 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3824 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3825 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3826 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3827 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3828 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3829 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3830 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
3831 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
3834 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3835 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3836 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3837 { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3838 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3839 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3840 { "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" },
3841 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3842 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3843 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3844 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3845 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3846 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3847 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3848 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3849 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3850 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3851 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3852 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3853 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3854 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3855 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3856 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
3857 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3858 "use same video quality as source (implies VBR)" },
3859 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3860 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
3861 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3862 "deinterlace pictures" },
3863 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3864 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3865 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3866 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3867 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3868 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3869 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3870 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3871 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3872 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3873 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
3876 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3877 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3878 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3879 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3880 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3881 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3882 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3883 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3884 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3885 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3886 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3887 { "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" },
3889 /* subtitle options */
3890 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3891 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3892 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3893 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3894 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
3897 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3898 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3899 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3902 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3903 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3905 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3906 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3907 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3909 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3910 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3911 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3913 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3917 int main(int argc, char **argv)
3922 avcodec_register_all();
3923 avdevice_register_all();
3926 if(isatty(STDIN_FILENO))
3927 url_set_interrupt_cb(decode_interrupt_cb);
3929 for(i=0; i<CODEC_TYPE_NB; i++){
3930 avcodec_opts[i]= avcodec_alloc_context2(i);
3932 avformat_opts = avformat_alloc_context();
3933 sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3938 parse_options(argc, argv, options, opt_output_file);
3940 /* file converter / grab */
3941 if (nb_output_files <= 0) {
3942 fprintf(stderr, "At least one output file must be specified\n");
3946 if (nb_input_files == 0) {
3947 fprintf(stderr, "At least one input file must be specified\n");
3952 if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
3953 stream_maps, nb_stream_maps) < 0)
3955 ti = getutime() - ti;
3957 printf("bench: utime=%0.3fs\n", ti / 1000000.0);