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 "libavformat/framehook.h"
38 #include "libavcodec/opt.h"
39 #include "libavcodec/audioconvert.h"
40 #include "libavutil/fifo.h"
41 #include "libavutil/avstring.h"
42 #include "libavformat/os_support.h"
44 #ifdef HAVE_SYS_RESOURCE_H
45 #include <sys/types.h>
46 #include <sys/resource.h>
47 #elif defined(HAVE_GETPROCESSTIMES)
51 #ifdef HAVE_SYS_SELECT_H
52 #include <sys/select.h>
57 #include <sys/ioctl.h>
60 #elif defined(HAVE_CONIO_H)
63 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
73 const char program_name[] = "FFmpeg";
74 const int program_birth_year = 2000;
76 /* select an input stream for an output stream */
77 typedef struct AVStreamMap {
81 int sync_stream_index;
84 /** select an input file for an output file */
85 typedef struct AVMetaDataMap {
90 static const OptionDef options[];
94 static AVFormatContext *input_files[MAX_FILES];
95 static int64_t input_files_ts_offset[MAX_FILES];
96 static double input_files_ts_scale[MAX_FILES][MAX_STREAMS];
97 static AVCodec *input_codecs[MAX_FILES*MAX_STREAMS];
98 static int nb_input_files = 0;
99 static int nb_icodecs;
101 static AVFormatContext *output_files[MAX_FILES];
102 static AVCodec *output_codecs[MAX_FILES*MAX_STREAMS];
103 static int nb_output_files = 0;
104 static int nb_ocodecs;
106 static AVStreamMap stream_maps[MAX_FILES*MAX_STREAMS];
107 static int nb_stream_maps;
109 static AVMetaDataMap meta_data_maps[MAX_FILES];
110 static int nb_meta_data_maps;
112 static AVInputFormat *file_iformat;
113 static AVOutputFormat *file_oformat;
114 static int frame_width = 0;
115 static int frame_height = 0;
116 static float frame_aspect_ratio = 0;
117 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
118 static enum SampleFormat audio_sample_fmt = SAMPLE_FMT_NONE;
119 static int frame_padtop = 0;
120 static int frame_padbottom = 0;
121 static int frame_padleft = 0;
122 static int frame_padright = 0;
123 static int padcolor[3] = {16,128,128}; /* default to black */
124 static int frame_topBand = 0;
125 static int frame_bottomBand = 0;
126 static int frame_leftBand = 0;
127 static int frame_rightBand = 0;
128 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
129 static AVRational frame_rate;
130 static float video_qscale = 0;
131 static uint16_t *intra_matrix = NULL;
132 static uint16_t *inter_matrix = NULL;
133 #if 0 //experimental, (can be removed)
134 static float video_rc_qsquish=1.0;
135 static float video_rc_qmod_amp=0;
136 static int video_rc_qmod_freq=0;
138 static const char *video_rc_override_string=NULL;
139 static int video_disable = 0;
140 static int video_discard = 0;
141 static char *video_codec_name = NULL;
142 static int video_codec_tag = 0;
143 static int same_quality = 0;
144 static int do_deinterlace = 0;
145 static int top_field_first = -1;
146 static int me_threshold = 0;
147 static int intra_dc_precision = 8;
148 static int loop_input = 0;
149 static int loop_output = AVFMT_NOOUTPUTLOOP;
150 static int qp_hist = 0;
152 static int intra_only = 0;
153 static int audio_sample_rate = 44100;
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;
166 static float mux_preload= 0.5;
167 static float mux_max_delay= 0.7;
169 static int64_t recording_time = INT64_MAX;
170 static int64_t start_time = 0;
171 static int64_t rec_timestamp = 0;
172 static int64_t input_ts_offset = 0;
173 static int file_overwrite = 0;
174 static char *str_title = NULL;
175 static char *str_author = NULL;
176 static char *str_copyright = NULL;
177 static char *str_comment = NULL;
178 static char *str_genre = NULL;
179 static char *str_album = NULL;
180 static int do_benchmark = 0;
181 static int do_hex_dump = 0;
182 static int do_pkt_dump = 0;
183 static int do_psnr = 0;
184 static int do_pass = 0;
185 static char *pass_logfilename = NULL;
186 static int audio_stream_copy = 0;
187 static int video_stream_copy = 0;
188 static int subtitle_stream_copy = 0;
189 static int video_sync_method= -1;
190 static int audio_sync_method= 0;
191 static float audio_drift_threshold= 0.1;
192 static int copy_ts= 0;
193 static int opt_shortest = 0; //
194 static int video_global_header = 0;
195 static char *vstats_filename;
196 static FILE *vstats_file;
197 static int opt_programid = 0;
199 static int rate_emu = 0;
201 static int video_channel = 0;
202 static char *video_standard;
204 static int audio_volume = 256;
206 static int exit_on_error = 0;
207 static int using_stdin = 0;
208 static int using_vhook = 0;
209 static int verbose = 1;
210 static int thread_count= 1;
211 static int q_pressed = 0;
212 static int64_t video_size = 0;
213 static int64_t audio_size = 0;
214 static int64_t extra_size = 0;
215 static int nb_frames_dup = 0;
216 static int nb_frames_drop = 0;
217 static int input_sync;
218 static uint64_t limit_filesize = 0; //
219 static int force_fps = 0;
221 static int pgmyuv_compatibility_hack=0;
222 static float dts_delta_threshold = 10;
224 static unsigned int sws_flags = SWS_BICUBIC;
226 static int64_t timer_start;
228 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
229 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
230 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
231 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
233 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
235 struct AVInputStream;
237 typedef struct AVOutputStream {
238 int file_index; /* file index */
239 int index; /* stream index in the output file */
240 int source_index; /* AVInputStream index */
241 AVStream *st; /* stream in the output file */
242 int encoding_needed; /* true if encoding needed for this stream */
244 /* input pts and corresponding output pts
246 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
247 struct AVInputStream *sync_ist; /* input stream to sync against */
248 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
251 AVFrame pict_tmp; /* temporary image for resampling */
252 struct SwsContext *img_resample_ctx; /* for image resampling */
256 int topBand; /* cropping area sizes */
260 int padtop; /* padding area sizes */
267 ReSampleContext *resample; /* for audio resampling */
269 AVAudioConvert *reformat_ctx;
270 AVFifoBuffer fifo; /* for compression: one audio fifo per codec */
274 typedef struct AVInputStream {
278 int discard; /* true if stream data should be discarded */
279 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
280 int64_t sample_index; /* current sample */
282 int64_t start; /* time when read started */
283 unsigned long frame; /* current frame */
284 int64_t next_pts; /* synthetic pts for cases where pkt.pts
286 int64_t pts; /* current pts */
287 int is_start; /* is 1 at the start and after a discontinuity */
290 typedef struct AVInputFile {
291 int eof_reached; /* true if eof reached */
292 int ist_index; /* index of first stream in ist_table */
293 int buffer_size; /* current total buffer size */
294 int nb_streams; /* nb streams we are aware of */
297 #ifdef HAVE_TERMIOS_H
299 /* init terminal so that we can grab keys */
300 static struct termios oldtty;
303 static void term_exit(void)
305 #ifdef HAVE_TERMIOS_H
306 tcsetattr (0, TCSANOW, &oldtty);
310 static volatile sig_atomic_t received_sigterm = 0;
313 sigterm_handler(int sig)
315 received_sigterm = sig;
319 static void term_init(void)
321 #ifdef HAVE_TERMIOS_H
327 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
328 |INLCR|IGNCR|ICRNL|IXON);
329 tty.c_oflag |= OPOST;
330 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
331 tty.c_cflag &= ~(CSIZE|PARENB);
336 tcsetattr (0, TCSANOW, &tty);
337 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
340 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
341 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
343 register a function to be called at normal program termination
346 #ifdef CONFIG_BEOS_NETSERVER
347 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
351 /* read a key without blocking */
352 static int read_key(void)
354 #if defined(HAVE_TERMIOS_H)
357 #ifndef CONFIG_BEOS_NETSERVER
365 n = select(1, &rfds, NULL, NULL, &tv);
374 #elif defined(HAVE_CONIO_H)
381 static int decode_interrupt_cb(void)
383 return q_pressed || (q_pressed = read_key() == 'q');
386 static int av_exit(int ret)
391 for(i=0;i<nb_output_files;i++) {
392 /* maybe av_close_output_file ??? */
393 AVFormatContext *s = output_files[i];
395 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
397 for(j=0;j<s->nb_streams;j++) {
398 av_free(s->streams[j]->codec);
399 av_free(s->streams[j]);
403 for(i=0;i<nb_input_files;i++)
404 av_close_input_file(input_files[i]);
406 av_free(intra_matrix);
407 av_free(inter_matrix);
411 av_free(vstats_filename);
415 av_free(video_codec_name);
416 av_free(audio_codec_name);
417 av_free(subtitle_codec_name);
419 av_free(video_standard);
421 #ifdef CONFIG_POWERPC_PERF
422 extern void powerpc_display_perf_report(void);
423 powerpc_display_perf_report();
424 #endif /* CONFIG_POWERPC_PERF */
426 if (received_sigterm) {
428 "Received signal %d: terminating.\n",
429 (int) received_sigterm);
433 exit(ret); /* not all OS-es handle main() return value */
437 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
443 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
446 /* copy stream format */
447 s->nb_streams = ic->nb_streams;
448 for(i=0;i<ic->nb_streams;i++) {
451 // FIXME: a more elegant solution is needed
452 st = av_mallocz(sizeof(AVStream));
453 memcpy(st, ic->streams[i], sizeof(AVStream));
454 st->codec = avcodec_alloc_context();
455 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
458 if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
460 else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
463 if(!st->codec->thread_count)
464 st->codec->thread_count = 1;
465 if(st->codec->thread_count>1)
466 avcodec_thread_init(st->codec, st->codec->thread_count);
468 if(st->codec->flags & CODEC_FLAG_BITEXACT)
473 s->timestamp = av_gettime();
475 av_close_input_file(ic);
480 get_sync_ipts(const AVOutputStream *ost)
482 const AVInputStream *ist = ost->sync_ist;
483 return (double)(ist->pts - start_time)/AV_TIME_BASE;
486 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
490 AVPacket new_pkt= *pkt;
491 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
492 &new_pkt.data, &new_pkt.size,
493 pkt->data, pkt->size,
494 pkt->flags & PKT_FLAG_KEY);
497 new_pkt.destruct= av_destruct_packet;
499 fprintf(stderr, "%s failed for stream %d, codec %s",
500 bsfc->filter->name, pkt->stream_index,
501 avctx->codec ? avctx->codec->name : "copy");
511 ret= av_interleaved_write_frame(s, pkt);
513 print_error("av_interleaved_write_frame()", ret);
518 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
520 static void do_audio_out(AVFormatContext *s,
523 unsigned char *buf, int size)
526 static uint8_t *audio_buf = NULL;
527 static uint8_t *audio_out = NULL;
528 static uint8_t *audio_out2 = NULL;
529 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
531 int size_out, frame_bytes, ret;
532 AVCodecContext *enc= ost->st->codec;
533 AVCodecContext *dec= ist->st->codec;
534 int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
535 int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
537 /* SC: dynamic allocation of buffers */
539 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
541 audio_out = av_malloc(audio_out_size);
542 if (!audio_buf || !audio_out)
543 return; /* Should signal an error ! */
545 if (enc->channels != dec->channels)
546 ost->audio_resample = 1;
548 if (ost->audio_resample && !ost->resample) {
549 if (dec->sample_fmt != SAMPLE_FMT_S16) {
550 fprintf(stderr, "Audio resampler only works with 16 bits per sample, patch welcome.\n");
553 ost->resample = audio_resample_init(enc->channels, dec->channels,
554 enc->sample_rate, dec->sample_rate);
555 if (!ost->resample) {
556 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
557 dec->channels, dec->sample_rate,
558 enc->channels, enc->sample_rate);
563 #define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
564 if (dec->sample_fmt!=enc->sample_fmt &&
565 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
567 audio_out2 = av_malloc(audio_out_size);
570 if (ost->reformat_ctx)
571 av_audio_convert_free(ost->reformat_ctx);
572 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
573 dec->sample_fmt, 1, NULL, 0);
574 if (!ost->reformat_ctx) {
575 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
576 avcodec_get_sample_fmt_name(dec->sample_fmt),
577 avcodec_get_sample_fmt_name(enc->sample_fmt));
580 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
583 if(audio_sync_method){
584 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
585 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
586 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
587 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
589 //FIXME resample delay
590 if(fabs(delta) > 50){
591 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
593 byte_delta= FFMAX(byte_delta, -size);
597 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
602 static uint8_t *input_tmp= NULL;
603 input_tmp= av_realloc(input_tmp, byte_delta + size);
605 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
608 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
610 memset(input_tmp, 0, byte_delta);
611 memcpy(input_tmp + byte_delta, buf, size);
615 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
617 }else if(audio_sync_method>1){
618 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
619 assert(ost->audio_resample);
621 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
622 // 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));
623 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
627 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
628 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
630 if (ost->audio_resample) {
632 size_out = audio_resample(ost->resample,
633 (short *)buftmp, (short *)buf,
634 size / (ist->st->codec->channels * isize));
635 size_out = size_out * enc->channels * osize;
641 if (dec->sample_fmt!=enc->sample_fmt) {
642 const void *ibuf[6]= {buftmp};
643 void *obuf[6]= {audio_out2};
644 int istride[6]= {isize};
645 int ostride[6]= {osize};
646 int len= size_out/istride[0];
647 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
648 printf("av_audio_convert() failed\n");
654 size_out = len*osize;
657 /* now encode as many frames as possible */
658 if (enc->frame_size > 1) {
659 /* output resampled raw samples */
660 if (av_fifo_realloc2(&ost->fifo, av_fifo_size(&ost->fifo) + size_out) < 0) {
661 fprintf(stderr, "av_fifo_realloc2() failed\n");
664 av_fifo_generic_write(&ost->fifo, buftmp, size_out, NULL);
666 frame_bytes = enc->frame_size * osize * enc->channels;
668 while (av_fifo_size(&ost->fifo) >= frame_bytes) {
670 av_init_packet(&pkt);
672 av_fifo_read(&ost->fifo, audio_buf, frame_bytes);
674 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
676 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
679 pkt.stream_index= ost->index;
682 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
683 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
684 pkt.flags |= PKT_FLAG_KEY;
685 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
687 ost->sync_opts += enc->frame_size;
691 int coded_bps = av_get_bits_per_sample(enc->codec->id)/8;
692 av_init_packet(&pkt);
694 ost->sync_opts += size_out / (osize * enc->channels);
696 /* output a pcm frame */
697 /* determine the size of the coded buffer */
700 size_out *= coded_bps;
702 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
703 ret = avcodec_encode_audio(enc, audio_out, size_out,
706 pkt.stream_index= ost->index;
709 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
710 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
711 pkt.flags |= PKT_FLAG_KEY;
712 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
716 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
720 AVPicture picture_tmp;
723 dec = ist->st->codec;
725 /* deinterlace : must be done before any resize */
726 if (do_deinterlace || using_vhook) {
729 /* create temporary picture */
730 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
731 buf = av_malloc(size);
735 picture2 = &picture_tmp;
736 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
739 if(avpicture_deinterlace(picture2, picture,
740 dec->pix_fmt, dec->width, dec->height) < 0) {
741 /* if error, do not deinterlace */
742 fprintf(stderr, "Deinterlacing failed\n");
748 av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
755 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,
756 1000000 * ist->pts / AV_TIME_BASE);
758 if (picture != picture2)
759 *picture = *picture2;
763 /* we begin to correct av delay at this threshold */
764 #define AV_DELAY_MAX 0.100
766 static void do_subtitle_out(AVFormatContext *s,
772 static uint8_t *subtitle_out = NULL;
773 int subtitle_out_max_size = 65536;
774 int subtitle_out_size, nb, i;
778 if (pts == AV_NOPTS_VALUE) {
779 fprintf(stderr, "Subtitle packets must have a pts\n");
785 enc = ost->st->codec;
788 subtitle_out = av_malloc(subtitle_out_max_size);
791 /* Note: DVB subtitle need one packet to draw them and one other
792 packet to clear them */
793 /* XXX: signal it in the codec context ? */
794 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
799 for(i = 0; i < nb; i++) {
800 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
801 subtitle_out_max_size, sub);
803 av_init_packet(&pkt);
804 pkt.stream_index = ost->index;
805 pkt.data = subtitle_out;
806 pkt.size = subtitle_out_size;
807 pkt.pts = av_rescale_q(pts, ist->st->time_base, ost->st->time_base);
808 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
809 /* XXX: the pts correction is handled here. Maybe handling
810 it in the codec would be better */
812 pkt.pts += 90 * sub->start_display_time;
814 pkt.pts += 90 * sub->end_display_time;
816 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
820 static int bit_buffer_size= 1024*256;
821 static uint8_t *bit_buffer= NULL;
823 static void do_video_out(AVFormatContext *s,
829 int nb_frames, i, ret;
830 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
831 AVFrame picture_crop_temp, picture_pad_temp;
832 AVCodecContext *enc, *dec;
834 avcodec_get_frame_defaults(&picture_crop_temp);
835 avcodec_get_frame_defaults(&picture_pad_temp);
837 enc = ost->st->codec;
838 dec = ist->st->codec;
840 /* by default, we output a single frame */
845 if(video_sync_method>0 || (video_sync_method && av_q2d(enc->time_base) > 0.001)){
847 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
848 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
851 else if (video_sync_method == 2)
852 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
853 else if (vdelta > 1.1)
854 nb_frames = lrintf(vdelta);
855 //fprintf(stderr, "vdelta:%f, ost->sync_opts:%"PRId64", ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, ost->sync_ipts, nb_frames);
859 fprintf(stderr, "*** drop!\n");
860 }else if (nb_frames > 1) {
861 nb_frames_dup += nb_frames;
863 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
866 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
868 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
872 if (ost->video_crop) {
873 if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
874 av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
879 formatted_picture = &picture_crop_temp;
881 formatted_picture = in_picture;
884 final_picture = formatted_picture;
885 padding_src = formatted_picture;
886 resampling_dst = &ost->pict_tmp;
887 if (ost->video_pad) {
888 final_picture = &ost->pict_tmp;
889 if (ost->video_resample) {
890 if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
891 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
896 resampling_dst = &picture_pad_temp;
900 if (ost->video_resample) {
902 final_picture = &ost->pict_tmp;
903 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
904 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
907 if (ost->video_pad) {
908 av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
909 enc->height, enc->width, enc->pix_fmt,
910 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
913 /* duplicates frame if needed */
914 for(i=0;i<nb_frames;i++) {
916 av_init_packet(&pkt);
917 pkt.stream_index= ost->index;
919 if (s->oformat->flags & AVFMT_RAWPICTURE) {
920 /* raw pictures are written as AVPicture structure to
921 avoid any copies. We support temorarily the older
923 AVFrame* old_frame = enc->coded_frame;
924 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
925 pkt.data= (uint8_t *)final_picture;
926 pkt.size= sizeof(AVPicture);
927 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
928 pkt.flags |= PKT_FLAG_KEY;
930 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
931 enc->coded_frame = old_frame;
935 big_picture= *final_picture;
936 /* better than nothing: use input picture interlaced
938 big_picture.interlaced_frame = in_picture->interlaced_frame;
939 if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
940 if(top_field_first == -1)
941 big_picture.top_field_first = in_picture->top_field_first;
943 big_picture.top_field_first = top_field_first;
946 /* handles sameq here. This is not correct because it may
947 not be a global option */
949 big_picture.quality = ist->st->quality;
951 big_picture.quality = ost->st->quality;
953 big_picture.pict_type = 0;
954 // big_picture.pts = AV_NOPTS_VALUE;
955 big_picture.pts= ost->sync_opts;
956 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
957 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
958 ret = avcodec_encode_video(enc,
959 bit_buffer, bit_buffer_size,
962 fprintf(stderr, "Video encoding failed\n");
965 //enc->frame_number = enc->real_pict_num;
967 pkt.data= bit_buffer;
969 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
970 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
971 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
972 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
973 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
975 if(enc->coded_frame->key_frame)
976 pkt.flags |= PKT_FLAG_KEY;
977 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
980 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
981 // enc->frame_number-1, enc->real_pict_num, ret,
983 /* if two pass, output log */
984 if (ost->logfile && enc->stats_out) {
985 fprintf(ost->logfile, "%s", enc->stats_out);
994 static double psnr(double d){
995 return -10.0*log(d)/log(10.0);
998 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1001 AVCodecContext *enc;
1003 double ti1, bitrate, avg_bitrate;
1005 /* this is executed just the first time do_video_stats is called */
1007 vstats_file = fopen(vstats_filename, "w");
1014 enc = ost->st->codec;
1015 if (enc->codec_type == CODEC_TYPE_VIDEO) {
1016 frame_number = ost->frame_number;
1017 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1018 if (enc->flags&CODEC_FLAG_PSNR)
1019 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1021 fprintf(vstats_file,"f_size= %6d ", frame_size);
1022 /* compute pts value */
1023 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1027 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1028 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1029 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1030 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1031 fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1035 static void print_report(AVFormatContext **output_files,
1036 AVOutputStream **ost_table, int nb_ostreams,
1040 AVOutputStream *ost;
1041 AVFormatContext *oc, *os;
1043 AVCodecContext *enc;
1044 int frame_number, vid, i;
1045 double bitrate, ti1, pts;
1046 static int64_t last_time = -1;
1047 static int qp_histogram[52];
1049 if (!is_last_report) {
1051 /* display the report every 0.5 seconds */
1052 cur_time = av_gettime();
1053 if (last_time == -1) {
1054 last_time = cur_time;
1057 if ((cur_time - last_time) < 500000)
1059 last_time = cur_time;
1063 oc = output_files[0];
1065 total_size = url_fsize(oc->pb);
1066 if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1067 total_size= url_ftell(oc->pb);
1072 for(i=0;i<nb_ostreams;i++) {
1074 os = output_files[ost->file_index];
1075 enc = ost->st->codec;
1076 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1077 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1078 !ost->st->stream_copy ?
1079 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1081 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1082 float t = (av_gettime()-timer_start) / 1000000.0;
1084 frame_number = ost->frame_number;
1085 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1086 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1087 !ost->st->stream_copy ?
1088 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1090 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1093 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1094 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
1097 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1099 if (enc->flags&CODEC_FLAG_PSNR){
1101 double error, error_sum=0;
1102 double scale, scale_sum=0;
1103 char type[3]= {'Y','U','V'};
1104 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1107 error= enc->error[j];
1108 scale= enc->width*enc->height*255.0*255.0*frame_number;
1110 error= enc->coded_frame->error[j];
1111 scale= enc->width*enc->height*255.0*255.0;
1116 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1118 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1122 /* compute min output value */
1123 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1124 if ((pts < ti1) && (pts > 0))
1130 if (verbose || is_last_report) {
1131 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1133 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1134 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1135 (double)total_size / 1024, ti1, bitrate);
1138 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1139 nb_frames_dup, nb_frames_drop);
1142 fprintf(stderr, "%s \r", buf);
1147 if (is_last_report && verbose >= 0){
1148 int64_t raw= audio_size + video_size + extra_size;
1149 fprintf(stderr, "\n");
1150 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1154 100.0*(total_size - raw)/raw
1159 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1160 static int output_packet(AVInputStream *ist, int ist_index,
1161 AVOutputStream **ost_table, int nb_ostreams,
1162 const AVPacket *pkt)
1164 AVFormatContext *os;
1165 AVOutputStream *ost;
1169 int data_size, got_picture;
1171 void *buffer_to_free;
1172 static unsigned int samples_size= 0;
1173 static short *samples= NULL;
1174 AVSubtitle subtitle, *subtitle_to_free;
1177 if(ist->next_pts == AV_NOPTS_VALUE)
1178 ist->next_pts= ist->pts;
1187 if(pkt->dts != AV_NOPTS_VALUE)
1188 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1193 //while we have more to decode or while the decoder did output something on EOF
1194 while (len > 0 || (!pkt && ist->next_pts != ist->pts)) {
1196 ist->pts= ist->next_pts;
1198 if(len && len != pkt->size && verbose>0)
1199 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1201 /* decode the packet if needed */
1202 data_buf = NULL; /* fail safe */
1204 subtitle_to_free = NULL;
1205 if (ist->decoding_needed) {
1206 switch(ist->st->codec->codec_type) {
1207 case CODEC_TYPE_AUDIO:{
1208 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1209 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1211 samples= av_malloc(samples_size);
1213 data_size= samples_size;
1214 /* XXX: could avoid copy if PCM 16 bits with same
1215 endianness as CPU */
1216 ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1222 /* Some bug in mpeg audio decoder gives */
1223 /* data_size < 0, it seems they are overflows */
1224 if (data_size <= 0) {
1225 /* no audio frame */
1228 data_buf = (uint8_t *)samples;
1229 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1230 (ist->st->codec->sample_rate * ist->st->codec->channels);
1232 case CODEC_TYPE_VIDEO:
1233 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1234 /* XXX: allocate picture correctly */
1235 avcodec_get_frame_defaults(&picture);
1237 ret = avcodec_decode_video(ist->st->codec,
1238 &picture, &got_picture, ptr, len);
1239 ist->st->quality= picture.quality;
1243 /* no picture yet */
1244 goto discard_packet;
1246 if (ist->st->codec->time_base.num != 0) {
1247 ist->next_pts += ((int64_t)AV_TIME_BASE *
1248 ist->st->codec->time_base.num) /
1249 ist->st->codec->time_base.den;
1253 case CODEC_TYPE_SUBTITLE:
1254 ret = avcodec_decode_subtitle(ist->st->codec,
1255 &subtitle, &got_subtitle, ptr, len);
1258 if (!got_subtitle) {
1259 goto discard_packet;
1261 subtitle_to_free = &subtitle;
1268 switch(ist->st->codec->codec_type) {
1269 case CODEC_TYPE_AUDIO:
1270 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1271 ist->st->codec->sample_rate;
1273 case CODEC_TYPE_VIDEO:
1274 if (ist->st->codec->time_base.num != 0) {
1275 ist->next_pts += ((int64_t)AV_TIME_BASE *
1276 ist->st->codec->time_base.num) /
1277 ist->st->codec->time_base.den;
1287 buffer_to_free = NULL;
1288 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1289 pre_process_video_frame(ist, (AVPicture *)&picture,
1293 // preprocess audio (volume)
1294 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1295 if (audio_volume != 256) {
1298 for(i=0;i<(data_size / sizeof(short));i++) {
1299 int v = ((*volp) * audio_volume + 128) >> 8;
1300 if (v < -32768) v = -32768;
1301 if (v > 32767) v = 32767;
1307 /* frame rate emulation */
1308 if (ist->st->codec->rate_emu) {
1309 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1310 int64_t now = av_gettime() - ist->start;
1317 /* if output time reached then transcode raw format,
1318 encode packets and output them */
1319 if (start_time == 0 || ist->pts >= start_time)
1320 for(i=0;i<nb_ostreams;i++) {
1324 if (ost->source_index == ist_index) {
1325 os = output_files[ost->file_index];
1328 printf("%d: got pts=%0.3f %0.3f\n", i,
1329 (double)pkt->pts / AV_TIME_BASE,
1330 ((double)ist->pts / AV_TIME_BASE) -
1331 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1333 /* set the input output pts pairs */
1334 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1336 if (ost->encoding_needed) {
1337 switch(ost->st->codec->codec_type) {
1338 case CODEC_TYPE_AUDIO:
1339 do_audio_out(os, ost, ist, data_buf, data_size);
1341 case CODEC_TYPE_VIDEO:
1342 do_video_out(os, ost, ist, &picture, &frame_size);
1343 if (vstats_filename && frame_size)
1344 do_video_stats(os, ost, frame_size);
1346 case CODEC_TYPE_SUBTITLE:
1347 do_subtitle_out(os, ost, ist, &subtitle,
1354 AVFrame avframe; //FIXME/XXX remove this
1356 av_init_packet(&opkt);
1358 if (!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY))
1361 /* no reencoding needed : output the packet directly */
1362 /* force the input stream PTS */
1364 avcodec_get_frame_defaults(&avframe);
1365 ost->st->codec->coded_frame= &avframe;
1366 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1368 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1369 audio_size += data_size;
1370 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1371 video_size += data_size;
1375 opkt.stream_index= ost->index;
1376 if(pkt->pts != AV_NOPTS_VALUE)
1377 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1379 opkt.pts= AV_NOPTS_VALUE;
1381 if (pkt->dts == AV_NOPTS_VALUE)
1382 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1384 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1386 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1387 opkt.flags= pkt->flags;
1389 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1390 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1391 opkt.destruct= av_destruct_packet;
1393 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1394 ost->st->codec->frame_number++;
1395 ost->frame_number++;
1396 av_free_packet(&opkt);
1400 av_free(buffer_to_free);
1401 /* XXX: allocate the subtitles in the codec ? */
1402 if (subtitle_to_free) {
1403 if (subtitle_to_free->rects != NULL) {
1404 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1405 av_free(subtitle_to_free->rects[i].bitmap);
1406 av_free(subtitle_to_free->rects[i].rgba_palette);
1408 av_freep(&subtitle_to_free->rects);
1410 subtitle_to_free->num_rects = 0;
1411 subtitle_to_free = NULL;
1418 for(i=0;i<nb_ostreams;i++) {
1420 if (ost->source_index == ist_index) {
1421 AVCodecContext *enc= ost->st->codec;
1422 os = output_files[ost->file_index];
1424 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1426 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1429 if (ost->encoding_needed) {
1433 av_init_packet(&pkt);
1434 pkt.stream_index= ost->index;
1436 switch(ost->st->codec->codec_type) {
1437 case CODEC_TYPE_AUDIO:
1438 fifo_bytes = av_fifo_size(&ost->fifo);
1440 /* encode any samples remaining in fifo */
1441 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1442 int fs_tmp = enc->frame_size;
1443 enc->frame_size = fifo_bytes / (2 * enc->channels);
1444 av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes);
1445 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1446 enc->frame_size = fs_tmp;
1449 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1452 pkt.flags |= PKT_FLAG_KEY;
1454 case CODEC_TYPE_VIDEO:
1455 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1457 if(enc->coded_frame && enc->coded_frame->key_frame)
1458 pkt.flags |= PKT_FLAG_KEY;
1459 if (ost->logfile && enc->stats_out) {
1460 fprintf(ost->logfile, "%s", enc->stats_out);
1469 pkt.data= bit_buffer;
1471 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1472 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1473 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1485 static void print_sdp(AVFormatContext **avc, int n)
1489 avf_sdp_create(avc, n, sdp, sizeof(sdp));
1490 printf("SDP:\n%s\n", sdp);
1493 static int stream_index_from_inputs(AVFormatContext **input_files,
1495 AVInputFile *file_table,
1496 AVInputStream **ist_table,
1497 enum CodecType type,
1501 for(z=0; z<nb_input_files; z++) {
1502 AVFormatContext *ic = input_files[z];
1503 for(p=0; p<ic->nb_programs; p++) {
1504 AVProgram *program = ic->programs[p];
1505 if(program->id != programid)
1507 for(q=0; q<program->nb_stream_indexes; q++) {
1508 int sidx = program->stream_index[q];
1509 int ris = file_table[z].ist_index + sidx;
1510 if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1520 * The following code is the main loop of the file converter
1522 static int av_encode(AVFormatContext **output_files,
1523 int nb_output_files,
1524 AVFormatContext **input_files,
1526 AVStreamMap *stream_maps, int nb_stream_maps)
1528 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1529 AVFormatContext *is, *os;
1530 AVCodecContext *codec, *icodec;
1531 AVOutputStream *ost, **ost_table = NULL;
1532 AVInputStream *ist, **ist_table = NULL;
1533 AVInputFile *file_table;
1537 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1541 /* input stream init */
1543 for(i=0;i<nb_input_files;i++) {
1544 is = input_files[i];
1545 file_table[i].ist_index = j;
1546 file_table[i].nb_streams = is->nb_streams;
1547 j += is->nb_streams;
1551 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1555 for(i=0;i<nb_istreams;i++) {
1556 ist = av_mallocz(sizeof(AVInputStream));
1562 for(i=0;i<nb_input_files;i++) {
1563 is = input_files[i];
1564 for(k=0;k<is->nb_streams;k++) {
1565 ist = ist_table[j++];
1566 ist->st = is->streams[k];
1567 ist->file_index = i;
1569 ist->discard = 1; /* the stream is discarded by default
1572 if (ist->st->codec->rate_emu) {
1573 ist->start = av_gettime();
1579 /* output stream init */
1581 for(i=0;i<nb_output_files;i++) {
1582 os = output_files[i];
1583 if (!os->nb_streams) {
1584 fprintf(stderr, "Output file does not contain any stream\n");
1587 nb_ostreams += os->nb_streams;
1589 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1590 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1594 /* Sanity check the mapping args -- do the input files & streams exist? */
1595 for(i=0;i<nb_stream_maps;i++) {
1596 int fi = stream_maps[i].file_index;
1597 int si = stream_maps[i].stream_index;
1599 if (fi < 0 || fi > nb_input_files - 1 ||
1600 si < 0 || si > file_table[fi].nb_streams - 1) {
1601 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1604 fi = stream_maps[i].sync_file_index;
1605 si = stream_maps[i].sync_stream_index;
1606 if (fi < 0 || fi > nb_input_files - 1 ||
1607 si < 0 || si > file_table[fi].nb_streams - 1) {
1608 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1613 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1616 for(i=0;i<nb_ostreams;i++) {
1617 ost = av_mallocz(sizeof(AVOutputStream));
1624 for(k=0;k<nb_output_files;k++) {
1625 os = output_files[k];
1626 for(i=0;i<os->nb_streams;i++,n++) {
1629 ost->file_index = k;
1631 ost->st = os->streams[i];
1632 if (nb_stream_maps > 0) {
1633 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1634 stream_maps[n].stream_index;
1636 /* Sanity check that the stream types match */
1637 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1638 int i= ost->file_index;
1639 dump_format(output_files[i], i, output_files[i]->filename, 1);
1640 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1641 stream_maps[n].file_index, stream_maps[n].stream_index,
1642 ost->file_index, ost->index);
1649 j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1651 ost->source_index = j;
1655 /* get corresponding input stream index : we select the first one with the right type */
1657 for(j=0;j<nb_istreams;j++) {
1660 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1661 ost->source_index = j;
1669 if(! opt_programid) {
1670 /* try again and reuse existing stream */
1671 for(j=0;j<nb_istreams;j++) {
1673 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1674 ost->source_index = j;
1680 int i= ost->file_index;
1681 dump_format(output_files[i], i, output_files[i]->filename, 1);
1682 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1683 ost->file_index, ost->index);
1688 ist = ist_table[ost->source_index];
1690 ost->sync_ist = (nb_stream_maps > 0) ?
1691 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
1692 stream_maps[n].sync_stream_index] : ist;
1696 /* for each output stream, we compute the right encoding parameters */
1697 for(i=0;i<nb_ostreams;i++) {
1699 os = output_files[ost->file_index];
1700 ist = ist_table[ost->source_index];
1702 codec = ost->st->codec;
1703 icodec = ist->st->codec;
1705 if (!ost->st->language[0])
1706 av_strlcpy(ost->st->language, ist->st->language,
1707 sizeof(ost->st->language));
1709 ost->st->disposition = ist->st->disposition;
1711 if (ost->st->stream_copy) {
1712 /* if stream_copy is selected, no need to decode or encode */
1713 codec->codec_id = icodec->codec_id;
1714 codec->codec_type = icodec->codec_type;
1716 if(!codec->codec_tag){
1717 if( !os->oformat->codec_tag
1718 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1719 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1720 codec->codec_tag = icodec->codec_tag;
1723 codec->bit_rate = icodec->bit_rate;
1724 codec->extradata= icodec->extradata;
1725 codec->extradata_size= icodec->extradata_size;
1726 if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1727 codec->time_base = icodec->time_base;
1729 codec->time_base = ist->st->time_base;
1730 switch(codec->codec_type) {
1731 case CODEC_TYPE_AUDIO:
1732 if(audio_volume != 256) {
1733 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1736 codec->sample_rate = icodec->sample_rate;
1737 codec->channels = icodec->channels;
1738 codec->frame_size = icodec->frame_size;
1739 codec->block_align= icodec->block_align;
1740 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1741 codec->block_align= 0;
1742 if(codec->codec_id == CODEC_ID_AC3)
1743 codec->block_align= 0;
1745 case CODEC_TYPE_VIDEO:
1747 fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1750 codec->pix_fmt = icodec->pix_fmt;
1751 codec->width = icodec->width;
1752 codec->height = icodec->height;
1753 codec->has_b_frames = icodec->has_b_frames;
1755 case CODEC_TYPE_SUBTITLE:
1761 switch(codec->codec_type) {
1762 case CODEC_TYPE_AUDIO:
1763 if (av_fifo_init(&ost->fifo, 1024))
1765 ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
1766 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1767 icodec->request_channels = codec->channels;
1768 ist->decoding_needed = 1;
1769 ost->encoding_needed = 1;
1771 case CODEC_TYPE_VIDEO:
1772 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1773 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1774 ost->video_resample = ((codec->width != icodec->width -
1775 (frame_leftBand + frame_rightBand) +
1776 (frame_padleft + frame_padright)) ||
1777 (codec->height != icodec->height -
1778 (frame_topBand + frame_bottomBand) +
1779 (frame_padtop + frame_padbottom)) ||
1780 (codec->pix_fmt != icodec->pix_fmt));
1781 if (ost->video_crop) {
1782 ost->topBand = frame_topBand;
1783 ost->leftBand = frame_leftBand;
1785 if (ost->video_pad) {
1786 ost->padtop = frame_padtop;
1787 ost->padleft = frame_padleft;
1788 ost->padbottom = frame_padbottom;
1789 ost->padright = frame_padright;
1790 if (!ost->video_resample) {
1791 avcodec_get_frame_defaults(&ost->pict_tmp);
1792 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1793 codec->width, codec->height))
1797 if (ost->video_resample) {
1798 avcodec_get_frame_defaults(&ost->pict_tmp);
1799 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1800 codec->width, codec->height)) {
1801 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1804 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1805 ost->img_resample_ctx = sws_getContext(
1806 icodec->width - (frame_leftBand + frame_rightBand),
1807 icodec->height - (frame_topBand + frame_bottomBand),
1809 codec->width - (frame_padleft + frame_padright),
1810 codec->height - (frame_padtop + frame_padbottom),
1812 sws_flags, NULL, NULL, NULL);
1813 if (ost->img_resample_ctx == NULL) {
1814 fprintf(stderr, "Cannot get resampling context\n");
1817 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1819 ost->encoding_needed = 1;
1820 ist->decoding_needed = 1;
1822 case CODEC_TYPE_SUBTITLE:
1823 ost->encoding_needed = 1;
1824 ist->decoding_needed = 1;
1831 if (ost->encoding_needed &&
1832 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1833 char logfilename[1024];
1838 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1840 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1841 if (codec->flags & CODEC_FLAG_PASS1) {
1842 f = fopen(logfilename, "w");
1844 perror(logfilename);
1849 /* read the log file */
1850 f = fopen(logfilename, "r");
1852 perror(logfilename);
1855 fseek(f, 0, SEEK_END);
1857 fseek(f, 0, SEEK_SET);
1858 logbuffer = av_malloc(size + 1);
1860 fprintf(stderr, "Could not allocate log buffer\n");
1863 size = fread(logbuffer, 1, size, f);
1865 logbuffer[size] = '\0';
1866 codec->stats_in = logbuffer;
1870 if(codec->codec_type == CODEC_TYPE_VIDEO){
1871 int size= codec->width * codec->height;
1872 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1877 bit_buffer = av_malloc(bit_buffer_size);
1881 /* dump the file output parameters - cannot be done before in case
1883 for(i=0;i<nb_output_files;i++) {
1884 dump_format(output_files[i], i, output_files[i]->filename, 1);
1887 /* dump the stream mapping */
1889 fprintf(stderr, "Stream mapping:\n");
1890 for(i=0;i<nb_ostreams;i++) {
1892 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1893 ist_table[ost->source_index]->file_index,
1894 ist_table[ost->source_index]->index,
1897 if (ost->sync_ist != ist_table[ost->source_index])
1898 fprintf(stderr, " [sync #%d.%d]",
1899 ost->sync_ist->file_index,
1900 ost->sync_ist->index);
1901 fprintf(stderr, "\n");
1905 /* open each encoder */
1906 for(i=0;i<nb_ostreams;i++) {
1908 if (ost->encoding_needed) {
1909 AVCodec *codec = output_codecs[i];
1911 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1913 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1914 ost->file_index, ost->index);
1917 if (avcodec_open(ost->st->codec, codec) < 0) {
1918 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1919 ost->file_index, ost->index);
1922 extra_size += ost->st->codec->extradata_size;
1926 /* open each decoder */
1927 for(i=0;i<nb_istreams;i++) {
1929 if (ist->decoding_needed) {
1930 AVCodec *codec = input_codecs[i];
1932 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1934 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1935 ist->st->codec->codec_id, ist->file_index, ist->index);
1938 if (avcodec_open(ist->st->codec, codec) < 0) {
1939 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1940 ist->file_index, ist->index);
1943 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1944 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1949 for(i=0;i<nb_istreams;i++) {
1951 is = input_files[ist->file_index];
1953 ist->next_pts = AV_NOPTS_VALUE;
1957 /* set meta data information from input file if required */
1958 for (i=0;i<nb_meta_data_maps;i++) {
1959 AVFormatContext *out_file;
1960 AVFormatContext *in_file;
1962 int out_file_index = meta_data_maps[i].out_file;
1963 int in_file_index = meta_data_maps[i].in_file;
1964 if (out_file_index < 0 || out_file_index >= nb_output_files) {
1965 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1966 ret = AVERROR(EINVAL);
1969 if (in_file_index < 0 || in_file_index >= nb_input_files) {
1970 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1971 ret = AVERROR(EINVAL);
1975 out_file = output_files[out_file_index];
1976 in_file = input_files[in_file_index];
1978 strcpy(out_file->title, in_file->title);
1979 strcpy(out_file->author, in_file->author);
1980 strcpy(out_file->copyright, in_file->copyright);
1981 strcpy(out_file->comment, in_file->comment);
1982 strcpy(out_file->album, in_file->album);
1983 out_file->year = in_file->year;
1984 out_file->track = in_file->track;
1985 strcpy(out_file->genre, in_file->genre);
1988 /* open files and write file headers */
1989 for(i=0;i<nb_output_files;i++) {
1990 os = output_files[i];
1991 if (av_write_header(os) < 0) {
1992 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1993 ret = AVERROR(EINVAL);
1996 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2001 print_sdp(output_files, nb_output_files);
2004 if (!using_stdin && verbose >= 0) {
2005 fprintf(stderr, "Press [q] to stop encoding\n");
2006 url_set_interrupt_cb(decode_interrupt_cb);
2011 timer_start = av_gettime();
2013 for(; received_sigterm == 0;) {
2014 int file_index, ist_index;
2022 /* if 'q' pressed, exits */
2026 /* read_key() returns 0 on EOF */
2032 /* select the stream that we must read now by looking at the
2033 smallest output pts */
2035 for(i=0;i<nb_ostreams;i++) {
2038 os = output_files[ost->file_index];
2039 ist = ist_table[ost->source_index];
2040 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2041 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2043 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2044 ipts = (double)ist->pts;
2045 if (!file_table[ist->file_index].eof_reached){
2046 if(ipts < ipts_min) {
2048 if(input_sync ) file_index = ist->file_index;
2050 if(opts < opts_min) {
2052 if(!input_sync) file_index = ist->file_index;
2055 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2060 /* if none, if is finished */
2061 if (file_index < 0) {
2065 /* finish if recording time exhausted */
2066 if (opts_min >= (recording_time / 1000000.0))
2069 /* finish if limit size exhausted */
2070 if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2073 /* read a frame from it and output it in the fifo */
2074 is = input_files[file_index];
2075 if (av_read_frame(is, &pkt) < 0) {
2076 file_table[file_index].eof_reached = 1;
2084 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2086 /* the following test is needed in case new streams appear
2087 dynamically in stream : we ignore them */
2088 if (pkt.stream_index >= file_table[file_index].nb_streams)
2089 goto discard_packet;
2090 ist_index = file_table[file_index].ist_index + pkt.stream_index;
2091 ist = ist_table[ist_index];
2093 goto discard_packet;
2095 if (pkt.dts != AV_NOPTS_VALUE)
2096 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2097 if (pkt.pts != AV_NOPTS_VALUE)
2098 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2100 if(input_files_ts_scale[file_index][pkt.stream_index]){
2101 if(pkt.pts != AV_NOPTS_VALUE)
2102 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2103 if(pkt.dts != AV_NOPTS_VALUE)
2104 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2107 // 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);
2108 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2109 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2110 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2111 int64_t delta= pkt_dts - ist->next_pts;
2112 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2113 input_files_ts_offset[ist->file_index]-= delta;
2115 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2116 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2117 if(pkt.pts != AV_NOPTS_VALUE)
2118 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2122 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2123 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2126 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2127 ist->file_index, ist->index);
2130 av_free_packet(&pkt);
2135 av_free_packet(&pkt);
2137 /* dump report by using the output first video and audio streams */
2138 print_report(output_files, ost_table, nb_ostreams, 0);
2141 /* at the end of stream, we must flush the decoder buffers */
2142 for(i=0;i<nb_istreams;i++) {
2144 if (ist->decoding_needed) {
2145 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2151 /* write the trailer if needed and close file */
2152 for(i=0;i<nb_output_files;i++) {
2153 os = output_files[i];
2154 av_write_trailer(os);
2157 /* dump report by using the first video and audio streams */
2158 print_report(output_files, ost_table, nb_ostreams, 1);
2160 /* close each encoder */
2161 for(i=0;i<nb_ostreams;i++) {
2163 if (ost->encoding_needed) {
2164 av_freep(&ost->st->codec->stats_in);
2165 avcodec_close(ost->st->codec);
2169 /* close each decoder */
2170 for(i=0;i<nb_istreams;i++) {
2172 if (ist->decoding_needed) {
2173 avcodec_close(ist->st->codec);
2181 av_freep(&bit_buffer);
2182 av_free(file_table);
2185 for(i=0;i<nb_istreams;i++) {
2192 for(i=0;i<nb_ostreams;i++) {
2196 fclose(ost->logfile);
2197 ost->logfile = NULL;
2199 av_fifo_free(&ost->fifo); /* works even if fifo is not
2200 initialized but set to zero */
2201 av_free(ost->pict_tmp.data[0]);
2202 if (ost->video_resample)
2203 sws_freeContext(ost->img_resample_ctx);
2205 audio_resample_close(ost->resample);
2206 if (ost->reformat_ctx)
2207 av_audio_convert_free(ost->reformat_ctx);
2215 ret = AVERROR(ENOMEM);
2220 int file_read(const char *filename)
2223 unsigned char buffer[1024];
2226 if (url_open(&h, filename, O_RDONLY) < 0) {
2227 printf("could not open '%s'\n", filename);
2231 len = url_read(h, buffer, sizeof(buffer));
2234 for(i=0;i<len;i++) putchar(buffer[i]);
2241 static void opt_format(const char *arg)
2243 /* compatibility stuff for pgmyuv */
2244 if (!strcmp(arg, "pgmyuv")) {
2245 pgmyuv_compatibility_hack=1;
2246 // opt_image_format(arg);
2248 fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2251 file_iformat = av_find_input_format(arg);
2252 file_oformat = guess_format(arg, NULL, NULL);
2253 if (!file_iformat && !file_oformat) {
2254 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2259 static void opt_video_rc_override_string(const char *arg)
2261 video_rc_override_string = arg;
2264 static int opt_me_threshold(const char *opt, const char *arg)
2266 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2270 static int opt_verbose(const char *opt, const char *arg)
2272 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2273 av_log_set_level(verbose);
2277 static int opt_frame_rate(const char *opt, const char *arg)
2279 if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2280 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2286 static int opt_bitrate(const char *opt, const char *arg)
2288 int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2290 opt_default(opt, arg);
2292 if (av_get_int(avctx_opts[codec_type], "b", NULL) < 1000)
2293 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2298 static void opt_frame_crop_top(const char *arg)
2300 frame_topBand = atoi(arg);
2301 if (frame_topBand < 0) {
2302 fprintf(stderr, "Incorrect top crop size\n");
2305 if ((frame_topBand % 2) != 0) {
2306 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2309 if ((frame_topBand) >= frame_height){
2310 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2313 frame_height -= frame_topBand;
2316 static void opt_frame_crop_bottom(const char *arg)
2318 frame_bottomBand = atoi(arg);
2319 if (frame_bottomBand < 0) {
2320 fprintf(stderr, "Incorrect bottom crop size\n");
2323 if ((frame_bottomBand % 2) != 0) {
2324 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2327 if ((frame_bottomBand) >= frame_height){
2328 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2331 frame_height -= frame_bottomBand;
2334 static void opt_frame_crop_left(const char *arg)
2336 frame_leftBand = atoi(arg);
2337 if (frame_leftBand < 0) {
2338 fprintf(stderr, "Incorrect left crop size\n");
2341 if ((frame_leftBand % 2) != 0) {
2342 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2345 if ((frame_leftBand) >= frame_width){
2346 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2349 frame_width -= frame_leftBand;
2352 static void opt_frame_crop_right(const char *arg)
2354 frame_rightBand = atoi(arg);
2355 if (frame_rightBand < 0) {
2356 fprintf(stderr, "Incorrect right crop size\n");
2359 if ((frame_rightBand % 2) != 0) {
2360 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2363 if ((frame_rightBand) >= frame_width){
2364 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2367 frame_width -= frame_rightBand;
2370 static void opt_frame_size(const char *arg)
2372 if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2373 fprintf(stderr, "Incorrect frame size\n");
2376 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2377 fprintf(stderr, "Frame size must be a multiple of 2\n");
2383 #define SCALEBITS 10
2384 #define ONE_HALF (1 << (SCALEBITS - 1))
2385 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2387 #define RGB_TO_Y(r, g, b) \
2388 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2389 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2391 #define RGB_TO_U(r1, g1, b1, shift)\
2392 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2393 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2395 #define RGB_TO_V(r1, g1, b1, shift)\
2396 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2397 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2399 static void opt_pad_color(const char *arg) {
2400 /* Input is expected to be six hex digits similar to
2401 how colors are expressed in html tags (but without the #) */
2402 int rgb = strtol(arg, NULL, 16);
2406 g = ((rgb >> 8) & 255);
2409 padcolor[0] = RGB_TO_Y(r,g,b);
2410 padcolor[1] = RGB_TO_U(r,g,b,0);
2411 padcolor[2] = RGB_TO_V(r,g,b,0);
2414 static void opt_frame_pad_top(const char *arg)
2416 frame_padtop = atoi(arg);
2417 if (frame_padtop < 0) {
2418 fprintf(stderr, "Incorrect top pad size\n");
2421 if ((frame_padtop % 2) != 0) {
2422 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2427 static void opt_frame_pad_bottom(const char *arg)
2429 frame_padbottom = atoi(arg);
2430 if (frame_padbottom < 0) {
2431 fprintf(stderr, "Incorrect bottom pad size\n");
2434 if ((frame_padbottom % 2) != 0) {
2435 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2441 static void opt_frame_pad_left(const char *arg)
2443 frame_padleft = atoi(arg);
2444 if (frame_padleft < 0) {
2445 fprintf(stderr, "Incorrect left pad size\n");
2448 if ((frame_padleft % 2) != 0) {
2449 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2455 static void opt_frame_pad_right(const char *arg)
2457 frame_padright = atoi(arg);
2458 if (frame_padright < 0) {
2459 fprintf(stderr, "Incorrect right pad size\n");
2462 if ((frame_padright % 2) != 0) {
2463 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2468 static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2472 for (i=-1; i < nb_fmts; i++) {
2473 get_fmt_string (fmt_str, sizeof(fmt_str), i);
2474 fprintf(stdout, "%s\n", fmt_str);
2478 static void opt_frame_pix_fmt(const char *arg)
2480 if (strcmp(arg, "list"))
2481 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2483 list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2488 static void opt_frame_aspect_ratio(const char *arg)
2495 p = strchr(arg, ':');
2497 x = strtol(arg, &end, 10);
2499 y = strtol(end+1, &end, 10);
2501 ar = (double)x / (double)y;
2503 ar = strtod(arg, NULL);
2506 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2509 frame_aspect_ratio = ar;
2512 static void opt_qscale(const char *arg)
2514 video_qscale = atof(arg);
2515 if (video_qscale <= 0 ||
2516 video_qscale > 255) {
2517 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2522 static void opt_top_field_first(const char *arg)
2524 top_field_first= atoi(arg);
2527 static int opt_thread_count(const char *opt, const char *arg)
2529 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2530 #if !defined(HAVE_THREADS)
2532 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2537 static void opt_audio_sample_fmt(const char *arg)
2539 if (strcmp(arg, "list"))
2540 audio_sample_fmt = avcodec_get_sample_fmt(arg);
2542 list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2547 static int opt_audio_rate(const char *opt, const char *arg)
2549 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2553 static int opt_audio_channels(const char *opt, const char *arg)
2555 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2559 static void opt_video_channel(const char *arg)
2561 video_channel = strtol(arg, NULL, 0);
2564 static void opt_video_standard(const char *arg)
2566 video_standard = av_strdup(arg);
2569 static void opt_codec(int *pstream_copy, char **pcodec_name,
2570 int codec_type, const char *arg)
2572 av_freep(pcodec_name);
2573 if (!strcmp(arg, "copy")) {
2576 *pcodec_name = av_strdup(arg);
2580 static void opt_audio_codec(const char *arg)
2582 opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2585 static void opt_audio_tag(const char *arg)
2588 audio_codec_tag= strtol(arg, &tail, 0);
2591 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2594 static void opt_video_tag(const char *arg)
2597 video_codec_tag= strtol(arg, &tail, 0);
2600 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2604 static void add_frame_hooker(const char *arg)
2609 char *args = av_strdup(arg);
2613 argv[0] = strtok(args, " ");
2614 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2617 i = frame_hook_add(argc, argv);
2620 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2626 static void opt_video_codec(const char *arg)
2628 opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2631 static void opt_subtitle_codec(const char *arg)
2633 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2636 static void opt_map(const char *arg)
2641 m = &stream_maps[nb_stream_maps++];
2643 m->file_index = strtol(arg, &p, 0);
2647 m->stream_index = strtol(p, &p, 0);
2650 m->sync_file_index = strtol(p, &p, 0);
2653 m->sync_stream_index = strtol(p, &p, 0);
2655 m->sync_file_index = m->file_index;
2656 m->sync_stream_index = m->stream_index;
2660 static void opt_map_meta_data(const char *arg)
2665 m = &meta_data_maps[nb_meta_data_maps++];
2667 m->out_file = strtol(arg, &p, 0);
2671 m->in_file = strtol(p, &p, 0);
2674 static void opt_input_ts_scale(const char *arg)
2676 unsigned int stream;
2680 stream = strtol(arg, &p, 0);
2683 scale= strtod(p, &p);
2685 if(stream >= MAX_STREAMS)
2688 input_files_ts_scale[nb_input_files][stream]= scale;
2691 static int opt_recording_time(const char *opt, const char *arg)
2693 recording_time = parse_time_or_die(opt, arg, 1);
2697 static int opt_start_time(const char *opt, const char *arg)
2699 start_time = parse_time_or_die(opt, arg, 1);
2703 static int opt_rec_timestamp(const char *opt, const char *arg)
2705 rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2709 static int opt_input_ts_offset(const char *opt, const char *arg)
2711 input_ts_offset = parse_time_or_die(opt, arg, 1);
2715 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2717 const char *codec_string = encoder ? "encoder" : "decoder";
2721 return CODEC_ID_NONE;
2723 avcodec_find_encoder_by_name(name) :
2724 avcodec_find_decoder_by_name(name);
2726 av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2729 if(codec->type != type) {
2730 av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2736 static void opt_input_file(const char *filename)
2738 AVFormatContext *ic;
2739 AVFormatParameters params, *ap = ¶ms;
2740 int err, i, ret, rfps, rfps_base;
2743 if (!strcmp(filename, "-"))
2746 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2747 !strcmp(filename, "/dev/stdin");
2749 /* get default parameters from command line */
2750 ic = av_alloc_format_context();
2752 memset(ap, 0, sizeof(*ap));
2753 ap->prealloced_context = 1;
2754 ap->sample_rate = audio_sample_rate;
2755 ap->channels = audio_channels;
2756 ap->time_base.den = frame_rate.num;
2757 ap->time_base.num = frame_rate.den;
2758 ap->width = frame_width + frame_padleft + frame_padright;
2759 ap->height = frame_height + frame_padtop + frame_padbottom;
2760 ap->pix_fmt = frame_pix_fmt;
2761 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2762 ap->channel = video_channel;
2763 ap->standard = video_standard;
2764 ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2765 ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2766 if(pgmyuv_compatibility_hack)
2767 ap->video_codec_id= CODEC_ID_PGMYUV;
2769 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2771 ic->video_codec_id = find_codec_or_die(video_codec_name , CODEC_TYPE_VIDEO , 0);
2772 ic->audio_codec_id = find_codec_or_die(audio_codec_name , CODEC_TYPE_AUDIO , 0);
2773 ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2775 /* open the input file with generic libav function */
2776 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2778 print_error(filename, err);
2783 for(i=0; i<ic->nb_programs; i++)
2784 if(ic->programs[i]->id != opt_programid)
2785 ic->programs[i]->discard = AVDISCARD_ALL;
2788 ic->loop_input = loop_input;
2790 /* If not enough info to get the stream parameters, we decode the
2791 first frames to get it. (used in mpeg case for example) */
2792 ret = av_find_stream_info(ic);
2793 if (ret < 0 && verbose >= 0) {
2794 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2798 timestamp = start_time;
2799 /* add the stream start time */
2800 if (ic->start_time != AV_NOPTS_VALUE)
2801 timestamp += ic->start_time;
2803 /* if seeking requested, we execute it */
2804 if (start_time != 0) {
2805 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2807 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2808 filename, (double)timestamp / AV_TIME_BASE);
2810 /* reset seek info */
2814 /* update the current parameters so that they match the one of the input stream */
2815 for(i=0;i<ic->nb_streams;i++) {
2816 AVCodecContext *enc = ic->streams[i]->codec;
2818 avcodec_thread_init(enc, thread_count);
2819 enc->thread_count= thread_count;
2820 switch(enc->codec_type) {
2821 case CODEC_TYPE_AUDIO:
2822 set_context_opts(enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2823 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2824 audio_channels = enc->channels;
2825 audio_sample_rate = enc->sample_rate;
2826 audio_sample_fmt = enc->sample_fmt;
2827 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
2829 ic->streams[i]->discard= AVDISCARD_ALL;
2831 case CODEC_TYPE_VIDEO:
2832 set_context_opts(enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2833 frame_height = enc->height;
2834 frame_width = enc->width;
2835 if(ic->streams[i]->sample_aspect_ratio.num)
2836 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
2838 frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
2839 frame_aspect_ratio *= (float) enc->width / enc->height;
2840 frame_pix_fmt = enc->pix_fmt;
2841 rfps = ic->streams[i]->r_frame_rate.num;
2842 rfps_base = ic->streams[i]->r_frame_rate.den;
2843 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2845 enc->debug |= FF_DEBUG_MV;
2847 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2850 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2851 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2853 (float)rfps / rfps_base, rfps, rfps_base);
2855 /* update the current frame rate to match the stream frame rate */
2856 frame_rate.num = rfps;
2857 frame_rate.den = rfps_base;
2859 enc->rate_emu = rate_emu;
2860 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2862 ic->streams[i]->discard= AVDISCARD_ALL;
2863 else if(video_discard)
2864 ic->streams[i]->discard= video_discard;
2866 case CODEC_TYPE_DATA:
2868 case CODEC_TYPE_SUBTITLE:
2869 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
2870 if(subtitle_disable)
2871 ic->streams[i]->discard = AVDISCARD_ALL;
2873 case CODEC_TYPE_ATTACHMENT:
2874 case CODEC_TYPE_UNKNOWN:
2882 input_files[nb_input_files] = ic;
2883 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2884 /* dump the file content */
2886 dump_format(ic, nb_input_files, filename, 0);
2889 file_iformat = NULL;
2890 file_oformat = NULL;
2895 av_freep(&video_codec_name);
2896 av_freep(&audio_codec_name);
2897 av_freep(&subtitle_codec_name);
2900 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2901 int *has_subtitle_ptr)
2903 int has_video, has_audio, has_subtitle, i, j;
2904 AVFormatContext *ic;
2909 for(j=0;j<nb_input_files;j++) {
2910 ic = input_files[j];
2911 for(i=0;i<ic->nb_streams;i++) {
2912 AVCodecContext *enc = ic->streams[i]->codec;
2913 switch(enc->codec_type) {
2914 case CODEC_TYPE_AUDIO:
2917 case CODEC_TYPE_VIDEO:
2920 case CODEC_TYPE_SUBTITLE:
2923 case CODEC_TYPE_DATA:
2924 case CODEC_TYPE_ATTACHMENT:
2925 case CODEC_TYPE_UNKNOWN:
2932 *has_video_ptr = has_video;
2933 *has_audio_ptr = has_audio;
2934 *has_subtitle_ptr = has_subtitle;
2937 static void new_video_stream(AVFormatContext *oc)
2940 AVCodecContext *video_enc;
2943 st = av_new_stream(oc, oc->nb_streams);
2945 fprintf(stderr, "Could not alloc stream\n");
2948 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2949 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2950 video_bitstream_filters= NULL;
2953 avcodec_thread_init(st->codec, thread_count);
2955 video_enc = st->codec;
2958 video_enc->codec_tag= video_codec_tag;
2960 if( (video_global_header&1)
2961 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2962 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2963 avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2965 if(video_global_header&2){
2966 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2967 avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2970 if (video_stream_copy) {
2971 st->stream_copy = 1;
2972 video_enc->codec_type = CODEC_TYPE_VIDEO;
2973 video_enc->sample_aspect_ratio =
2974 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
2979 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
2981 if (video_codec_name) {
2982 codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
2983 codec = avcodec_find_encoder_by_name(video_codec_name);
2984 output_codecs[nb_ocodecs] = codec;
2986 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2987 codec = avcodec_find_encoder(codec_id);
2990 video_enc->codec_id = codec_id;
2992 set_context_opts(video_enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
2994 if (codec && codec->supported_framerates && !force_fps)
2995 fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
2996 video_enc->time_base.den = fps.num;
2997 video_enc->time_base.num = fps.den;
2999 video_enc->width = frame_width + frame_padright + frame_padleft;
3000 video_enc->height = frame_height + frame_padtop + frame_padbottom;
3001 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3002 video_enc->pix_fmt = frame_pix_fmt;
3003 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3005 if(codec && codec->pix_fmts){
3006 const enum PixelFormat *p= codec->pix_fmts;
3008 if(*p == video_enc->pix_fmt)
3012 video_enc->pix_fmt = codec->pix_fmts[0];
3016 video_enc->gop_size = 0;
3017 if (video_qscale || same_quality) {
3018 video_enc->flags |= CODEC_FLAG_QSCALE;
3019 video_enc->global_quality=
3020 st->quality = FF_QP2LAMBDA * video_qscale;
3024 video_enc->intra_matrix = intra_matrix;
3026 video_enc->inter_matrix = inter_matrix;
3028 video_enc->thread_count = thread_count;
3029 p= video_rc_override_string;
3032 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3034 fprintf(stderr, "error parsing rc_override\n");
3037 video_enc->rc_override=
3038 av_realloc(video_enc->rc_override,
3039 sizeof(RcOverride)*(i+1));
3040 video_enc->rc_override[i].start_frame= start;
3041 video_enc->rc_override[i].end_frame = end;
3043 video_enc->rc_override[i].qscale= q;
3044 video_enc->rc_override[i].quality_factor= 1.0;
3047 video_enc->rc_override[i].qscale= 0;
3048 video_enc->rc_override[i].quality_factor= -q/100.0;
3053 video_enc->rc_override_count=i;
3054 if (!video_enc->rc_initial_buffer_occupancy)
3055 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3056 video_enc->me_threshold= me_threshold;
3057 video_enc->intra_dc_precision= intra_dc_precision - 8;
3060 video_enc->flags|= CODEC_FLAG_PSNR;
3065 video_enc->flags |= CODEC_FLAG_PASS1;
3067 video_enc->flags |= CODEC_FLAG_PASS2;
3073 /* reset some key parameters */
3075 av_freep(&video_codec_name);
3076 video_stream_copy = 0;
3079 static void new_audio_stream(AVFormatContext *oc)
3082 AVCodecContext *audio_enc;
3085 st = av_new_stream(oc, oc->nb_streams);
3087 fprintf(stderr, "Could not alloc stream\n");
3090 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3092 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3093 audio_bitstream_filters= NULL;
3096 avcodec_thread_init(st->codec, thread_count);
3098 audio_enc = st->codec;
3099 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3102 audio_enc->codec_tag= audio_codec_tag;
3104 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3105 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3106 avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3108 if (audio_stream_copy) {
3109 st->stream_copy = 1;
3110 audio_enc->channels = audio_channels;
3114 set_context_opts(audio_enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3116 if (audio_codec_name) {
3117 codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3118 codec = avcodec_find_encoder_by_name(audio_codec_name);
3119 output_codecs[nb_ocodecs] = codec;
3121 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3122 codec = avcodec_find_encoder(codec_id);
3124 audio_enc->codec_id = codec_id;
3126 if (audio_qscale > QSCALE_NONE) {
3127 audio_enc->flags |= CODEC_FLAG_QSCALE;
3128 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3130 audio_enc->thread_count = thread_count;
3131 audio_enc->channels = audio_channels;
3132 audio_enc->sample_fmt = audio_sample_fmt;
3134 if(codec && codec->sample_fmts){
3135 const enum SampleFormat *p= codec->sample_fmts;
3137 if(*p == audio_enc->sample_fmt)
3141 audio_enc->sample_fmt = codec->sample_fmts[0];
3145 audio_enc->sample_rate = audio_sample_rate;
3146 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3147 if (audio_language) {
3148 av_strlcpy(st->language, audio_language, sizeof(st->language));
3149 av_free(audio_language);
3150 audio_language = NULL;
3153 /* reset some key parameters */
3155 av_freep(&audio_codec_name);
3156 audio_stream_copy = 0;
3159 static void new_subtitle_stream(AVFormatContext *oc)
3162 AVCodecContext *subtitle_enc;
3164 st = av_new_stream(oc, oc->nb_streams);
3166 fprintf(stderr, "Could not alloc stream\n");
3169 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3171 bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3172 subtitle_bitstream_filters= NULL;
3174 subtitle_enc = st->codec;
3175 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3176 if (subtitle_stream_copy) {
3177 st->stream_copy = 1;
3179 set_context_opts(avctx_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3180 subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3181 output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3185 if (subtitle_language) {
3186 av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3187 av_free(subtitle_language);
3188 subtitle_language = NULL;
3191 subtitle_disable = 0;
3192 av_freep(&subtitle_codec_name);
3193 subtitle_stream_copy = 0;
3196 static void opt_new_audio_stream(void)
3198 AVFormatContext *oc;
3199 if (nb_output_files <= 0) {
3200 fprintf(stderr, "At least one output file must be specified\n");
3203 oc = output_files[nb_output_files - 1];
3204 new_audio_stream(oc);
3207 static void opt_new_video_stream(void)
3209 AVFormatContext *oc;
3210 if (nb_output_files <= 0) {
3211 fprintf(stderr, "At least one output file must be specified\n");
3214 oc = output_files[nb_output_files - 1];
3215 new_video_stream(oc);
3218 static void opt_new_subtitle_stream(void)
3220 AVFormatContext *oc;
3221 if (nb_output_files <= 0) {
3222 fprintf(stderr, "At least one output file must be specified\n");
3225 oc = output_files[nb_output_files - 1];
3226 new_subtitle_stream(oc);
3229 static void opt_output_file(const char *filename)
3231 AVFormatContext *oc;
3232 int use_video, use_audio, use_subtitle;
3233 int input_has_video, input_has_audio, input_has_subtitle;
3234 AVFormatParameters params, *ap = ¶ms;
3236 if (!strcmp(filename, "-"))
3239 oc = av_alloc_format_context();
3241 if (!file_oformat) {
3242 file_oformat = guess_format(NULL, filename, NULL);
3243 if (!file_oformat) {
3244 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3250 oc->oformat = file_oformat;
3251 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3253 if (!strcmp(file_oformat->name, "ffm") &&
3254 av_strstart(filename, "http:", NULL)) {
3255 /* special case for files sent to ffserver: we get the stream
3256 parameters from ffserver */
3257 int err = read_ffserver_streams(oc, filename);
3259 print_error(filename, err);
3263 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3264 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3265 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3267 /* disable if no corresponding type found and at least one
3269 if (nb_input_files > 0) {
3270 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3271 &input_has_subtitle);
3272 if (!input_has_video)
3274 if (!input_has_audio)
3276 if (!input_has_subtitle)
3280 /* manual disable */
3281 if (audio_disable) {
3284 if (video_disable) {
3287 if (subtitle_disable) {
3292 new_video_stream(oc);
3296 new_audio_stream(oc);
3300 new_subtitle_stream(oc);
3303 oc->timestamp = rec_timestamp;
3306 av_strlcpy(oc->title, str_title, sizeof(oc->title));
3308 av_strlcpy(oc->author, str_author, sizeof(oc->author));
3310 av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3312 av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3314 av_strlcpy(oc->album, str_album, sizeof(oc->album));
3316 av_strlcpy(oc->genre, str_genre, sizeof(oc->genre));
3319 output_files[nb_output_files++] = oc;
3321 /* check filename in case of an image number is expected */
3322 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3323 if (!av_filename_number_test(oc->filename)) {
3324 print_error(oc->filename, AVERROR_NUMEXPECTED);
3329 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3330 /* test if it already exists to avoid loosing precious files */
3331 if (!file_overwrite &&
3332 (strchr(filename, ':') == NULL ||
3333 filename[1] == ':' ||
3334 av_strstart(filename, "file:", NULL))) {
3335 if (url_exist(filename)) {
3339 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3342 if (toupper(c) != 'Y') {
3343 fprintf(stderr, "Not overwriting - exiting\n");
3348 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3355 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3356 fprintf(stderr, "Could not open '%s'\n", filename);
3361 memset(ap, 0, sizeof(*ap));
3362 if (av_set_parameters(oc, ap) < 0) {
3363 fprintf(stderr, "%s: Invalid encoding parameters\n",
3368 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3369 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3370 oc->loop_output = loop_output;
3372 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3374 /* reset some options */
3375 file_oformat = NULL;
3376 file_iformat = NULL;
3379 /* same option as mencoder */
3380 static void opt_pass(const char *pass_str)
3383 pass = atoi(pass_str);
3384 if (pass != 1 && pass != 2) {
3385 fprintf(stderr, "pass number can be only 1 or 2\n");
3391 static int64_t getutime(void)
3393 #ifdef HAVE_GETRUSAGE
3394 struct rusage rusage;
3396 getrusage(RUSAGE_SELF, &rusage);
3397 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3398 #elif defined(HAVE_GETPROCESSTIMES)
3400 FILETIME c, e, k, u;
3401 proc = GetCurrentProcess();
3402 GetProcessTimes(proc, &c, &e, &k, &u);
3403 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3405 return av_gettime();
3409 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3412 const char *p = str;
3419 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3426 static void opt_inter_matrix(const char *arg)
3428 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3429 parse_matrix_coeffs(inter_matrix, arg);
3432 static void opt_intra_matrix(const char *arg)
3434 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3435 parse_matrix_coeffs(intra_matrix, arg);
3439 * Trivial log callback.
3440 * Only suitable for show_help and similar since it lacks prefix handling.
3442 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3444 vfprintf(stdout, fmt, vl);
3447 static void show_help(void)
3449 av_log_set_callback(log_callback_help);
3450 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3451 "Hyper fast Audio and Video encoder\n");
3453 show_help_options(options, "Main options:\n",
3454 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3455 show_help_options(options, "\nAdvanced options:\n",
3456 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3458 show_help_options(options, "\nVideo options:\n",
3459 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3461 show_help_options(options, "\nAdvanced Video options:\n",
3462 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3463 OPT_VIDEO | OPT_EXPERT);
3464 show_help_options(options, "\nAudio options:\n",
3465 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3467 show_help_options(options, "\nAdvanced Audio options:\n",
3468 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3469 OPT_AUDIO | OPT_EXPERT);
3470 show_help_options(options, "\nSubtitle options:\n",
3471 OPT_SUBTITLE | OPT_GRAB,
3473 show_help_options(options, "\nAudio/Video grab options:\n",
3477 av_opt_show(avctx_opts[0], NULL);
3479 av_opt_show(avformat_opts, NULL);
3481 av_opt_show(sws_opts, NULL);
3484 static void opt_target(const char *arg)
3487 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3489 if(!strncmp(arg, "pal-", 4)) {
3492 } else if(!strncmp(arg, "ntsc-", 5)) {
3495 } else if(!strncmp(arg, "film-", 5)) {
3500 /* Calculate FR via float to avoid int overflow */
3501 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3504 } else if((fr == 29970) || (fr == 23976)) {
3507 /* Try to determine PAL/NTSC by peeking in the input files */
3508 if(nb_input_files) {
3510 for(j = 0; j < nb_input_files; j++) {
3511 for(i = 0; i < input_files[j]->nb_streams; i++) {
3512 AVCodecContext *c = input_files[j]->streams[i]->codec;
3513 if(c->codec_type != CODEC_TYPE_VIDEO)
3515 fr = c->time_base.den * 1000 / c->time_base.num;
3519 } else if((fr == 29970) || (fr == 23976)) {
3529 if(verbose && norm >= 0)
3530 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3534 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3535 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3536 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3540 if(!strcmp(arg, "vcd")) {
3542 opt_video_codec("mpeg1video");
3543 opt_audio_codec("mp2");
3546 opt_frame_size(norm ? "352x240" : "352x288");
3547 opt_frame_rate(NULL, frame_rates[norm]);
3548 opt_default("gop", norm ? "18" : "15");
3550 opt_default("b", "1150000");
3551 opt_default("maxrate", "1150000");
3552 opt_default("minrate", "1150000");
3553 opt_default("bufsize", "327680"); // 40*1024*8;
3555 opt_default("ab", "224000");
3556 audio_sample_rate = 44100;
3559 opt_default("packetsize", "2324");
3560 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3562 /* We have to offset the PTS, so that it is consistent with the SCR.
3563 SCR starts at 36000, but the first two packs contain only padding
3564 and the first pack from the other stream, respectively, may also have
3565 been written before.
3566 So the real data starts at SCR 36000+3*1200. */
3567 mux_preload= (36000+3*1200) / 90000.0; //0.44
3568 } else if(!strcmp(arg, "svcd")) {
3570 opt_video_codec("mpeg2video");
3571 opt_audio_codec("mp2");
3574 opt_frame_size(norm ? "480x480" : "480x576");
3575 opt_frame_rate(NULL, frame_rates[norm]);
3576 opt_default("gop", norm ? "18" : "15");
3578 opt_default("b", "2040000");
3579 opt_default("maxrate", "2516000");
3580 opt_default("minrate", "0"); //1145000;
3581 opt_default("bufsize", "1835008"); //224*1024*8;
3582 opt_default("flags", "+scan_offset");
3585 opt_default("ab", "224000");
3586 audio_sample_rate = 44100;
3588 opt_default("packetsize", "2324");
3590 } else if(!strcmp(arg, "dvd")) {
3592 opt_video_codec("mpeg2video");
3593 opt_audio_codec("ac3");
3596 opt_frame_size(norm ? "720x480" : "720x576");
3597 opt_frame_rate(NULL, frame_rates[norm]);
3598 opt_default("gop", norm ? "18" : "15");
3600 opt_default("b", "6000000");
3601 opt_default("maxrate", "9000000");
3602 opt_default("minrate", "0"); //1500000;
3603 opt_default("bufsize", "1835008"); //224*1024*8;
3605 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3606 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3608 opt_default("ab", "448000");
3609 audio_sample_rate = 48000;
3611 } else if(!strncmp(arg, "dv", 2)) {
3615 opt_frame_size(norm ? "720x480" : "720x576");
3616 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3617 (norm ? "yuv411p" : "yuv420p"));
3618 opt_frame_rate(NULL, frame_rates[norm]);
3620 audio_sample_rate = 48000;
3624 fprintf(stderr, "Unknown target: %s\n", arg);
3629 static void opt_vstats_file (const char *arg)
3631 av_free (vstats_filename);
3632 vstats_filename=av_strdup (arg);
3635 static void opt_vstats (void)
3638 time_t today2 = time(NULL);
3639 struct tm *today = localtime(&today2);
3641 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3643 opt_vstats_file(filename);
3646 static int opt_bsf(const char *opt, const char *arg)
3648 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3649 AVBitStreamFilterContext **bsfp;
3652 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3656 bsfp= *opt == 'v' ? &video_bitstream_filters :
3657 *opt == 'a' ? &audio_bitstream_filters :
3658 &subtitle_bitstream_filters;
3660 bsfp= &(*bsfp)->next;
3667 static int opt_preset(const char *opt, const char *arg)
3670 char tmp[1000], tmp2[1000], line[1000];
3672 const char *base[3]= { getenv("HOME"),
3677 for(i=!base[0]; i<3 && !f; i++){
3678 snprintf(tmp, sizeof(tmp), "%s/%sffmpeg/%s.ffpreset", base[i], i ? "" : ".", arg);
3681 char *codec_name= *opt == 'v' ? video_codec_name :
3682 *opt == 'a' ? audio_codec_name :
3683 subtitle_codec_name;
3684 snprintf(tmp, sizeof(tmp), "%s/%sffmpeg/%s-%s.ffpreset", base[i], i ? "" : ".", codec_name, arg);
3688 if(!f && ((arg[0]=='.' && arg[1]=='/') || arg[0]=='/')){
3693 fprintf(stderr, "Preset file not found\n");
3698 int e= fscanf(f, "%999[^\n]\n", line) - 1;
3699 if(line[0] == '#' && !e)
3701 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3703 fprintf(stderr, "Preset file invalid\n");
3706 if(!strcmp(tmp, "acodec")){
3707 opt_audio_codec(tmp2);
3708 }else if(!strcmp(tmp, "vcodec")){
3709 opt_video_codec(tmp2);
3710 }else if(!strcmp(tmp, "scodec")){
3711 opt_subtitle_codec(tmp2);
3713 opt_default(tmp, tmp2);
3721 static const OptionDef options[] = {
3723 { "L", OPT_EXIT, {(void*)show_license}, "show license" },
3724 { "h", OPT_EXIT, {(void*)show_help}, "show help" },
3725 { "version", OPT_EXIT, {(void*)show_version}, "show version" },
3726 { "formats", OPT_EXIT, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3727 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3728 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3729 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3730 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3731 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3732 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3733 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3734 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3735 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3736 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
3737 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3738 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3739 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3740 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3741 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3742 { "genre", HAS_ARG | OPT_STRING, {(void*)&str_genre}, "set the genre", "string" },
3743 { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3744 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3745 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3746 "add timings for benchmarking" },
3747 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3748 "dump each input packet" },
3749 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3750 "when dumping packets, also dump the payload" },
3751 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3752 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3753 { "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)", "" },
3754 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set the logging verbosity level", "number" },
3755 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3756 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3757 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3758 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3759 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3760 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3761 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3762 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3763 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3764 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3765 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
3768 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3769 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3770 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3771 { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3772 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3773 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3774 { "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" },
3775 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3776 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3777 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3778 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3779 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3780 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3781 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3782 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3783 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3784 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3785 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3786 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3787 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3788 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3789 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3790 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
3791 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3792 "use same video quality as source (implies VBR)" },
3793 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3794 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3795 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3796 "deinterlace pictures" },
3797 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3798 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3799 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3801 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3803 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3804 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3805 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3806 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3807 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3808 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3809 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3810 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
3813 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3814 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3815 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3816 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3817 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3818 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3819 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3820 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3821 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3822 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3823 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3824 { "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" },
3826 /* subtitle options */
3827 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3828 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3829 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3830 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3833 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3834 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3835 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3838 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3839 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3841 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3842 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3843 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3845 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3846 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3847 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3849 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3853 int main(int argc, char **argv)
3858 avcodec_register_all();
3859 avdevice_register_all();
3862 if(isatty(STDIN_FILENO))
3863 url_set_interrupt_cb(decode_interrupt_cb);
3865 for(i=0; i<CODEC_TYPE_NB; i++){
3866 avctx_opts[i]= avcodec_alloc_context2(i);
3868 avformat_opts = av_alloc_format_context();
3869 sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3878 parse_options(argc, argv, options, opt_output_file);
3880 /* file converter / grab */
3881 if (nb_output_files <= 0) {
3882 fprintf(stderr, "Must supply at least one output file\n");
3886 if (nb_input_files == 0) {
3887 fprintf(stderr, "Must supply at least one input file\n");
3892 av_encode(output_files, nb_output_files, input_files, nb_input_files,
3893 stream_maps, nb_stream_maps);
3894 ti = getutime() - ti;
3896 printf("bench: utime=%0.3fs\n", ti / 1000000.0);