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<FF_ARRAY_ELEMS(qp_histogram))
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);
1494 static int stream_index_from_inputs(AVFormatContext **input_files,
1496 AVInputFile *file_table,
1497 AVInputStream **ist_table,
1498 enum CodecType type,
1502 for(z=0; z<nb_input_files; z++) {
1503 AVFormatContext *ic = input_files[z];
1504 for(p=0; p<ic->nb_programs; p++) {
1505 AVProgram *program = ic->programs[p];
1506 if(program->id != programid)
1508 for(q=0; q<program->nb_stream_indexes; q++) {
1509 int sidx = program->stream_index[q];
1510 int ris = file_table[z].ist_index + sidx;
1511 if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1521 * The following code is the main loop of the file converter
1523 static int av_encode(AVFormatContext **output_files,
1524 int nb_output_files,
1525 AVFormatContext **input_files,
1527 AVStreamMap *stream_maps, int nb_stream_maps)
1529 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1530 AVFormatContext *is, *os;
1531 AVCodecContext *codec, *icodec;
1532 AVOutputStream *ost, **ost_table = NULL;
1533 AVInputStream *ist, **ist_table = NULL;
1534 AVInputFile *file_table;
1538 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1542 /* input stream init */
1544 for(i=0;i<nb_input_files;i++) {
1545 is = input_files[i];
1546 file_table[i].ist_index = j;
1547 file_table[i].nb_streams = is->nb_streams;
1548 j += is->nb_streams;
1552 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1556 for(i=0;i<nb_istreams;i++) {
1557 ist = av_mallocz(sizeof(AVInputStream));
1563 for(i=0;i<nb_input_files;i++) {
1564 is = input_files[i];
1565 for(k=0;k<is->nb_streams;k++) {
1566 ist = ist_table[j++];
1567 ist->st = is->streams[k];
1568 ist->file_index = i;
1570 ist->discard = 1; /* the stream is discarded by default
1573 if (ist->st->codec->rate_emu) {
1574 ist->start = av_gettime();
1580 /* output stream init */
1582 for(i=0;i<nb_output_files;i++) {
1583 os = output_files[i];
1584 if (!os->nb_streams) {
1585 fprintf(stderr, "Output file does not contain any stream\n");
1588 nb_ostreams += os->nb_streams;
1590 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1591 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1595 /* Sanity check the mapping args -- do the input files & streams exist? */
1596 for(i=0;i<nb_stream_maps;i++) {
1597 int fi = stream_maps[i].file_index;
1598 int si = stream_maps[i].stream_index;
1600 if (fi < 0 || fi > nb_input_files - 1 ||
1601 si < 0 || si > file_table[fi].nb_streams - 1) {
1602 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1605 fi = stream_maps[i].sync_file_index;
1606 si = stream_maps[i].sync_stream_index;
1607 if (fi < 0 || fi > nb_input_files - 1 ||
1608 si < 0 || si > file_table[fi].nb_streams - 1) {
1609 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1614 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1617 for(i=0;i<nb_ostreams;i++) {
1618 ost = av_mallocz(sizeof(AVOutputStream));
1625 for(k=0;k<nb_output_files;k++) {
1626 os = output_files[k];
1627 for(i=0;i<os->nb_streams;i++,n++) {
1630 ost->file_index = k;
1632 ost->st = os->streams[i];
1633 if (nb_stream_maps > 0) {
1634 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1635 stream_maps[n].stream_index;
1637 /* Sanity check that the stream types match */
1638 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1639 int i= ost->file_index;
1640 dump_format(output_files[i], i, output_files[i]->filename, 1);
1641 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1642 stream_maps[n].file_index, stream_maps[n].stream_index,
1643 ost->file_index, ost->index);
1650 j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1652 ost->source_index = j;
1656 /* get corresponding input stream index : we select the first one with the right type */
1658 for(j=0;j<nb_istreams;j++) {
1661 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1662 ost->source_index = j;
1670 if(! opt_programid) {
1671 /* try again and reuse existing stream */
1672 for(j=0;j<nb_istreams;j++) {
1674 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1675 ost->source_index = j;
1681 int i= ost->file_index;
1682 dump_format(output_files[i], i, output_files[i]->filename, 1);
1683 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1684 ost->file_index, ost->index);
1689 ist = ist_table[ost->source_index];
1691 ost->sync_ist = (nb_stream_maps > 0) ?
1692 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
1693 stream_maps[n].sync_stream_index] : ist;
1697 /* for each output stream, we compute the right encoding parameters */
1698 for(i=0;i<nb_ostreams;i++) {
1700 os = output_files[ost->file_index];
1701 ist = ist_table[ost->source_index];
1703 codec = ost->st->codec;
1704 icodec = ist->st->codec;
1706 if (!ost->st->language[0])
1707 av_strlcpy(ost->st->language, ist->st->language,
1708 sizeof(ost->st->language));
1710 ost->st->disposition = ist->st->disposition;
1712 if (ost->st->stream_copy) {
1713 /* if stream_copy is selected, no need to decode or encode */
1714 codec->codec_id = icodec->codec_id;
1715 codec->codec_type = icodec->codec_type;
1717 if(!codec->codec_tag){
1718 if( !os->oformat->codec_tag
1719 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1720 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1721 codec->codec_tag = icodec->codec_tag;
1724 codec->bit_rate = icodec->bit_rate;
1725 codec->extradata= icodec->extradata;
1726 codec->extradata_size= icodec->extradata_size;
1727 if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1728 codec->time_base = icodec->time_base;
1730 codec->time_base = ist->st->time_base;
1731 switch(codec->codec_type) {
1732 case CODEC_TYPE_AUDIO:
1733 if(audio_volume != 256) {
1734 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1737 codec->sample_rate = icodec->sample_rate;
1738 codec->channels = icodec->channels;
1739 codec->frame_size = icodec->frame_size;
1740 codec->block_align= icodec->block_align;
1741 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1742 codec->block_align= 0;
1743 if(codec->codec_id == CODEC_ID_AC3)
1744 codec->block_align= 0;
1746 case CODEC_TYPE_VIDEO:
1748 fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1751 codec->pix_fmt = icodec->pix_fmt;
1752 codec->width = icodec->width;
1753 codec->height = icodec->height;
1754 codec->has_b_frames = icodec->has_b_frames;
1756 case CODEC_TYPE_SUBTITLE:
1762 switch(codec->codec_type) {
1763 case CODEC_TYPE_AUDIO:
1764 if (av_fifo_init(&ost->fifo, 1024))
1766 ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
1767 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1768 icodec->request_channels = codec->channels;
1769 ist->decoding_needed = 1;
1770 ost->encoding_needed = 1;
1772 case CODEC_TYPE_VIDEO:
1773 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1774 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1775 ost->video_resample = ((codec->width != icodec->width -
1776 (frame_leftBand + frame_rightBand) +
1777 (frame_padleft + frame_padright)) ||
1778 (codec->height != icodec->height -
1779 (frame_topBand + frame_bottomBand) +
1780 (frame_padtop + frame_padbottom)) ||
1781 (codec->pix_fmt != icodec->pix_fmt));
1782 if (ost->video_crop) {
1783 ost->topBand = frame_topBand;
1784 ost->leftBand = frame_leftBand;
1786 if (ost->video_pad) {
1787 ost->padtop = frame_padtop;
1788 ost->padleft = frame_padleft;
1789 ost->padbottom = frame_padbottom;
1790 ost->padright = frame_padright;
1791 if (!ost->video_resample) {
1792 avcodec_get_frame_defaults(&ost->pict_tmp);
1793 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1794 codec->width, codec->height))
1798 if (ost->video_resample) {
1799 avcodec_get_frame_defaults(&ost->pict_tmp);
1800 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1801 codec->width, codec->height)) {
1802 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1805 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1806 ost->img_resample_ctx = sws_getContext(
1807 icodec->width - (frame_leftBand + frame_rightBand),
1808 icodec->height - (frame_topBand + frame_bottomBand),
1810 codec->width - (frame_padleft + frame_padright),
1811 codec->height - (frame_padtop + frame_padbottom),
1813 sws_flags, NULL, NULL, NULL);
1814 if (ost->img_resample_ctx == NULL) {
1815 fprintf(stderr, "Cannot get resampling context\n");
1818 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1820 ost->encoding_needed = 1;
1821 ist->decoding_needed = 1;
1823 case CODEC_TYPE_SUBTITLE:
1824 ost->encoding_needed = 1;
1825 ist->decoding_needed = 1;
1832 if (ost->encoding_needed &&
1833 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1834 char logfilename[1024];
1839 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1841 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1842 if (codec->flags & CODEC_FLAG_PASS1) {
1843 f = fopen(logfilename, "w");
1845 perror(logfilename);
1850 /* read the log file */
1851 f = fopen(logfilename, "r");
1853 perror(logfilename);
1856 fseek(f, 0, SEEK_END);
1858 fseek(f, 0, SEEK_SET);
1859 logbuffer = av_malloc(size + 1);
1861 fprintf(stderr, "Could not allocate log buffer\n");
1864 size = fread(logbuffer, 1, size, f);
1866 logbuffer[size] = '\0';
1867 codec->stats_in = logbuffer;
1871 if(codec->codec_type == CODEC_TYPE_VIDEO){
1872 int size= codec->width * codec->height;
1873 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1878 bit_buffer = av_malloc(bit_buffer_size);
1882 /* dump the file output parameters - cannot be done before in case
1884 for(i=0;i<nb_output_files;i++) {
1885 dump_format(output_files[i], i, output_files[i]->filename, 1);
1888 /* dump the stream mapping */
1890 fprintf(stderr, "Stream mapping:\n");
1891 for(i=0;i<nb_ostreams;i++) {
1893 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1894 ist_table[ost->source_index]->file_index,
1895 ist_table[ost->source_index]->index,
1898 if (ost->sync_ist != ist_table[ost->source_index])
1899 fprintf(stderr, " [sync #%d.%d]",
1900 ost->sync_ist->file_index,
1901 ost->sync_ist->index);
1902 fprintf(stderr, "\n");
1906 /* open each encoder */
1907 for(i=0;i<nb_ostreams;i++) {
1909 if (ost->encoding_needed) {
1910 AVCodec *codec = output_codecs[i];
1912 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1914 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1915 ost->file_index, ost->index);
1918 if (avcodec_open(ost->st->codec, codec) < 0) {
1919 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1920 ost->file_index, ost->index);
1923 extra_size += ost->st->codec->extradata_size;
1927 /* open each decoder */
1928 for(i=0;i<nb_istreams;i++) {
1930 if (ist->decoding_needed) {
1931 AVCodec *codec = input_codecs[i];
1933 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1935 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1936 ist->st->codec->codec_id, ist->file_index, ist->index);
1939 if (avcodec_open(ist->st->codec, codec) < 0) {
1940 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1941 ist->file_index, ist->index);
1944 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1945 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1950 for(i=0;i<nb_istreams;i++) {
1952 is = input_files[ist->file_index];
1954 ist->next_pts = AV_NOPTS_VALUE;
1958 /* set meta data information from input file if required */
1959 for (i=0;i<nb_meta_data_maps;i++) {
1960 AVFormatContext *out_file;
1961 AVFormatContext *in_file;
1963 int out_file_index = meta_data_maps[i].out_file;
1964 int in_file_index = meta_data_maps[i].in_file;
1965 if (out_file_index < 0 || out_file_index >= nb_output_files) {
1966 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1967 ret = AVERROR(EINVAL);
1970 if (in_file_index < 0 || in_file_index >= nb_input_files) {
1971 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1972 ret = AVERROR(EINVAL);
1976 out_file = output_files[out_file_index];
1977 in_file = input_files[in_file_index];
1979 strcpy(out_file->title, in_file->title);
1980 strcpy(out_file->author, in_file->author);
1981 strcpy(out_file->copyright, in_file->copyright);
1982 strcpy(out_file->comment, in_file->comment);
1983 strcpy(out_file->album, in_file->album);
1984 out_file->year = in_file->year;
1985 out_file->track = in_file->track;
1986 strcpy(out_file->genre, in_file->genre);
1989 /* open files and write file headers */
1990 for(i=0;i<nb_output_files;i++) {
1991 os = output_files[i];
1992 if (av_write_header(os) < 0) {
1993 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1994 ret = AVERROR(EINVAL);
1997 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2002 print_sdp(output_files, nb_output_files);
2005 if (!using_stdin && verbose >= 0) {
2006 fprintf(stderr, "Press [q] to stop encoding\n");
2007 url_set_interrupt_cb(decode_interrupt_cb);
2012 timer_start = av_gettime();
2014 for(; received_sigterm == 0;) {
2015 int file_index, ist_index;
2023 /* if 'q' pressed, exits */
2027 /* read_key() returns 0 on EOF */
2033 /* select the stream that we must read now by looking at the
2034 smallest output pts */
2036 for(i=0;i<nb_ostreams;i++) {
2039 os = output_files[ost->file_index];
2040 ist = ist_table[ost->source_index];
2041 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2042 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2044 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2045 ipts = (double)ist->pts;
2046 if (!file_table[ist->file_index].eof_reached){
2047 if(ipts < ipts_min) {
2049 if(input_sync ) file_index = ist->file_index;
2051 if(opts < opts_min) {
2053 if(!input_sync) file_index = ist->file_index;
2056 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2061 /* if none, if is finished */
2062 if (file_index < 0) {
2066 /* finish if recording time exhausted */
2067 if (opts_min >= (recording_time / 1000000.0))
2070 /* finish if limit size exhausted */
2071 if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2074 /* read a frame from it and output it in the fifo */
2075 is = input_files[file_index];
2076 if (av_read_frame(is, &pkt) < 0) {
2077 file_table[file_index].eof_reached = 1;
2085 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2087 /* the following test is needed in case new streams appear
2088 dynamically in stream : we ignore them */
2089 if (pkt.stream_index >= file_table[file_index].nb_streams)
2090 goto discard_packet;
2091 ist_index = file_table[file_index].ist_index + pkt.stream_index;
2092 ist = ist_table[ist_index];
2094 goto discard_packet;
2096 if (pkt.dts != AV_NOPTS_VALUE)
2097 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2098 if (pkt.pts != AV_NOPTS_VALUE)
2099 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2101 if(input_files_ts_scale[file_index][pkt.stream_index]){
2102 if(pkt.pts != AV_NOPTS_VALUE)
2103 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2104 if(pkt.dts != AV_NOPTS_VALUE)
2105 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2108 // 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);
2109 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2110 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2111 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2112 int64_t delta= pkt_dts - ist->next_pts;
2113 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2114 input_files_ts_offset[ist->file_index]-= delta;
2116 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2117 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2118 if(pkt.pts != AV_NOPTS_VALUE)
2119 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2123 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2124 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2127 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2128 ist->file_index, ist->index);
2131 av_free_packet(&pkt);
2136 av_free_packet(&pkt);
2138 /* dump report by using the output first video and audio streams */
2139 print_report(output_files, ost_table, nb_ostreams, 0);
2142 /* at the end of stream, we must flush the decoder buffers */
2143 for(i=0;i<nb_istreams;i++) {
2145 if (ist->decoding_needed) {
2146 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2152 /* write the trailer if needed and close file */
2153 for(i=0;i<nb_output_files;i++) {
2154 os = output_files[i];
2155 av_write_trailer(os);
2158 /* dump report by using the first video and audio streams */
2159 print_report(output_files, ost_table, nb_ostreams, 1);
2161 /* close each encoder */
2162 for(i=0;i<nb_ostreams;i++) {
2164 if (ost->encoding_needed) {
2165 av_freep(&ost->st->codec->stats_in);
2166 avcodec_close(ost->st->codec);
2170 /* close each decoder */
2171 for(i=0;i<nb_istreams;i++) {
2173 if (ist->decoding_needed) {
2174 avcodec_close(ist->st->codec);
2182 av_freep(&bit_buffer);
2183 av_free(file_table);
2186 for(i=0;i<nb_istreams;i++) {
2193 for(i=0;i<nb_ostreams;i++) {
2197 fclose(ost->logfile);
2198 ost->logfile = NULL;
2200 av_fifo_free(&ost->fifo); /* works even if fifo is not
2201 initialized but set to zero */
2202 av_free(ost->pict_tmp.data[0]);
2203 if (ost->video_resample)
2204 sws_freeContext(ost->img_resample_ctx);
2206 audio_resample_close(ost->resample);
2207 if (ost->reformat_ctx)
2208 av_audio_convert_free(ost->reformat_ctx);
2216 ret = AVERROR(ENOMEM);
2221 int file_read(const char *filename)
2224 unsigned char buffer[1024];
2227 if (url_open(&h, filename, O_RDONLY) < 0) {
2228 printf("could not open '%s'\n", filename);
2232 len = url_read(h, buffer, sizeof(buffer));
2235 for(i=0;i<len;i++) putchar(buffer[i]);
2242 static void opt_format(const char *arg)
2244 /* compatibility stuff for pgmyuv */
2245 if (!strcmp(arg, "pgmyuv")) {
2246 pgmyuv_compatibility_hack=1;
2247 // opt_image_format(arg);
2249 fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2252 file_iformat = av_find_input_format(arg);
2253 file_oformat = guess_format(arg, NULL, NULL);
2254 if (!file_iformat && !file_oformat) {
2255 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2260 static void opt_video_rc_override_string(const char *arg)
2262 video_rc_override_string = arg;
2265 static int opt_me_threshold(const char *opt, const char *arg)
2267 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2271 static int opt_verbose(const char *opt, const char *arg)
2273 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2274 av_log_set_level(verbose);
2278 static int opt_frame_rate(const char *opt, const char *arg)
2280 if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2281 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2287 static int opt_bitrate(const char *opt, const char *arg)
2289 int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2291 opt_default(opt, arg);
2293 if (av_get_int(avctx_opts[codec_type], "b", NULL) < 1000)
2294 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2299 static void opt_frame_crop_top(const char *arg)
2301 frame_topBand = atoi(arg);
2302 if (frame_topBand < 0) {
2303 fprintf(stderr, "Incorrect top crop size\n");
2306 if ((frame_topBand % 2) != 0) {
2307 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2310 if ((frame_topBand) >= frame_height){
2311 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2314 frame_height -= frame_topBand;
2317 static void opt_frame_crop_bottom(const char *arg)
2319 frame_bottomBand = atoi(arg);
2320 if (frame_bottomBand < 0) {
2321 fprintf(stderr, "Incorrect bottom crop size\n");
2324 if ((frame_bottomBand % 2) != 0) {
2325 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2328 if ((frame_bottomBand) >= frame_height){
2329 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2332 frame_height -= frame_bottomBand;
2335 static void opt_frame_crop_left(const char *arg)
2337 frame_leftBand = atoi(arg);
2338 if (frame_leftBand < 0) {
2339 fprintf(stderr, "Incorrect left crop size\n");
2342 if ((frame_leftBand % 2) != 0) {
2343 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2346 if ((frame_leftBand) >= frame_width){
2347 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2350 frame_width -= frame_leftBand;
2353 static void opt_frame_crop_right(const char *arg)
2355 frame_rightBand = atoi(arg);
2356 if (frame_rightBand < 0) {
2357 fprintf(stderr, "Incorrect right crop size\n");
2360 if ((frame_rightBand % 2) != 0) {
2361 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2364 if ((frame_rightBand) >= frame_width){
2365 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2368 frame_width -= frame_rightBand;
2371 static void opt_frame_size(const char *arg)
2373 if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2374 fprintf(stderr, "Incorrect frame size\n");
2377 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2378 fprintf(stderr, "Frame size must be a multiple of 2\n");
2384 #define SCALEBITS 10
2385 #define ONE_HALF (1 << (SCALEBITS - 1))
2386 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2388 #define RGB_TO_Y(r, g, b) \
2389 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2390 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2392 #define RGB_TO_U(r1, g1, b1, shift)\
2393 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2394 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2396 #define RGB_TO_V(r1, g1, b1, shift)\
2397 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2398 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2400 static void opt_pad_color(const char *arg) {
2401 /* Input is expected to be six hex digits similar to
2402 how colors are expressed in html tags (but without the #) */
2403 int rgb = strtol(arg, NULL, 16);
2407 g = ((rgb >> 8) & 255);
2410 padcolor[0] = RGB_TO_Y(r,g,b);
2411 padcolor[1] = RGB_TO_U(r,g,b,0);
2412 padcolor[2] = RGB_TO_V(r,g,b,0);
2415 static void opt_frame_pad_top(const char *arg)
2417 frame_padtop = atoi(arg);
2418 if (frame_padtop < 0) {
2419 fprintf(stderr, "Incorrect top pad size\n");
2422 if ((frame_padtop % 2) != 0) {
2423 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2428 static void opt_frame_pad_bottom(const char *arg)
2430 frame_padbottom = atoi(arg);
2431 if (frame_padbottom < 0) {
2432 fprintf(stderr, "Incorrect bottom pad size\n");
2435 if ((frame_padbottom % 2) != 0) {
2436 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2442 static void opt_frame_pad_left(const char *arg)
2444 frame_padleft = atoi(arg);
2445 if (frame_padleft < 0) {
2446 fprintf(stderr, "Incorrect left pad size\n");
2449 if ((frame_padleft % 2) != 0) {
2450 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2456 static void opt_frame_pad_right(const char *arg)
2458 frame_padright = atoi(arg);
2459 if (frame_padright < 0) {
2460 fprintf(stderr, "Incorrect right pad size\n");
2463 if ((frame_padright % 2) != 0) {
2464 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2469 static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2473 for (i=-1; i < nb_fmts; i++) {
2474 get_fmt_string (fmt_str, sizeof(fmt_str), i);
2475 fprintf(stdout, "%s\n", fmt_str);
2479 static void opt_frame_pix_fmt(const char *arg)
2481 if (strcmp(arg, "list"))
2482 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2484 list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2489 static void opt_frame_aspect_ratio(const char *arg)
2496 p = strchr(arg, ':');
2498 x = strtol(arg, &end, 10);
2500 y = strtol(end+1, &end, 10);
2502 ar = (double)x / (double)y;
2504 ar = strtod(arg, NULL);
2507 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2510 frame_aspect_ratio = ar;
2513 static void opt_qscale(const char *arg)
2515 video_qscale = atof(arg);
2516 if (video_qscale <= 0 ||
2517 video_qscale > 255) {
2518 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2523 static void opt_top_field_first(const char *arg)
2525 top_field_first= atoi(arg);
2528 static int opt_thread_count(const char *opt, const char *arg)
2530 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2531 #if !defined(HAVE_THREADS)
2533 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2538 static void opt_audio_sample_fmt(const char *arg)
2540 if (strcmp(arg, "list"))
2541 audio_sample_fmt = avcodec_get_sample_fmt(arg);
2543 list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2548 static int opt_audio_rate(const char *opt, const char *arg)
2550 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2554 static int opt_audio_channels(const char *opt, const char *arg)
2556 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2560 static void opt_video_channel(const char *arg)
2562 video_channel = strtol(arg, NULL, 0);
2565 static void opt_video_standard(const char *arg)
2567 video_standard = av_strdup(arg);
2570 static void opt_codec(int *pstream_copy, char **pcodec_name,
2571 int codec_type, const char *arg)
2573 av_freep(pcodec_name);
2574 if (!strcmp(arg, "copy")) {
2577 *pcodec_name = av_strdup(arg);
2581 static void opt_audio_codec(const char *arg)
2583 opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2586 static void opt_audio_tag(const char *arg)
2589 audio_codec_tag= strtol(arg, &tail, 0);
2592 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2595 static void opt_video_tag(const char *arg)
2598 video_codec_tag= strtol(arg, &tail, 0);
2601 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2605 static void add_frame_hooker(const char *arg)
2610 char *args = av_strdup(arg);
2614 argv[0] = strtok(args, " ");
2615 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2618 i = frame_hook_add(argc, argv);
2621 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2627 static void opt_video_codec(const char *arg)
2629 opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2632 static void opt_subtitle_codec(const char *arg)
2634 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2637 static void opt_map(const char *arg)
2642 m = &stream_maps[nb_stream_maps++];
2644 m->file_index = strtol(arg, &p, 0);
2648 m->stream_index = strtol(p, &p, 0);
2651 m->sync_file_index = strtol(p, &p, 0);
2654 m->sync_stream_index = strtol(p, &p, 0);
2656 m->sync_file_index = m->file_index;
2657 m->sync_stream_index = m->stream_index;
2661 static void opt_map_meta_data(const char *arg)
2666 m = &meta_data_maps[nb_meta_data_maps++];
2668 m->out_file = strtol(arg, &p, 0);
2672 m->in_file = strtol(p, &p, 0);
2675 static void opt_input_ts_scale(const char *arg)
2677 unsigned int stream;
2681 stream = strtol(arg, &p, 0);
2684 scale= strtod(p, &p);
2686 if(stream >= MAX_STREAMS)
2689 input_files_ts_scale[nb_input_files][stream]= scale;
2692 static int opt_recording_time(const char *opt, const char *arg)
2694 recording_time = parse_time_or_die(opt, arg, 1);
2698 static int opt_start_time(const char *opt, const char *arg)
2700 start_time = parse_time_or_die(opt, arg, 1);
2704 static int opt_rec_timestamp(const char *opt, const char *arg)
2706 rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2710 static int opt_input_ts_offset(const char *opt, const char *arg)
2712 input_ts_offset = parse_time_or_die(opt, arg, 1);
2716 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2718 const char *codec_string = encoder ? "encoder" : "decoder";
2722 return CODEC_ID_NONE;
2724 avcodec_find_encoder_by_name(name) :
2725 avcodec_find_decoder_by_name(name);
2727 av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2730 if(codec->type != type) {
2731 av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2737 static void opt_input_file(const char *filename)
2739 AVFormatContext *ic;
2740 AVFormatParameters params, *ap = ¶ms;
2741 int err, i, ret, rfps, rfps_base;
2744 if (!strcmp(filename, "-"))
2747 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2748 !strcmp(filename, "/dev/stdin");
2750 /* get default parameters from command line */
2751 ic = av_alloc_format_context();
2753 memset(ap, 0, sizeof(*ap));
2754 ap->prealloced_context = 1;
2755 ap->sample_rate = audio_sample_rate;
2756 ap->channels = audio_channels;
2757 ap->time_base.den = frame_rate.num;
2758 ap->time_base.num = frame_rate.den;
2759 ap->width = frame_width + frame_padleft + frame_padright;
2760 ap->height = frame_height + frame_padtop + frame_padbottom;
2761 ap->pix_fmt = frame_pix_fmt;
2762 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2763 ap->channel = video_channel;
2764 ap->standard = video_standard;
2765 ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2766 ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2767 if(pgmyuv_compatibility_hack)
2768 ap->video_codec_id= CODEC_ID_PGMYUV;
2770 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2772 ic->video_codec_id = find_codec_or_die(video_codec_name , CODEC_TYPE_VIDEO , 0);
2773 ic->audio_codec_id = find_codec_or_die(audio_codec_name , CODEC_TYPE_AUDIO , 0);
2774 ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2776 /* open the input file with generic libav function */
2777 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2779 print_error(filename, err);
2784 for(i=0; i<ic->nb_programs; i++)
2785 if(ic->programs[i]->id != opt_programid)
2786 ic->programs[i]->discard = AVDISCARD_ALL;
2789 ic->loop_input = loop_input;
2791 /* If not enough info to get the stream parameters, we decode the
2792 first frames to get it. (used in mpeg case for example) */
2793 ret = av_find_stream_info(ic);
2794 if (ret < 0 && verbose >= 0) {
2795 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2799 timestamp = start_time;
2800 /* add the stream start time */
2801 if (ic->start_time != AV_NOPTS_VALUE)
2802 timestamp += ic->start_time;
2804 /* if seeking requested, we execute it */
2805 if (start_time != 0) {
2806 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2808 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2809 filename, (double)timestamp / AV_TIME_BASE);
2811 /* reset seek info */
2815 /* update the current parameters so that they match the one of the input stream */
2816 for(i=0;i<ic->nb_streams;i++) {
2817 AVCodecContext *enc = ic->streams[i]->codec;
2819 avcodec_thread_init(enc, thread_count);
2820 enc->thread_count= thread_count;
2821 switch(enc->codec_type) {
2822 case CODEC_TYPE_AUDIO:
2823 set_context_opts(enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2824 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2825 audio_channels = enc->channels;
2826 audio_sample_rate = enc->sample_rate;
2827 audio_sample_fmt = enc->sample_fmt;
2828 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
2830 ic->streams[i]->discard= AVDISCARD_ALL;
2832 case CODEC_TYPE_VIDEO:
2833 set_context_opts(enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2834 frame_height = enc->height;
2835 frame_width = enc->width;
2836 if(ic->streams[i]->sample_aspect_ratio.num)
2837 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
2839 frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
2840 frame_aspect_ratio *= (float) enc->width / enc->height;
2841 frame_pix_fmt = enc->pix_fmt;
2842 rfps = ic->streams[i]->r_frame_rate.num;
2843 rfps_base = ic->streams[i]->r_frame_rate.den;
2844 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2846 enc->debug |= FF_DEBUG_MV;
2848 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2851 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2852 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2854 (float)rfps / rfps_base, rfps, rfps_base);
2856 /* update the current frame rate to match the stream frame rate */
2857 frame_rate.num = rfps;
2858 frame_rate.den = rfps_base;
2860 enc->rate_emu = rate_emu;
2861 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2863 ic->streams[i]->discard= AVDISCARD_ALL;
2864 else if(video_discard)
2865 ic->streams[i]->discard= video_discard;
2867 case CODEC_TYPE_DATA:
2869 case CODEC_TYPE_SUBTITLE:
2870 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
2871 if(subtitle_disable)
2872 ic->streams[i]->discard = AVDISCARD_ALL;
2874 case CODEC_TYPE_ATTACHMENT:
2875 case CODEC_TYPE_UNKNOWN:
2883 input_files[nb_input_files] = ic;
2884 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2885 /* dump the file content */
2887 dump_format(ic, nb_input_files, filename, 0);
2890 file_iformat = NULL;
2891 file_oformat = NULL;
2896 av_freep(&video_codec_name);
2897 av_freep(&audio_codec_name);
2898 av_freep(&subtitle_codec_name);
2901 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2902 int *has_subtitle_ptr)
2904 int has_video, has_audio, has_subtitle, i, j;
2905 AVFormatContext *ic;
2910 for(j=0;j<nb_input_files;j++) {
2911 ic = input_files[j];
2912 for(i=0;i<ic->nb_streams;i++) {
2913 AVCodecContext *enc = ic->streams[i]->codec;
2914 switch(enc->codec_type) {
2915 case CODEC_TYPE_AUDIO:
2918 case CODEC_TYPE_VIDEO:
2921 case CODEC_TYPE_SUBTITLE:
2924 case CODEC_TYPE_DATA:
2925 case CODEC_TYPE_ATTACHMENT:
2926 case CODEC_TYPE_UNKNOWN:
2933 *has_video_ptr = has_video;
2934 *has_audio_ptr = has_audio;
2935 *has_subtitle_ptr = has_subtitle;
2938 static void new_video_stream(AVFormatContext *oc)
2941 AVCodecContext *video_enc;
2944 st = av_new_stream(oc, oc->nb_streams);
2946 fprintf(stderr, "Could not alloc stream\n");
2949 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2950 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2951 video_bitstream_filters= NULL;
2954 avcodec_thread_init(st->codec, thread_count);
2956 video_enc = st->codec;
2959 video_enc->codec_tag= video_codec_tag;
2961 if( (video_global_header&1)
2962 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2963 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2964 avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2966 if(video_global_header&2){
2967 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2968 avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2971 if (video_stream_copy) {
2972 st->stream_copy = 1;
2973 video_enc->codec_type = CODEC_TYPE_VIDEO;
2974 video_enc->sample_aspect_ratio =
2975 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
2980 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
2982 if (video_codec_name) {
2983 codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
2984 codec = avcodec_find_encoder_by_name(video_codec_name);
2985 output_codecs[nb_ocodecs] = codec;
2987 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2988 codec = avcodec_find_encoder(codec_id);
2991 video_enc->codec_id = codec_id;
2993 set_context_opts(video_enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
2995 if (codec && codec->supported_framerates && !force_fps)
2996 fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
2997 video_enc->time_base.den = fps.num;
2998 video_enc->time_base.num = fps.den;
3000 video_enc->width = frame_width + frame_padright + frame_padleft;
3001 video_enc->height = frame_height + frame_padtop + frame_padbottom;
3002 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3003 video_enc->pix_fmt = frame_pix_fmt;
3004 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3006 if(codec && codec->pix_fmts){
3007 const enum PixelFormat *p= codec->pix_fmts;
3009 if(*p == video_enc->pix_fmt)
3013 video_enc->pix_fmt = codec->pix_fmts[0];
3017 video_enc->gop_size = 0;
3018 if (video_qscale || same_quality) {
3019 video_enc->flags |= CODEC_FLAG_QSCALE;
3020 video_enc->global_quality=
3021 st->quality = FF_QP2LAMBDA * video_qscale;
3025 video_enc->intra_matrix = intra_matrix;
3027 video_enc->inter_matrix = inter_matrix;
3029 video_enc->thread_count = thread_count;
3030 p= video_rc_override_string;
3033 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3035 fprintf(stderr, "error parsing rc_override\n");
3038 video_enc->rc_override=
3039 av_realloc(video_enc->rc_override,
3040 sizeof(RcOverride)*(i+1));
3041 video_enc->rc_override[i].start_frame= start;
3042 video_enc->rc_override[i].end_frame = end;
3044 video_enc->rc_override[i].qscale= q;
3045 video_enc->rc_override[i].quality_factor= 1.0;
3048 video_enc->rc_override[i].qscale= 0;
3049 video_enc->rc_override[i].quality_factor= -q/100.0;
3054 video_enc->rc_override_count=i;
3055 if (!video_enc->rc_initial_buffer_occupancy)
3056 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3057 video_enc->me_threshold= me_threshold;
3058 video_enc->intra_dc_precision= intra_dc_precision - 8;
3061 video_enc->flags|= CODEC_FLAG_PSNR;
3066 video_enc->flags |= CODEC_FLAG_PASS1;
3068 video_enc->flags |= CODEC_FLAG_PASS2;
3074 /* reset some key parameters */
3076 av_freep(&video_codec_name);
3077 video_stream_copy = 0;
3080 static void new_audio_stream(AVFormatContext *oc)
3083 AVCodecContext *audio_enc;
3086 st = av_new_stream(oc, oc->nb_streams);
3088 fprintf(stderr, "Could not alloc stream\n");
3091 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3093 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3094 audio_bitstream_filters= NULL;
3097 avcodec_thread_init(st->codec, thread_count);
3099 audio_enc = st->codec;
3100 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3103 audio_enc->codec_tag= audio_codec_tag;
3105 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3106 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3107 avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3109 if (audio_stream_copy) {
3110 st->stream_copy = 1;
3111 audio_enc->channels = audio_channels;
3115 set_context_opts(audio_enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3117 if (audio_codec_name) {
3118 codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3119 codec = avcodec_find_encoder_by_name(audio_codec_name);
3120 output_codecs[nb_ocodecs] = codec;
3122 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3123 codec = avcodec_find_encoder(codec_id);
3125 audio_enc->codec_id = codec_id;
3127 if (audio_qscale > QSCALE_NONE) {
3128 audio_enc->flags |= CODEC_FLAG_QSCALE;
3129 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3131 audio_enc->thread_count = thread_count;
3132 audio_enc->channels = audio_channels;
3133 audio_enc->sample_fmt = audio_sample_fmt;
3135 if(codec && codec->sample_fmts){
3136 const enum SampleFormat *p= codec->sample_fmts;
3138 if(*p == audio_enc->sample_fmt)
3142 audio_enc->sample_fmt = codec->sample_fmts[0];
3146 audio_enc->sample_rate = audio_sample_rate;
3147 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3148 if (audio_language) {
3149 av_strlcpy(st->language, audio_language, sizeof(st->language));
3150 av_free(audio_language);
3151 audio_language = NULL;
3154 /* reset some key parameters */
3156 av_freep(&audio_codec_name);
3157 audio_stream_copy = 0;
3160 static void new_subtitle_stream(AVFormatContext *oc)
3163 AVCodecContext *subtitle_enc;
3165 st = av_new_stream(oc, oc->nb_streams);
3167 fprintf(stderr, "Could not alloc stream\n");
3170 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3172 bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3173 subtitle_bitstream_filters= NULL;
3175 subtitle_enc = st->codec;
3176 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3177 if (subtitle_stream_copy) {
3178 st->stream_copy = 1;
3180 set_context_opts(avctx_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3181 subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3182 output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3186 if (subtitle_language) {
3187 av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3188 av_free(subtitle_language);
3189 subtitle_language = NULL;
3192 subtitle_disable = 0;
3193 av_freep(&subtitle_codec_name);
3194 subtitle_stream_copy = 0;
3197 static void opt_new_audio_stream(void)
3199 AVFormatContext *oc;
3200 if (nb_output_files <= 0) {
3201 fprintf(stderr, "At least one output file must be specified\n");
3204 oc = output_files[nb_output_files - 1];
3205 new_audio_stream(oc);
3208 static void opt_new_video_stream(void)
3210 AVFormatContext *oc;
3211 if (nb_output_files <= 0) {
3212 fprintf(stderr, "At least one output file must be specified\n");
3215 oc = output_files[nb_output_files - 1];
3216 new_video_stream(oc);
3219 static void opt_new_subtitle_stream(void)
3221 AVFormatContext *oc;
3222 if (nb_output_files <= 0) {
3223 fprintf(stderr, "At least one output file must be specified\n");
3226 oc = output_files[nb_output_files - 1];
3227 new_subtitle_stream(oc);
3230 static void opt_output_file(const char *filename)
3232 AVFormatContext *oc;
3233 int use_video, use_audio, use_subtitle;
3234 int input_has_video, input_has_audio, input_has_subtitle;
3235 AVFormatParameters params, *ap = ¶ms;
3237 if (!strcmp(filename, "-"))
3240 oc = av_alloc_format_context();
3242 if (!file_oformat) {
3243 file_oformat = guess_format(NULL, filename, NULL);
3244 if (!file_oformat) {
3245 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3251 oc->oformat = file_oformat;
3252 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3254 if (!strcmp(file_oformat->name, "ffm") &&
3255 av_strstart(filename, "http:", NULL)) {
3256 /* special case for files sent to ffserver: we get the stream
3257 parameters from ffserver */
3258 int err = read_ffserver_streams(oc, filename);
3260 print_error(filename, err);
3264 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3265 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3266 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3268 /* disable if no corresponding type found and at least one
3270 if (nb_input_files > 0) {
3271 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3272 &input_has_subtitle);
3273 if (!input_has_video)
3275 if (!input_has_audio)
3277 if (!input_has_subtitle)
3281 /* manual disable */
3282 if (audio_disable) {
3285 if (video_disable) {
3288 if (subtitle_disable) {
3293 new_video_stream(oc);
3297 new_audio_stream(oc);
3301 new_subtitle_stream(oc);
3304 oc->timestamp = rec_timestamp;
3307 av_strlcpy(oc->title, str_title, sizeof(oc->title));
3309 av_strlcpy(oc->author, str_author, sizeof(oc->author));
3311 av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3313 av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3315 av_strlcpy(oc->album, str_album, sizeof(oc->album));
3317 av_strlcpy(oc->genre, str_genre, sizeof(oc->genre));
3320 output_files[nb_output_files++] = oc;
3322 /* check filename in case of an image number is expected */
3323 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3324 if (!av_filename_number_test(oc->filename)) {
3325 print_error(oc->filename, AVERROR_NUMEXPECTED);
3330 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3331 /* test if it already exists to avoid loosing precious files */
3332 if (!file_overwrite &&
3333 (strchr(filename, ':') == NULL ||
3334 filename[1] == ':' ||
3335 av_strstart(filename, "file:", NULL))) {
3336 if (url_exist(filename)) {
3340 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3343 if (toupper(c) != 'Y') {
3344 fprintf(stderr, "Not overwriting - exiting\n");
3349 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3356 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3357 fprintf(stderr, "Could not open '%s'\n", filename);
3362 memset(ap, 0, sizeof(*ap));
3363 if (av_set_parameters(oc, ap) < 0) {
3364 fprintf(stderr, "%s: Invalid encoding parameters\n",
3369 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3370 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3371 oc->loop_output = loop_output;
3373 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3375 /* reset some options */
3376 file_oformat = NULL;
3377 file_iformat = NULL;
3380 /* same option as mencoder */
3381 static void opt_pass(const char *pass_str)
3384 pass = atoi(pass_str);
3385 if (pass != 1 && pass != 2) {
3386 fprintf(stderr, "pass number can be only 1 or 2\n");
3392 static int64_t getutime(void)
3394 #ifdef HAVE_GETRUSAGE
3395 struct rusage rusage;
3397 getrusage(RUSAGE_SELF, &rusage);
3398 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3399 #elif defined(HAVE_GETPROCESSTIMES)
3401 FILETIME c, e, k, u;
3402 proc = GetCurrentProcess();
3403 GetProcessTimes(proc, &c, &e, &k, &u);
3404 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3406 return av_gettime();
3410 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3413 const char *p = str;
3420 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3427 static void opt_inter_matrix(const char *arg)
3429 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3430 parse_matrix_coeffs(inter_matrix, arg);
3433 static void opt_intra_matrix(const char *arg)
3435 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3436 parse_matrix_coeffs(intra_matrix, arg);
3440 * Trivial log callback.
3441 * Only suitable for show_help and similar since it lacks prefix handling.
3443 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3445 vfprintf(stdout, fmt, vl);
3448 static void show_help(void)
3450 av_log_set_callback(log_callback_help);
3451 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3452 "Hyper fast Audio and Video encoder\n");
3454 show_help_options(options, "Main options:\n",
3455 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3456 show_help_options(options, "\nAdvanced options:\n",
3457 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3459 show_help_options(options, "\nVideo options:\n",
3460 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3462 show_help_options(options, "\nAdvanced Video options:\n",
3463 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3464 OPT_VIDEO | OPT_EXPERT);
3465 show_help_options(options, "\nAudio options:\n",
3466 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3468 show_help_options(options, "\nAdvanced Audio options:\n",
3469 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3470 OPT_AUDIO | OPT_EXPERT);
3471 show_help_options(options, "\nSubtitle options:\n",
3472 OPT_SUBTITLE | OPT_GRAB,
3474 show_help_options(options, "\nAudio/Video grab options:\n",
3478 av_opt_show(avctx_opts[0], NULL);
3480 av_opt_show(avformat_opts, NULL);
3482 av_opt_show(sws_opts, NULL);
3485 static void opt_target(const char *arg)
3488 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3490 if(!strncmp(arg, "pal-", 4)) {
3493 } else if(!strncmp(arg, "ntsc-", 5)) {
3496 } else if(!strncmp(arg, "film-", 5)) {
3501 /* Calculate FR via float to avoid int overflow */
3502 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3505 } else if((fr == 29970) || (fr == 23976)) {
3508 /* Try to determine PAL/NTSC by peeking in the input files */
3509 if(nb_input_files) {
3511 for(j = 0; j < nb_input_files; j++) {
3512 for(i = 0; i < input_files[j]->nb_streams; i++) {
3513 AVCodecContext *c = input_files[j]->streams[i]->codec;
3514 if(c->codec_type != CODEC_TYPE_VIDEO)
3516 fr = c->time_base.den * 1000 / c->time_base.num;
3520 } else if((fr == 29970) || (fr == 23976)) {
3530 if(verbose && norm >= 0)
3531 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3535 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3536 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3537 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3541 if(!strcmp(arg, "vcd")) {
3543 opt_video_codec("mpeg1video");
3544 opt_audio_codec("mp2");
3547 opt_frame_size(norm ? "352x240" : "352x288");
3548 opt_frame_rate(NULL, frame_rates[norm]);
3549 opt_default("gop", norm ? "18" : "15");
3551 opt_default("b", "1150000");
3552 opt_default("maxrate", "1150000");
3553 opt_default("minrate", "1150000");
3554 opt_default("bufsize", "327680"); // 40*1024*8;
3556 opt_default("ab", "224000");
3557 audio_sample_rate = 44100;
3560 opt_default("packetsize", "2324");
3561 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3563 /* We have to offset the PTS, so that it is consistent with the SCR.
3564 SCR starts at 36000, but the first two packs contain only padding
3565 and the first pack from the other stream, respectively, may also have
3566 been written before.
3567 So the real data starts at SCR 36000+3*1200. */
3568 mux_preload= (36000+3*1200) / 90000.0; //0.44
3569 } else if(!strcmp(arg, "svcd")) {
3571 opt_video_codec("mpeg2video");
3572 opt_audio_codec("mp2");
3575 opt_frame_size(norm ? "480x480" : "480x576");
3576 opt_frame_rate(NULL, frame_rates[norm]);
3577 opt_default("gop", norm ? "18" : "15");
3579 opt_default("b", "2040000");
3580 opt_default("maxrate", "2516000");
3581 opt_default("minrate", "0"); //1145000;
3582 opt_default("bufsize", "1835008"); //224*1024*8;
3583 opt_default("flags", "+scan_offset");
3586 opt_default("ab", "224000");
3587 audio_sample_rate = 44100;
3589 opt_default("packetsize", "2324");
3591 } else if(!strcmp(arg, "dvd")) {
3593 opt_video_codec("mpeg2video");
3594 opt_audio_codec("ac3");
3597 opt_frame_size(norm ? "720x480" : "720x576");
3598 opt_frame_rate(NULL, frame_rates[norm]);
3599 opt_default("gop", norm ? "18" : "15");
3601 opt_default("b", "6000000");
3602 opt_default("maxrate", "9000000");
3603 opt_default("minrate", "0"); //1500000;
3604 opt_default("bufsize", "1835008"); //224*1024*8;
3606 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3607 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3609 opt_default("ab", "448000");
3610 audio_sample_rate = 48000;
3612 } else if(!strncmp(arg, "dv", 2)) {
3616 opt_frame_size(norm ? "720x480" : "720x576");
3617 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3618 (norm ? "yuv411p" : "yuv420p"));
3619 opt_frame_rate(NULL, frame_rates[norm]);
3621 audio_sample_rate = 48000;
3625 fprintf(stderr, "Unknown target: %s\n", arg);
3630 static void opt_vstats_file (const char *arg)
3632 av_free (vstats_filename);
3633 vstats_filename=av_strdup (arg);
3636 static void opt_vstats (void)
3639 time_t today2 = time(NULL);
3640 struct tm *today = localtime(&today2);
3642 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3644 opt_vstats_file(filename);
3647 static int opt_bsf(const char *opt, const char *arg)
3649 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3650 AVBitStreamFilterContext **bsfp;
3653 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3657 bsfp= *opt == 'v' ? &video_bitstream_filters :
3658 *opt == 'a' ? &audio_bitstream_filters :
3659 &subtitle_bitstream_filters;
3661 bsfp= &(*bsfp)->next;
3668 static int opt_preset(const char *opt, const char *arg)
3671 char filename[1000], tmp[1000], tmp2[1000], line[1000];
3673 const char *base[3]= { getenv("HOME"),
3678 for(i=!base[0]; i<3 && !f; i++){
3679 snprintf(filename, sizeof(filename), "%s/%sffmpeg/%s.ffpreset", base[i], i ? "" : ".", arg);
3680 f= fopen(filename, "r");
3682 char *codec_name= *opt == 'v' ? video_codec_name :
3683 *opt == 'a' ? audio_codec_name :
3684 subtitle_codec_name;
3685 snprintf(filename, sizeof(filename), "%s/%sffmpeg/%s-%s.ffpreset", base[i], i ? "" : ".", codec_name, arg);
3686 f= fopen(filename, "r");
3689 if(!f && ((arg[0]=='.' && arg[1]=='/') || arg[0]=='/' ||
3691 snprintf(filename, sizeof(filename), arg);
3692 f= fopen(filename, "r");
3696 fprintf(stderr, "File for preset '%s' not found\n", arg);
3701 int e= fscanf(f, "%999[^\n]\n", line) - 1;
3702 if(line[0] == '#' && !e)
3704 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3706 fprintf(stderr, "%s: Preset file invalid\n", filename);
3709 if(!strcmp(tmp, "acodec")){
3710 opt_audio_codec(tmp2);
3711 }else if(!strcmp(tmp, "vcodec")){
3712 opt_video_codec(tmp2);
3713 }else if(!strcmp(tmp, "scodec")){
3714 opt_subtitle_codec(tmp2);
3715 }else if(opt_default(tmp, tmp2) < 0){
3716 fprintf(stderr, "%s: Invalid option or argument: %s=%s\n", filename, tmp, tmp2);
3726 static const OptionDef options[] = {
3728 { "L", OPT_EXIT, {(void*)show_license}, "show license" },
3729 { "h", OPT_EXIT, {(void*)show_help}, "show help" },
3730 { "version", OPT_EXIT, {(void*)show_version}, "show version" },
3731 { "formats", OPT_EXIT, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3732 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3733 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3734 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3735 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3736 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3737 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3738 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3739 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3740 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3741 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
3742 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3743 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3744 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3745 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3746 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3747 { "genre", HAS_ARG | OPT_STRING, {(void*)&str_genre}, "set the genre", "string" },
3748 { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3749 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3750 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3751 "add timings for benchmarking" },
3752 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3753 "dump each input packet" },
3754 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3755 "when dumping packets, also dump the payload" },
3756 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3757 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3758 { "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)", "" },
3759 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set the logging verbosity level", "number" },
3760 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3761 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3762 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3763 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3764 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3765 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3766 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3767 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3768 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3769 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3770 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
3773 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3774 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3775 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3776 { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3777 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3778 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3779 { "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" },
3780 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3781 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3782 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3783 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3784 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3785 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3786 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3787 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3788 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3789 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3790 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3791 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3792 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3793 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3794 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3795 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
3796 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3797 "use same video quality as source (implies VBR)" },
3798 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3799 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3800 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3801 "deinterlace pictures" },
3802 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3803 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3804 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3806 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3808 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3809 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3810 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3811 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3812 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3813 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3814 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3815 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
3818 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3819 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3820 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3821 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3822 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3823 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3824 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3825 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3826 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3827 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3828 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3829 { "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" },
3831 /* subtitle options */
3832 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3833 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3834 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3835 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3838 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3839 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3840 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3843 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3844 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3846 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3847 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3848 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3850 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3851 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3852 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3854 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3858 int main(int argc, char **argv)
3863 avcodec_register_all();
3864 avdevice_register_all();
3867 if(isatty(STDIN_FILENO))
3868 url_set_interrupt_cb(decode_interrupt_cb);
3870 for(i=0; i<CODEC_TYPE_NB; i++){
3871 avctx_opts[i]= avcodec_alloc_context2(i);
3873 avformat_opts = av_alloc_format_context();
3874 sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3883 parse_options(argc, argv, options, opt_output_file);
3885 /* file converter / grab */
3886 if (nb_output_files <= 0) {
3887 fprintf(stderr, "Must supply at least one output file\n");
3891 if (nb_input_files == 0) {
3892 fprintf(stderr, "Must supply at least one input file\n");
3897 av_encode(output_files, nb_output_files, input_files, nb_input_files,
3898 stream_maps, nb_stream_maps);
3899 ti = getutime() - ti;
3901 printf("bench: utime=%0.3fs\n", ti / 1000000.0);