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 500
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 #if defined(HAVE_TERMIOS_H)
53 #include <sys/ioctl.h>
56 #elif defined(HAVE_CONIO_H)
59 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
69 const char program_name[] = "FFmpeg";
70 const int program_birth_year = 2000;
72 /* select an input stream for an output stream */
73 typedef struct AVStreamMap {
77 int sync_stream_index;
80 /** select an input file for an output file */
81 typedef struct AVMetaDataMap {
86 static const OptionDef options[];
90 static AVFormatContext *input_files[MAX_FILES];
91 static int64_t input_files_ts_offset[MAX_FILES];
92 static double input_files_ts_scale[MAX_FILES][MAX_STREAMS];
93 static int nb_input_files = 0;
95 static AVFormatContext *output_files[MAX_FILES];
96 static int nb_output_files = 0;
98 static AVStreamMap stream_maps[MAX_FILES*MAX_STREAMS];
99 static int nb_stream_maps;
101 static AVMetaDataMap meta_data_maps[MAX_FILES];
102 static int nb_meta_data_maps;
104 static AVInputFormat *file_iformat;
105 static AVOutputFormat *file_oformat;
106 static int frame_width = 0;
107 static int frame_height = 0;
108 static float frame_aspect_ratio = 0;
109 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
110 static enum SampleFormat audio_sample_fmt = SAMPLE_FMT_NONE;
111 static int frame_padtop = 0;
112 static int frame_padbottom = 0;
113 static int frame_padleft = 0;
114 static int frame_padright = 0;
115 static int padcolor[3] = {16,128,128}; /* default to black */
116 static int frame_topBand = 0;
117 static int frame_bottomBand = 0;
118 static int frame_leftBand = 0;
119 static int frame_rightBand = 0;
120 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
121 static AVRational frame_rate;
122 static float video_qscale = 0;
123 static uint16_t *intra_matrix = NULL;
124 static uint16_t *inter_matrix = NULL;
125 #if 0 //experimental, (can be removed)
126 static float video_rc_qsquish=1.0;
127 static float video_rc_qmod_amp=0;
128 static int video_rc_qmod_freq=0;
130 static const char *video_rc_override_string=NULL;
131 static int video_disable = 0;
132 static int video_discard = 0;
133 static char *video_codec_name = NULL;
134 static int video_codec_tag = 0;
135 static int same_quality = 0;
136 static int do_deinterlace = 0;
137 static int top_field_first = -1;
138 static int me_threshold = 0;
139 static int intra_dc_precision = 8;
140 static int loop_input = 0;
141 static int loop_output = AVFMT_NOOUTPUTLOOP;
142 static int qp_hist = 0;
144 static int intra_only = 0;
145 static int audio_sample_rate = 44100;
146 #define QSCALE_NONE -99999
147 static float audio_qscale = QSCALE_NONE;
148 static int audio_disable = 0;
149 static int audio_channels = 1;
150 static char *audio_codec_name = NULL;
151 static int audio_codec_tag = 0;
152 static char *audio_language = NULL;
154 static int subtitle_disable = 0;
155 static char *subtitle_codec_name = NULL;
156 static char *subtitle_language = NULL;
158 static float mux_preload= 0.5;
159 static float mux_max_delay= 0.7;
161 static int64_t recording_time = INT64_MAX;
162 static int64_t start_time = 0;
163 static int64_t rec_timestamp = 0;
164 static int64_t input_ts_offset = 0;
165 static int file_overwrite = 0;
166 static char *str_title = NULL;
167 static char *str_author = NULL;
168 static char *str_copyright = NULL;
169 static char *str_comment = NULL;
170 static char *str_genre = NULL;
171 static char *str_album = NULL;
172 static int do_benchmark = 0;
173 static int do_hex_dump = 0;
174 static int do_pkt_dump = 0;
175 static int do_psnr = 0;
176 static int do_pass = 0;
177 static char *pass_logfilename = NULL;
178 static int audio_stream_copy = 0;
179 static int video_stream_copy = 0;
180 static int subtitle_stream_copy = 0;
181 static int video_sync_method= -1;
182 static int audio_sync_method= 0;
183 static float audio_drift_threshold= 0.1;
184 static int copy_ts= 0;
185 static int opt_shortest = 0; //
186 static int video_global_header = 0;
187 static char *vstats_filename;
188 static FILE *vstats_file;
189 static int opt_programid = 0;
191 static int rate_emu = 0;
193 static int video_channel = 0;
194 static char *video_standard;
196 static int audio_volume = 256;
198 static int using_stdin = 0;
199 static int using_vhook = 0;
200 static int verbose = 1;
201 static int thread_count= 1;
202 static int q_pressed = 0;
203 static int64_t video_size = 0;
204 static int64_t audio_size = 0;
205 static int64_t extra_size = 0;
206 static int nb_frames_dup = 0;
207 static int nb_frames_drop = 0;
208 static int input_sync;
209 static uint64_t limit_filesize = 0; //
211 static int pgmyuv_compatibility_hack=0;
212 static float dts_delta_threshold = 10;
214 static unsigned int sws_flags = SWS_BICUBIC;
216 static const char **opt_names;
217 static int opt_name_count;
218 static AVCodecContext *avctx_opts[CODEC_TYPE_NB];
219 static AVFormatContext *avformat_opts;
220 static struct SwsContext *sws_opts;
221 static int64_t timer_start;
223 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
224 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
225 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
226 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
228 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
230 struct AVInputStream;
232 typedef struct AVOutputStream {
233 int file_index; /* file index */
234 int index; /* stream index in the output file */
235 int source_index; /* AVInputStream index */
236 AVStream *st; /* stream in the output file */
237 int encoding_needed; /* true if encoding needed for this stream */
239 /* input pts and corresponding output pts
241 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
242 struct AVInputStream *sync_ist; /* input stream to sync against */
243 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
246 AVFrame pict_tmp; /* temporary image for resampling */
247 struct SwsContext *img_resample_ctx; /* for image resampling */
251 int topBand; /* cropping area sizes */
255 int padtop; /* padding area sizes */
262 ReSampleContext *resample; /* for audio resampling */
264 AVAudioConvert *reformat_ctx;
265 AVFifoBuffer fifo; /* for compression: one audio fifo per codec */
269 typedef struct AVInputStream {
273 int discard; /* true if stream data should be discarded */
274 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
275 int64_t sample_index; /* current sample */
277 int64_t start; /* time when read started */
278 unsigned long frame; /* current frame */
279 int64_t next_pts; /* synthetic pts for cases where pkt.pts
281 int64_t pts; /* current pts */
282 int is_start; /* is 1 at the start and after a discontinuity */
285 typedef struct AVInputFile {
286 int eof_reached; /* true if eof reached */
287 int ist_index; /* index of first stream in ist_table */
288 int buffer_size; /* current total buffer size */
289 int nb_streams; /* nb streams we are aware of */
292 #ifdef HAVE_TERMIOS_H
294 /* init terminal so that we can grab keys */
295 static struct termios oldtty;
298 static void term_exit(void)
300 #ifdef HAVE_TERMIOS_H
301 tcsetattr (0, TCSANOW, &oldtty);
305 static volatile sig_atomic_t received_sigterm = 0;
308 sigterm_handler(int sig)
310 received_sigterm = sig;
314 static void term_init(void)
316 #ifdef HAVE_TERMIOS_H
322 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
323 |INLCR|IGNCR|ICRNL|IXON);
324 tty.c_oflag |= OPOST;
325 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
326 tty.c_cflag &= ~(CSIZE|PARENB);
331 tcsetattr (0, TCSANOW, &tty);
332 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
335 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
336 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
338 register a function to be called at normal program termination
341 #ifdef CONFIG_BEOS_NETSERVER
342 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
346 /* read a key without blocking */
347 static int read_key(void)
349 #if defined(HAVE_TERMIOS_H)
352 #ifndef CONFIG_BEOS_NETSERVER
360 n = select(1, &rfds, NULL, NULL, &tv);
369 #elif defined(HAVE_CONIO_H)
376 static int decode_interrupt_cb(void)
378 return q_pressed || (q_pressed = read_key() == 'q');
381 static int av_exit(int ret)
386 for(i=0;i<nb_output_files;i++) {
387 /* maybe av_close_output_file ??? */
388 AVFormatContext *s = output_files[i];
390 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
392 for(j=0;j<s->nb_streams;j++) {
393 av_free(s->streams[j]->codec);
394 av_free(s->streams[j]);
398 for(i=0;i<nb_input_files;i++)
399 av_close_input_file(input_files[i]);
401 av_free(intra_matrix);
402 av_free(inter_matrix);
406 av_free(vstats_filename);
410 av_free(video_codec_name);
411 av_free(audio_codec_name);
412 av_free(subtitle_codec_name);
414 av_free(video_standard);
416 #ifdef CONFIG_POWERPC_PERF
417 extern void powerpc_display_perf_report(void);
418 powerpc_display_perf_report();
419 #endif /* CONFIG_POWERPC_PERF */
421 if (received_sigterm) {
423 "Received signal %d: terminating.\n",
424 (int) received_sigterm);
428 exit(ret); /* not all OS-es handle main() return value */
432 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
438 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
441 /* copy stream format */
442 s->nb_streams = ic->nb_streams;
443 for(i=0;i<ic->nb_streams;i++) {
446 // FIXME: a more elegant solution is needed
447 st = av_mallocz(sizeof(AVStream));
448 memcpy(st, ic->streams[i], sizeof(AVStream));
449 st->codec = avcodec_alloc_context();
450 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
453 if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
455 else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
458 if(!st->codec->thread_count)
459 st->codec->thread_count = 1;
460 if(st->codec->thread_count>1)
461 avcodec_thread_init(st->codec, st->codec->thread_count);
463 if(st->codec->flags & CODEC_FLAG_BITEXACT)
468 s->timestamp = av_gettime();
470 av_close_input_file(ic);
475 get_sync_ipts(const AVOutputStream *ost)
477 const AVInputStream *ist = ost->sync_ist;
478 return (double)(ist->pts - start_time)/AV_TIME_BASE;
481 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
485 AVPacket new_pkt= *pkt;
486 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
487 &new_pkt.data, &new_pkt.size,
488 pkt->data, pkt->size,
489 pkt->flags & PKT_FLAG_KEY);
492 new_pkt.destruct= av_destruct_packet;
494 fprintf(stderr, "%s failed for stream %d, codec %s",
495 bsfc->filter->name, pkt->stream_index,
496 avctx->codec ? avctx->codec->name : "copy");
504 ret= av_interleaved_write_frame(s, pkt);
506 print_error("av_interleaved_write_frame()", ret);
511 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
513 static void do_audio_out(AVFormatContext *s,
516 unsigned char *buf, int size)
519 static uint8_t *audio_buf = NULL;
520 static uint8_t *audio_out = NULL;
521 static uint8_t *audio_out2 = NULL;
522 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
524 int size_out, frame_bytes, ret;
525 AVCodecContext *enc= ost->st->codec;
526 AVCodecContext *dec= ist->st->codec;
528 /* SC: dynamic allocation of buffers */
530 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
532 audio_out = av_malloc(audio_out_size);
533 if (!audio_buf || !audio_out)
534 return; /* Should signal an error ! */
536 if (enc->channels != dec->channels)
537 ost->audio_resample = 1;
539 if (ost->audio_resample && !ost->resample) {
540 ost->resample = audio_resample_init(enc->channels, dec->channels,
541 enc->sample_rate, dec->sample_rate);
542 if (!ost->resample) {
543 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
544 dec->channels, dec->sample_rate,
545 enc->channels, enc->sample_rate);
550 #define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
551 if (dec->sample_fmt!=enc->sample_fmt &&
552 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
554 audio_out2 = av_malloc(audio_out_size);
557 if (ost->reformat_ctx)
558 av_audio_convert_free(ost->reformat_ctx);
559 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
560 dec->sample_fmt, 1, NULL, 0);
561 if (!ost->reformat_ctx) {
562 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
563 avcodec_get_sample_fmt_name(dec->sample_fmt),
564 avcodec_get_sample_fmt_name(enc->sample_fmt));
567 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
570 if(audio_sync_method){
571 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
572 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
573 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
574 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
576 //FIXME resample delay
577 if(fabs(delta) > 50){
578 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
580 byte_delta= FFMAX(byte_delta, -size);
584 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
589 static uint8_t *input_tmp= NULL;
590 input_tmp= av_realloc(input_tmp, byte_delta + size);
592 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
595 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
597 memset(input_tmp, 0, byte_delta);
598 memcpy(input_tmp + byte_delta, buf, size);
602 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
604 }else if(audio_sync_method>1){
605 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
606 assert(ost->audio_resample);
608 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
609 // 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));
610 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
614 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
615 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
617 if (ost->audio_resample) {
619 size_out = audio_resample(ost->resample,
620 (short *)buftmp, (short *)buf,
621 size / (ist->st->codec->channels * 2));
622 size_out = size_out * enc->channels * 2;
628 if (dec->sample_fmt!=enc->sample_fmt) {
629 const void *ibuf[6]= {buftmp};
630 void *obuf[6]= {audio_out2};
631 int istride[6]= {av_get_bits_per_sample_format(dec->sample_fmt)/8};
632 int ostride[6]= {av_get_bits_per_sample_format(enc->sample_fmt)/8};
633 int len= size_out/istride[0];
634 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
635 printf("av_audio_convert() failed\n");
639 /* FIXME: existing code assume that size_out equals framesize*channels*2
640 remove this legacy cruft */
644 /* now encode as many frames as possible */
645 if (enc->frame_size > 1) {
646 /* output resampled raw samples */
647 av_fifo_realloc(&ost->fifo, av_fifo_size(&ost->fifo) + size_out);
648 av_fifo_generic_write(&ost->fifo, buftmp, size_out, NULL);
650 frame_bytes = enc->frame_size * 2 * enc->channels;
652 while (av_fifo_size(&ost->fifo) >= frame_bytes) {
654 av_init_packet(&pkt);
656 av_fifo_read(&ost->fifo, audio_buf, frame_bytes);
658 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
660 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
663 pkt.stream_index= ost->index;
666 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
667 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
668 pkt.flags |= PKT_FLAG_KEY;
669 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
671 ost->sync_opts += enc->frame_size;
675 av_init_packet(&pkt);
677 ost->sync_opts += size_out / (2 * enc->channels);
679 /* output a pcm frame */
680 /* XXX: change encoding codec API to avoid this ? */
681 switch(enc->codec->id) {
682 case CODEC_ID_PCM_S32LE:
683 case CODEC_ID_PCM_S32BE:
684 case CODEC_ID_PCM_U32LE:
685 case CODEC_ID_PCM_U32BE:
686 case CODEC_ID_PCM_F32BE:
687 size_out = size_out << 1;
689 case CODEC_ID_PCM_S24LE:
690 case CODEC_ID_PCM_S24BE:
691 case CODEC_ID_PCM_U24LE:
692 case CODEC_ID_PCM_U24BE:
693 case CODEC_ID_PCM_S24DAUD:
694 size_out = size_out / 2 * 3;
696 case CODEC_ID_PCM_S16LE:
697 case CODEC_ID_PCM_S16BE:
698 case CODEC_ID_PCM_U16LE:
699 case CODEC_ID_PCM_U16BE:
702 size_out = size_out >> 1;
705 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
706 ret = avcodec_encode_audio(enc, audio_out, size_out,
709 pkt.stream_index= ost->index;
712 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
713 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
714 pkt.flags |= PKT_FLAG_KEY;
715 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
719 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
723 AVPicture picture_tmp;
726 dec = ist->st->codec;
728 /* deinterlace : must be done before any resize */
729 if (do_deinterlace || using_vhook) {
732 /* create temporary picture */
733 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
734 buf = av_malloc(size);
738 picture2 = &picture_tmp;
739 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
742 if(avpicture_deinterlace(picture2, picture,
743 dec->pix_fmt, dec->width, dec->height) < 0) {
744 /* if error, do not deinterlace */
750 av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
757 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,
758 1000000 * ist->pts / AV_TIME_BASE);
760 if (picture != picture2)
761 *picture = *picture2;
765 /* we begin to correct av delay at this threshold */
766 #define AV_DELAY_MAX 0.100
768 static void do_subtitle_out(AVFormatContext *s,
774 static uint8_t *subtitle_out = NULL;
775 int subtitle_out_max_size = 65536;
776 int subtitle_out_size, nb, i;
780 if (pts == AV_NOPTS_VALUE) {
781 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");
877 formatted_picture = &picture_crop_temp;
879 formatted_picture = in_picture;
882 final_picture = formatted_picture;
883 padding_src = formatted_picture;
884 resampling_dst = &ost->pict_tmp;
885 if (ost->video_pad) {
886 final_picture = &ost->pict_tmp;
887 if (ost->video_resample) {
888 if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
889 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
892 resampling_dst = &picture_pad_temp;
896 if (ost->video_resample) {
898 final_picture = &ost->pict_tmp;
899 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
900 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
903 if (ost->video_pad) {
904 av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
905 enc->height, enc->width, enc->pix_fmt,
906 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
909 /* duplicates frame if needed */
910 for(i=0;i<nb_frames;i++) {
912 av_init_packet(&pkt);
913 pkt.stream_index= ost->index;
915 if (s->oformat->flags & AVFMT_RAWPICTURE) {
916 /* raw pictures are written as AVPicture structure to
917 avoid any copies. We support temorarily the older
919 AVFrame* old_frame = enc->coded_frame;
920 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
921 pkt.data= (uint8_t *)final_picture;
922 pkt.size= sizeof(AVPicture);
923 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
924 pkt.flags |= PKT_FLAG_KEY;
926 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
927 enc->coded_frame = old_frame;
931 big_picture= *final_picture;
932 /* better than nothing: use input picture interlaced
934 big_picture.interlaced_frame = in_picture->interlaced_frame;
935 if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
936 if(top_field_first == -1)
937 big_picture.top_field_first = in_picture->top_field_first;
939 big_picture.top_field_first = top_field_first;
942 /* handles sameq here. This is not correct because it may
943 not be a global option */
945 big_picture.quality = ist->st->quality;
947 big_picture.quality = ost->st->quality;
949 big_picture.pict_type = 0;
950 // big_picture.pts = AV_NOPTS_VALUE;
951 big_picture.pts= ost->sync_opts;
952 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
953 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
954 ret = avcodec_encode_video(enc,
955 bit_buffer, bit_buffer_size,
958 fprintf(stderr, "Video encoding failed\n");
961 //enc->frame_number = enc->real_pict_num;
963 pkt.data= bit_buffer;
965 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
966 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
967 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
968 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
969 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
971 if(enc->coded_frame->key_frame)
972 pkt.flags |= PKT_FLAG_KEY;
973 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
976 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
977 // enc->frame_number-1, enc->real_pict_num, ret,
979 /* if two pass, output log */
980 if (ost->logfile && enc->stats_out) {
981 fprintf(ost->logfile, "%s", enc->stats_out);
990 static double psnr(double d){
991 return -10.0*log(d)/log(10.0);
994 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
999 double ti1, bitrate, avg_bitrate;
1001 /* this is executed just the first time do_video_stats is called */
1003 vstats_file = fopen(vstats_filename, "w");
1010 enc = ost->st->codec;
1011 if (enc->codec_type == CODEC_TYPE_VIDEO) {
1012 frame_number = ost->frame_number;
1013 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1014 if (enc->flags&CODEC_FLAG_PSNR)
1015 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1017 fprintf(vstats_file,"f_size= %6d ", frame_size);
1018 /* compute pts value */
1019 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1023 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1024 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1025 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1026 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1027 fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1031 static void print_report(AVFormatContext **output_files,
1032 AVOutputStream **ost_table, int nb_ostreams,
1036 AVOutputStream *ost;
1037 AVFormatContext *oc, *os;
1039 AVCodecContext *enc;
1040 int frame_number, vid, i;
1041 double bitrate, ti1, pts;
1042 static int64_t last_time = -1;
1043 static int qp_histogram[52];
1045 if (!is_last_report) {
1047 /* display the report every 0.5 seconds */
1048 cur_time = av_gettime();
1049 if (last_time == -1) {
1050 last_time = cur_time;
1053 if ((cur_time - last_time) < 500000)
1055 last_time = cur_time;
1059 oc = output_files[0];
1061 total_size = url_fsize(oc->pb);
1062 if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1063 total_size= url_ftell(oc->pb);
1068 for(i=0;i<nb_ostreams;i++) {
1070 os = output_files[ost->file_index];
1071 enc = ost->st->codec;
1072 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1073 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1074 !ost->st->stream_copy ?
1075 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1077 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1078 float t = (av_gettime()-timer_start) / 1000000.0;
1080 frame_number = ost->frame_number;
1081 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1082 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1083 !ost->st->stream_copy ?
1084 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1086 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1089 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1090 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
1093 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1095 if (enc->flags&CODEC_FLAG_PSNR){
1097 double error, error_sum=0;
1098 double scale, scale_sum=0;
1099 char type[3]= {'Y','U','V'};
1100 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1103 error= enc->error[j];
1104 scale= enc->width*enc->height*255.0*255.0*frame_number;
1106 error= enc->coded_frame->error[j];
1107 scale= enc->width*enc->height*255.0*255.0;
1112 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1114 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1118 /* compute min output value */
1119 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1120 if ((pts < ti1) && (pts > 0))
1126 if (verbose || is_last_report) {
1127 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1129 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1130 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1131 (double)total_size / 1024, ti1, bitrate);
1134 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1135 nb_frames_dup, nb_frames_drop);
1138 fprintf(stderr, "%s \r", buf);
1143 if (is_last_report && verbose >= 0){
1144 int64_t raw= audio_size + video_size + extra_size;
1145 fprintf(stderr, "\n");
1146 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1150 100.0*(total_size - raw)/raw
1155 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1156 static int output_packet(AVInputStream *ist, int ist_index,
1157 AVOutputStream **ost_table, int nb_ostreams,
1158 const AVPacket *pkt)
1160 AVFormatContext *os;
1161 AVOutputStream *ost;
1165 int data_size, got_picture;
1167 void *buffer_to_free;
1168 static unsigned int samples_size= 0;
1169 static short *samples= NULL;
1170 AVSubtitle subtitle, *subtitle_to_free;
1173 if(ist->next_pts == AV_NOPTS_VALUE)
1174 ist->next_pts= ist->pts;
1183 if(pkt->dts != AV_NOPTS_VALUE)
1184 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1189 //while we have more to decode or while the decoder did output something on EOF
1190 while (len > 0 || (!pkt && ist->next_pts != ist->pts)) {
1192 ist->pts= ist->next_pts;
1194 if(len && len != pkt->size && verbose>0)
1195 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1197 /* decode the packet if needed */
1198 data_buf = NULL; /* fail safe */
1200 subtitle_to_free = NULL;
1201 if (ist->decoding_needed) {
1202 switch(ist->st->codec->codec_type) {
1203 case CODEC_TYPE_AUDIO:{
1204 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1205 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1207 samples= av_malloc(samples_size);
1209 data_size= samples_size;
1210 /* XXX: could avoid copy if PCM 16 bits with same
1211 endianness as CPU */
1212 ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1218 /* Some bug in mpeg audio decoder gives */
1219 /* data_size < 0, it seems they are overflows */
1220 if (data_size <= 0) {
1221 /* no audio frame */
1224 data_buf = (uint8_t *)samples;
1225 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1226 (ist->st->codec->sample_rate * ist->st->codec->channels);
1228 case CODEC_TYPE_VIDEO:
1229 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1230 /* XXX: allocate picture correctly */
1231 avcodec_get_frame_defaults(&picture);
1233 ret = avcodec_decode_video(ist->st->codec,
1234 &picture, &got_picture, ptr, len);
1235 ist->st->quality= picture.quality;
1239 /* no picture yet */
1240 goto discard_packet;
1242 if (ist->st->codec->time_base.num != 0) {
1243 ist->next_pts += ((int64_t)AV_TIME_BASE *
1244 ist->st->codec->time_base.num) /
1245 ist->st->codec->time_base.den;
1249 case CODEC_TYPE_SUBTITLE:
1250 ret = avcodec_decode_subtitle(ist->st->codec,
1251 &subtitle, &got_subtitle, ptr, len);
1254 if (!got_subtitle) {
1255 goto discard_packet;
1257 subtitle_to_free = &subtitle;
1264 switch(ist->st->codec->codec_type) {
1265 case CODEC_TYPE_AUDIO:
1266 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1267 ist->st->codec->sample_rate;
1269 case CODEC_TYPE_VIDEO:
1270 if (ist->st->codec->time_base.num != 0) {
1271 ist->next_pts += ((int64_t)AV_TIME_BASE *
1272 ist->st->codec->time_base.num) /
1273 ist->st->codec->time_base.den;
1283 buffer_to_free = NULL;
1284 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1285 pre_process_video_frame(ist, (AVPicture *)&picture,
1289 // preprocess audio (volume)
1290 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1291 if (audio_volume != 256) {
1294 for(i=0;i<(data_size / sizeof(short));i++) {
1295 int v = ((*volp) * audio_volume + 128) >> 8;
1296 if (v < -32768) v = -32768;
1297 if (v > 32767) v = 32767;
1303 /* frame rate emulation */
1304 if (ist->st->codec->rate_emu) {
1305 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1306 int64_t now = av_gettime() - ist->start;
1314 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1315 is the one of the next displayed one */
1316 /* XXX: add mpeg4 too ? */
1317 if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1318 if (ist->st->codec->pict_type != B_TYPE) {
1320 tmp = ist->last_ip_pts;
1321 ist->last_ip_pts = ist->frac_pts.val;
1322 ist->frac_pts.val = tmp;
1326 /* if output time reached then transcode raw format,
1327 encode packets and output them */
1328 if (start_time == 0 || ist->pts >= start_time)
1329 for(i=0;i<nb_ostreams;i++) {
1333 if (ost->source_index == ist_index) {
1334 os = output_files[ost->file_index];
1337 printf("%d: got pts=%0.3f %0.3f\n", i,
1338 (double)pkt->pts / AV_TIME_BASE,
1339 ((double)ist->pts / AV_TIME_BASE) -
1340 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1342 /* set the input output pts pairs */
1343 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1345 if (ost->encoding_needed) {
1346 switch(ost->st->codec->codec_type) {
1347 case CODEC_TYPE_AUDIO:
1348 do_audio_out(os, ost, ist, data_buf, data_size);
1350 case CODEC_TYPE_VIDEO:
1351 do_video_out(os, ost, ist, &picture, &frame_size);
1352 if (vstats_filename && frame_size)
1353 do_video_stats(os, ost, frame_size);
1355 case CODEC_TYPE_SUBTITLE:
1356 do_subtitle_out(os, ost, ist, &subtitle,
1363 AVFrame avframe; //FIXME/XXX remove this
1365 av_init_packet(&opkt);
1367 if (!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY))
1370 /* no reencoding needed : output the packet directly */
1371 /* force the input stream PTS */
1373 avcodec_get_frame_defaults(&avframe);
1374 ost->st->codec->coded_frame= &avframe;
1375 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1377 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1378 audio_size += data_size;
1379 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1380 video_size += data_size;
1384 opkt.stream_index= ost->index;
1385 if(pkt->pts != AV_NOPTS_VALUE)
1386 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1388 opkt.pts= AV_NOPTS_VALUE;
1390 if (pkt->dts == AV_NOPTS_VALUE)
1391 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1393 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1395 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1396 opkt.flags= pkt->flags;
1398 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1399 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1400 opkt.destruct= av_destruct_packet;
1402 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1403 ost->st->codec->frame_number++;
1404 ost->frame_number++;
1405 av_free_packet(&opkt);
1409 av_free(buffer_to_free);
1410 /* XXX: allocate the subtitles in the codec ? */
1411 if (subtitle_to_free) {
1412 if (subtitle_to_free->rects != NULL) {
1413 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1414 av_free(subtitle_to_free->rects[i].bitmap);
1415 av_free(subtitle_to_free->rects[i].rgba_palette);
1417 av_freep(&subtitle_to_free->rects);
1419 subtitle_to_free->num_rects = 0;
1420 subtitle_to_free = NULL;
1427 for(i=0;i<nb_ostreams;i++) {
1429 if (ost->source_index == ist_index) {
1430 AVCodecContext *enc= ost->st->codec;
1431 os = output_files[ost->file_index];
1433 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1435 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1438 if (ost->encoding_needed) {
1442 av_init_packet(&pkt);
1443 pkt.stream_index= ost->index;
1445 switch(ost->st->codec->codec_type) {
1446 case CODEC_TYPE_AUDIO:
1447 fifo_bytes = av_fifo_size(&ost->fifo);
1449 /* encode any samples remaining in fifo */
1450 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1451 int fs_tmp = enc->frame_size;
1452 enc->frame_size = fifo_bytes / (2 * enc->channels);
1453 av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes);
1454 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1455 enc->frame_size = fs_tmp;
1458 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1461 pkt.flags |= PKT_FLAG_KEY;
1463 case CODEC_TYPE_VIDEO:
1464 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1466 if(enc->coded_frame && enc->coded_frame->key_frame)
1467 pkt.flags |= PKT_FLAG_KEY;
1468 if (ost->logfile && enc->stats_out) {
1469 fprintf(ost->logfile, "%s", enc->stats_out);
1478 pkt.data= bit_buffer;
1480 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1481 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1482 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1494 static void print_sdp(AVFormatContext **avc, int n)
1498 avf_sdp_create(avc, n, sdp, sizeof(sdp));
1499 printf("SDP:\n%s\n", sdp);
1502 static int stream_index_from_inputs(AVFormatContext **input_files,
1504 AVInputFile *file_table,
1505 AVInputStream **ist_table,
1506 enum CodecType type,
1510 for(z=0; z<nb_input_files; z++) {
1511 AVFormatContext *ic = input_files[z];
1512 for(p=0; p<ic->nb_programs; p++) {
1513 AVProgram *program = ic->programs[p];
1514 if(program->id != programid)
1516 for(q=0; q<program->nb_stream_indexes; q++) {
1517 int sidx = program->stream_index[q];
1518 int ris = file_table[z].ist_index + sidx;
1519 if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1529 * The following code is the main loop of the file converter
1531 static int av_encode(AVFormatContext **output_files,
1532 int nb_output_files,
1533 AVFormatContext **input_files,
1535 AVStreamMap *stream_maps, int nb_stream_maps)
1537 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1538 AVFormatContext *is, *os;
1539 AVCodecContext *codec, *icodec;
1540 AVOutputStream *ost, **ost_table = NULL;
1541 AVInputStream *ist, **ist_table = NULL;
1542 AVInputFile *file_table;
1546 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1550 /* input stream init */
1552 for(i=0;i<nb_input_files;i++) {
1553 is = input_files[i];
1554 file_table[i].ist_index = j;
1555 file_table[i].nb_streams = is->nb_streams;
1556 j += is->nb_streams;
1560 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1564 for(i=0;i<nb_istreams;i++) {
1565 ist = av_mallocz(sizeof(AVInputStream));
1571 for(i=0;i<nb_input_files;i++) {
1572 is = input_files[i];
1573 for(k=0;k<is->nb_streams;k++) {
1574 ist = ist_table[j++];
1575 ist->st = is->streams[k];
1576 ist->file_index = i;
1578 ist->discard = 1; /* the stream is discarded by default
1581 if (ist->st->codec->rate_emu) {
1582 ist->start = av_gettime();
1588 /* output stream init */
1590 for(i=0;i<nb_output_files;i++) {
1591 os = output_files[i];
1592 if (!os->nb_streams) {
1593 fprintf(stderr, "Output file does not contain any stream\n");
1596 nb_ostreams += os->nb_streams;
1598 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1599 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1603 /* Sanity check the mapping args -- do the input files & streams exist? */
1604 for(i=0;i<nb_stream_maps;i++) {
1605 int fi = stream_maps[i].file_index;
1606 int si = stream_maps[i].stream_index;
1608 if (fi < 0 || fi > nb_input_files - 1 ||
1609 si < 0 || si > file_table[fi].nb_streams - 1) {
1610 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1613 fi = stream_maps[i].sync_file_index;
1614 si = stream_maps[i].sync_stream_index;
1615 if (fi < 0 || fi > nb_input_files - 1 ||
1616 si < 0 || si > file_table[fi].nb_streams - 1) {
1617 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1622 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1625 for(i=0;i<nb_ostreams;i++) {
1626 ost = av_mallocz(sizeof(AVOutputStream));
1633 for(k=0;k<nb_output_files;k++) {
1634 os = output_files[k];
1635 for(i=0;i<os->nb_streams;i++) {
1637 ost = ost_table[n++];
1638 ost->file_index = k;
1640 ost->st = os->streams[i];
1641 if (nb_stream_maps > 0) {
1642 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1643 stream_maps[n-1].stream_index;
1645 /* Sanity check that the stream types match */
1646 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1647 int i= ost->file_index;
1648 dump_format(output_files[i], i, output_files[i]->filename, 1);
1649 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1650 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1651 ost->file_index, ost->index);
1658 j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1660 ost->source_index = j;
1664 /* get corresponding input stream index : we select the first one with the right type */
1666 for(j=0;j<nb_istreams;j++) {
1669 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1670 ost->source_index = j;
1678 if(! opt_programid) {
1679 /* try again and reuse existing stream */
1680 for(j=0;j<nb_istreams;j++) {
1682 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1683 ost->source_index = j;
1689 int i= ost->file_index;
1690 dump_format(output_files[i], i, output_files[i]->filename, 1);
1691 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1692 ost->file_index, ost->index);
1697 ist = ist_table[ost->source_index];
1699 ost->sync_ist = (nb_stream_maps > 0) ?
1700 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1701 stream_maps[n-1].sync_stream_index] : ist;
1705 /* for each output stream, we compute the right encoding parameters */
1706 for(i=0;i<nb_ostreams;i++) {
1708 os = output_files[ost->file_index];
1709 ist = ist_table[ost->source_index];
1711 codec = ost->st->codec;
1712 icodec = ist->st->codec;
1714 if (!ost->st->language[0])
1715 av_strlcpy(ost->st->language, ist->st->language,
1716 sizeof(ost->st->language));
1718 ost->st->disposition = ist->st->disposition;
1720 if (ost->st->stream_copy) {
1721 /* if stream_copy is selected, no need to decode or encode */
1722 codec->codec_id = icodec->codec_id;
1723 codec->codec_type = icodec->codec_type;
1725 if(!codec->codec_tag){
1726 if( !os->oformat->codec_tag
1727 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1728 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1729 codec->codec_tag = icodec->codec_tag;
1732 codec->bit_rate = icodec->bit_rate;
1733 codec->extradata= icodec->extradata;
1734 codec->extradata_size= icodec->extradata_size;
1735 if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1736 codec->time_base = icodec->time_base;
1738 codec->time_base = ist->st->time_base;
1739 switch(codec->codec_type) {
1740 case CODEC_TYPE_AUDIO:
1741 if(audio_volume != 256) {
1742 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1745 codec->sample_rate = icodec->sample_rate;
1746 codec->channels = icodec->channels;
1747 codec->frame_size = icodec->frame_size;
1748 codec->block_align= icodec->block_align;
1749 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1750 codec->block_align= 0;
1751 if(codec->codec_id == CODEC_ID_AC3)
1752 codec->block_align= 0;
1754 case CODEC_TYPE_VIDEO:
1756 fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1759 codec->pix_fmt = icodec->pix_fmt;
1760 codec->width = icodec->width;
1761 codec->height = icodec->height;
1762 codec->has_b_frames = icodec->has_b_frames;
1764 case CODEC_TYPE_SUBTITLE:
1770 switch(codec->codec_type) {
1771 case CODEC_TYPE_AUDIO:
1772 if (av_fifo_init(&ost->fifo, 1024))
1774 ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
1775 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1776 icodec->request_channels = codec->channels;
1777 ist->decoding_needed = 1;
1778 ost->encoding_needed = 1;
1780 case CODEC_TYPE_VIDEO:
1781 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1782 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1783 ost->video_resample = ((codec->width != icodec->width -
1784 (frame_leftBand + frame_rightBand) +
1785 (frame_padleft + frame_padright)) ||
1786 (codec->height != icodec->height -
1787 (frame_topBand + frame_bottomBand) +
1788 (frame_padtop + frame_padbottom)) ||
1789 (codec->pix_fmt != icodec->pix_fmt));
1790 if (ost->video_crop) {
1791 ost->topBand = frame_topBand;
1792 ost->leftBand = frame_leftBand;
1794 if (ost->video_pad) {
1795 ost->padtop = frame_padtop;
1796 ost->padleft = frame_padleft;
1797 ost->padbottom = frame_padbottom;
1798 ost->padright = frame_padright;
1799 if (!ost->video_resample) {
1800 avcodec_get_frame_defaults(&ost->pict_tmp);
1801 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1802 codec->width, codec->height))
1806 if (ost->video_resample) {
1807 avcodec_get_frame_defaults(&ost->pict_tmp);
1808 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1809 codec->width, codec->height)) {
1810 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1813 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1814 ost->img_resample_ctx = sws_getContext(
1815 icodec->width - (frame_leftBand + frame_rightBand),
1816 icodec->height - (frame_topBand + frame_bottomBand),
1818 codec->width - (frame_padleft + frame_padright),
1819 codec->height - (frame_padtop + frame_padbottom),
1821 sws_flags, NULL, NULL, NULL);
1822 if (ost->img_resample_ctx == NULL) {
1823 fprintf(stderr, "Cannot get resampling context\n");
1826 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1828 ost->encoding_needed = 1;
1829 ist->decoding_needed = 1;
1831 case CODEC_TYPE_SUBTITLE:
1832 ost->encoding_needed = 1;
1833 ist->decoding_needed = 1;
1840 if (ost->encoding_needed &&
1841 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1842 char logfilename[1024];
1847 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1849 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1850 if (codec->flags & CODEC_FLAG_PASS1) {
1851 f = fopen(logfilename, "w");
1853 perror(logfilename);
1858 /* read the log file */
1859 f = fopen(logfilename, "r");
1861 perror(logfilename);
1864 fseek(f, 0, SEEK_END);
1866 fseek(f, 0, SEEK_SET);
1867 logbuffer = av_malloc(size + 1);
1869 fprintf(stderr, "Could not allocate log buffer\n");
1872 size = fread(logbuffer, 1, size, f);
1874 logbuffer[size] = '\0';
1875 codec->stats_in = logbuffer;
1879 if(codec->codec_type == CODEC_TYPE_VIDEO){
1880 int size= codec->width * codec->height;
1881 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1886 bit_buffer = av_malloc(bit_buffer_size);
1890 /* dump the file output parameters - cannot be done before in case
1892 for(i=0;i<nb_output_files;i++) {
1893 dump_format(output_files[i], i, output_files[i]->filename, 1);
1896 /* dump the stream mapping */
1898 fprintf(stderr, "Stream mapping:\n");
1899 for(i=0;i<nb_ostreams;i++) {
1901 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1902 ist_table[ost->source_index]->file_index,
1903 ist_table[ost->source_index]->index,
1906 if (ost->sync_ist != ist_table[ost->source_index])
1907 fprintf(stderr, " [sync #%d.%d]",
1908 ost->sync_ist->file_index,
1909 ost->sync_ist->index);
1910 fprintf(stderr, "\n");
1914 /* open each encoder */
1915 for(i=0;i<nb_ostreams;i++) {
1917 if (ost->encoding_needed) {
1919 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1921 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1922 ost->file_index, ost->index);
1925 if (avcodec_open(ost->st->codec, codec) < 0) {
1926 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1927 ost->file_index, ost->index);
1930 extra_size += ost->st->codec->extradata_size;
1934 /* open each decoder */
1935 for(i=0;i<nb_istreams;i++) {
1937 if (ist->decoding_needed) {
1939 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1941 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1942 ist->st->codec->codec_id, ist->file_index, ist->index);
1945 if (avcodec_open(ist->st->codec, codec) < 0) {
1946 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1947 ist->file_index, ist->index);
1950 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1951 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1956 for(i=0;i<nb_istreams;i++) {
1958 is = input_files[ist->file_index];
1960 ist->next_pts = AV_NOPTS_VALUE;
1964 /* set meta data information from input file if required */
1965 for (i=0;i<nb_meta_data_maps;i++) {
1966 AVFormatContext *out_file;
1967 AVFormatContext *in_file;
1969 int out_file_index = meta_data_maps[i].out_file;
1970 int in_file_index = meta_data_maps[i].in_file;
1971 if (out_file_index < 0 || out_file_index >= nb_output_files) {
1972 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1973 ret = AVERROR(EINVAL);
1976 if (in_file_index < 0 || in_file_index >= nb_input_files) {
1977 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1978 ret = AVERROR(EINVAL);
1982 out_file = output_files[out_file_index];
1983 in_file = input_files[in_file_index];
1985 strcpy(out_file->title, in_file->title);
1986 strcpy(out_file->author, in_file->author);
1987 strcpy(out_file->copyright, in_file->copyright);
1988 strcpy(out_file->comment, in_file->comment);
1989 strcpy(out_file->album, in_file->album);
1990 out_file->year = in_file->year;
1991 out_file->track = in_file->track;
1992 strcpy(out_file->genre, in_file->genre);
1995 /* open files and write file headers */
1996 for(i=0;i<nb_output_files;i++) {
1997 os = output_files[i];
1998 if (av_write_header(os) < 0) {
1999 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
2000 ret = AVERROR(EINVAL);
2003 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2008 print_sdp(output_files, nb_output_files);
2011 if (!using_stdin && verbose >= 0) {
2012 fprintf(stderr, "Press [q] to stop encoding\n");
2013 url_set_interrupt_cb(decode_interrupt_cb);
2018 timer_start = av_gettime();
2020 for(; received_sigterm == 0;) {
2021 int file_index, ist_index;
2029 /* if 'q' pressed, exits */
2033 /* read_key() returns 0 on EOF */
2039 /* select the stream that we must read now by looking at the
2040 smallest output pts */
2042 for(i=0;i<nb_ostreams;i++) {
2045 os = output_files[ost->file_index];
2046 ist = ist_table[ost->source_index];
2047 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2048 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2050 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2051 ipts = (double)ist->pts;
2052 if (!file_table[ist->file_index].eof_reached){
2053 if(ipts < ipts_min) {
2055 if(input_sync ) file_index = ist->file_index;
2057 if(opts < opts_min) {
2059 if(!input_sync) file_index = ist->file_index;
2062 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2067 /* if none, if is finished */
2068 if (file_index < 0) {
2072 /* finish if recording time exhausted */
2073 if (opts_min >= (recording_time / 1000000.0))
2076 /* finish if limit size exhausted */
2077 if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2080 /* read a frame from it and output it in the fifo */
2081 is = input_files[file_index];
2082 if (av_read_frame(is, &pkt) < 0) {
2083 file_table[file_index].eof_reached = 1;
2091 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2093 /* the following test is needed in case new streams appear
2094 dynamically in stream : we ignore them */
2095 if (pkt.stream_index >= file_table[file_index].nb_streams)
2096 goto discard_packet;
2097 ist_index = file_table[file_index].ist_index + pkt.stream_index;
2098 ist = ist_table[ist_index];
2100 goto discard_packet;
2102 if (pkt.dts != AV_NOPTS_VALUE)
2103 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2104 if (pkt.pts != AV_NOPTS_VALUE)
2105 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2107 if(input_files_ts_scale[file_index][pkt.stream_index]){
2108 if(pkt.pts != AV_NOPTS_VALUE)
2109 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2110 if(pkt.dts != AV_NOPTS_VALUE)
2111 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2114 // 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);
2115 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
2116 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2117 int64_t delta= pkt_dts - ist->next_pts;
2118 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2119 input_files_ts_offset[ist->file_index]-= delta;
2121 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2122 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2123 if(pkt.pts != AV_NOPTS_VALUE)
2124 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2128 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2129 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2132 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2133 ist->file_index, ist->index);
2135 av_free_packet(&pkt);
2140 av_free_packet(&pkt);
2142 /* dump report by using the output first video and audio streams */
2143 print_report(output_files, ost_table, nb_ostreams, 0);
2146 /* at the end of stream, we must flush the decoder buffers */
2147 for(i=0;i<nb_istreams;i++) {
2149 if (ist->decoding_needed) {
2150 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2156 /* write the trailer if needed and close file */
2157 for(i=0;i<nb_output_files;i++) {
2158 os = output_files[i];
2159 av_write_trailer(os);
2162 /* dump report by using the first video and audio streams */
2163 print_report(output_files, ost_table, nb_ostreams, 1);
2165 /* close each encoder */
2166 for(i=0;i<nb_ostreams;i++) {
2168 if (ost->encoding_needed) {
2169 av_freep(&ost->st->codec->stats_in);
2170 avcodec_close(ost->st->codec);
2174 /* close each decoder */
2175 for(i=0;i<nb_istreams;i++) {
2177 if (ist->decoding_needed) {
2178 avcodec_close(ist->st->codec);
2186 av_freep(&bit_buffer);
2187 av_free(file_table);
2190 for(i=0;i<nb_istreams;i++) {
2197 for(i=0;i<nb_ostreams;i++) {
2201 fclose(ost->logfile);
2202 ost->logfile = NULL;
2204 av_fifo_free(&ost->fifo); /* works even if fifo is not
2205 initialized but set to zero */
2206 av_free(ost->pict_tmp.data[0]);
2207 if (ost->video_resample)
2208 sws_freeContext(ost->img_resample_ctx);
2210 audio_resample_close(ost->resample);
2211 if (ost->reformat_ctx)
2212 av_audio_convert_free(ost->reformat_ctx);
2220 ret = AVERROR(ENOMEM);
2225 int file_read(const char *filename)
2228 unsigned char buffer[1024];
2231 if (url_open(&h, filename, O_RDONLY) < 0) {
2232 printf("could not open '%s'\n", filename);
2236 len = url_read(h, buffer, sizeof(buffer));
2239 for(i=0;i<len;i++) putchar(buffer[i]);
2246 static void opt_format(const char *arg)
2248 /* compatibility stuff for pgmyuv */
2249 if (!strcmp(arg, "pgmyuv")) {
2250 pgmyuv_compatibility_hack=1;
2251 // opt_image_format(arg);
2253 fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2256 file_iformat = av_find_input_format(arg);
2257 file_oformat = guess_format(arg, NULL, NULL);
2258 if (!file_iformat && !file_oformat) {
2259 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2264 static int opt_default(const char *opt, const char *arg){
2266 const AVOption *o= NULL;
2267 int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
2269 for(type=0; type<CODEC_TYPE_NB; type++){
2270 const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
2272 o = av_set_string2(avctx_opts[type], opt, arg, 1);
2275 o = av_set_string2(avformat_opts, opt, arg, 1);
2277 o = av_set_string2(sws_opts, opt, arg, 1);
2280 o = av_set_string2(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg, 1);
2281 else if(opt[0] == 'v')
2282 o = av_set_string2(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg, 1);
2283 else if(opt[0] == 's')
2284 o = av_set_string2(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg, 1);
2289 // av_log(NULL, AV_LOG_ERROR, "%s:%s: %f 0x%0X\n", opt, arg, av_get_double(avctx_opts, opt, NULL), (int)av_get_int(avctx_opts, opt, NULL));
2291 //FIXME we should always use avctx_opts, ... for storing options so there will not be any need to keep track of what i set over this
2292 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
2293 opt_names[opt_name_count++]= o->name;
2295 if(avctx_opts[0]->debug || avformat_opts->debug)
2296 av_log_set_level(AV_LOG_DEBUG);
2300 static void opt_video_rc_override_string(const char *arg)
2302 video_rc_override_string = arg;
2305 static int opt_me_threshold(const char *opt, const char *arg)
2307 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2311 static int opt_verbose(const char *opt, const char *arg)
2313 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2314 av_log_set_level(verbose);
2318 static void opt_frame_rate(const char *arg)
2320 if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2321 fprintf(stderr, "Incorrect frame rate\n");
2326 static int opt_bitrate(const char *opt, const char *arg)
2328 int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2330 opt_default(opt, arg);
2332 if (av_get_int(avctx_opts[codec_type], "b", NULL) < 1000)
2333 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2338 static void opt_frame_crop_top(const char *arg)
2340 frame_topBand = atoi(arg);
2341 if (frame_topBand < 0) {
2342 fprintf(stderr, "Incorrect top crop size\n");
2345 if ((frame_topBand % 2) != 0) {
2346 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2349 if ((frame_topBand) >= frame_height){
2350 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2353 frame_height -= frame_topBand;
2356 static void opt_frame_crop_bottom(const char *arg)
2358 frame_bottomBand = atoi(arg);
2359 if (frame_bottomBand < 0) {
2360 fprintf(stderr, "Incorrect bottom crop size\n");
2363 if ((frame_bottomBand % 2) != 0) {
2364 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2367 if ((frame_bottomBand) >= frame_height){
2368 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2371 frame_height -= frame_bottomBand;
2374 static void opt_frame_crop_left(const char *arg)
2376 frame_leftBand = atoi(arg);
2377 if (frame_leftBand < 0) {
2378 fprintf(stderr, "Incorrect left crop size\n");
2381 if ((frame_leftBand % 2) != 0) {
2382 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2385 if ((frame_leftBand) >= frame_width){
2386 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2389 frame_width -= frame_leftBand;
2392 static void opt_frame_crop_right(const char *arg)
2394 frame_rightBand = atoi(arg);
2395 if (frame_rightBand < 0) {
2396 fprintf(stderr, "Incorrect right crop size\n");
2399 if ((frame_rightBand % 2) != 0) {
2400 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2403 if ((frame_rightBand) >= frame_width){
2404 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2407 frame_width -= frame_rightBand;
2410 static void opt_frame_size(const char *arg)
2412 if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2413 fprintf(stderr, "Incorrect frame size\n");
2416 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2417 fprintf(stderr, "Frame size must be a multiple of 2\n");
2423 #define SCALEBITS 10
2424 #define ONE_HALF (1 << (SCALEBITS - 1))
2425 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2427 #define RGB_TO_Y(r, g, b) \
2428 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2429 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2431 #define RGB_TO_U(r1, g1, b1, shift)\
2432 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2433 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2435 #define RGB_TO_V(r1, g1, b1, shift)\
2436 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2437 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2439 static void opt_pad_color(const char *arg) {
2440 /* Input is expected to be six hex digits similar to
2441 how colors are expressed in html tags (but without the #) */
2442 int rgb = strtol(arg, NULL, 16);
2446 g = ((rgb >> 8) & 255);
2449 padcolor[0] = RGB_TO_Y(r,g,b);
2450 padcolor[1] = RGB_TO_U(r,g,b,0);
2451 padcolor[2] = RGB_TO_V(r,g,b,0);
2454 static void opt_frame_pad_top(const char *arg)
2456 frame_padtop = atoi(arg);
2457 if (frame_padtop < 0) {
2458 fprintf(stderr, "Incorrect top pad size\n");
2461 if ((frame_padtop % 2) != 0) {
2462 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2467 static void opt_frame_pad_bottom(const char *arg)
2469 frame_padbottom = atoi(arg);
2470 if (frame_padbottom < 0) {
2471 fprintf(stderr, "Incorrect bottom pad size\n");
2474 if ((frame_padbottom % 2) != 0) {
2475 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2481 static void opt_frame_pad_left(const char *arg)
2483 frame_padleft = atoi(arg);
2484 if (frame_padleft < 0) {
2485 fprintf(stderr, "Incorrect left pad size\n");
2488 if ((frame_padleft % 2) != 0) {
2489 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2495 static void opt_frame_pad_right(const char *arg)
2497 frame_padright = atoi(arg);
2498 if (frame_padright < 0) {
2499 fprintf(stderr, "Incorrect right pad size\n");
2502 if ((frame_padright % 2) != 0) {
2503 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2508 static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2512 for (i=-1; i < nb_fmts; i++) {
2513 get_fmt_string (fmt_str, sizeof(fmt_str), i);
2514 fprintf(stdout, "%s\n", fmt_str);
2518 static void opt_frame_pix_fmt(const char *arg)
2520 if (strcmp(arg, "list"))
2521 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2523 list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2528 static void opt_frame_aspect_ratio(const char *arg)
2535 p = strchr(arg, ':');
2537 x = strtol(arg, &end, 10);
2539 y = strtol(end+1, &end, 10);
2541 ar = (double)x / (double)y;
2543 ar = strtod(arg, NULL);
2546 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2549 frame_aspect_ratio = ar;
2552 static void opt_qscale(const char *arg)
2554 video_qscale = atof(arg);
2555 if (video_qscale <= 0 ||
2556 video_qscale > 255) {
2557 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2562 static void opt_top_field_first(const char *arg)
2564 top_field_first= atoi(arg);
2567 static int opt_thread_count(const char *opt, const char *arg)
2569 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2570 #if !defined(HAVE_THREADS)
2572 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2577 static void opt_audio_sample_fmt(const char *arg)
2579 if (strcmp(arg, "list"))
2580 audio_sample_fmt = avcodec_get_sample_fmt(arg);
2582 list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2587 static int opt_audio_rate(const char *opt, const char *arg)
2589 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2593 static int opt_audio_channels(const char *opt, const char *arg)
2595 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2599 static void opt_video_channel(const char *arg)
2601 video_channel = strtol(arg, NULL, 0);
2604 static void opt_video_standard(const char *arg)
2606 video_standard = av_strdup(arg);
2609 static void opt_codec(int *pstream_copy, char **pcodec_name,
2610 int codec_type, const char *arg)
2612 av_freep(pcodec_name);
2613 if (!strcmp(arg, "copy")) {
2616 *pcodec_name = av_strdup(arg);
2620 static void opt_audio_codec(const char *arg)
2622 opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2625 static void opt_audio_tag(const char *arg)
2628 audio_codec_tag= strtol(arg, &tail, 0);
2631 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2634 static void opt_video_tag(const char *arg)
2637 video_codec_tag= strtol(arg, &tail, 0);
2640 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2644 static void add_frame_hooker(const char *arg)
2649 char *args = av_strdup(arg);
2653 argv[0] = strtok(args, " ");
2654 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2657 i = frame_hook_add(argc, argv);
2660 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2666 static void opt_video_codec(const char *arg)
2668 opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2671 static void opt_subtitle_codec(const char *arg)
2673 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2676 static void opt_map(const char *arg)
2681 m = &stream_maps[nb_stream_maps++];
2683 m->file_index = strtol(arg, &p, 0);
2687 m->stream_index = strtol(p, &p, 0);
2690 m->sync_file_index = strtol(p, &p, 0);
2693 m->sync_stream_index = strtol(p, &p, 0);
2695 m->sync_file_index = m->file_index;
2696 m->sync_stream_index = m->stream_index;
2700 static void opt_map_meta_data(const char *arg)
2705 m = &meta_data_maps[nb_meta_data_maps++];
2707 m->out_file = strtol(arg, &p, 0);
2711 m->in_file = strtol(p, &p, 0);
2714 static void opt_input_ts_scale(const char *arg)
2716 unsigned int stream;
2720 stream = strtol(arg, &p, 0);
2723 scale= strtod(p, &p);
2725 if(stream >= MAX_STREAMS)
2728 input_files_ts_scale[nb_input_files][stream]= scale;
2731 static int opt_recording_time(const char *opt, const char *arg)
2733 recording_time = parse_time_or_die(opt, arg, 1);
2737 static int opt_start_time(const char *opt, const char *arg)
2739 start_time = parse_time_or_die(opt, arg, 1);
2743 static int opt_rec_timestamp(const char *opt, const char *arg)
2745 rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2749 static int opt_input_ts_offset(const char *opt, const char *arg)
2751 input_ts_offset = parse_time_or_die(opt, arg, 1);
2755 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2757 const char *codec_string = encoder ? "encoder" : "decoder";
2761 return CODEC_ID_NONE;
2763 avcodec_find_encoder_by_name(name) :
2764 avcodec_find_decoder_by_name(name);
2766 av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2769 if(codec->type != type) {
2770 av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2776 static void set_context_opts(void *ctx, void *opts_ctx, int flags)
2779 for(i=0; i<opt_name_count; i++){
2781 const AVOption *opt;
2782 const char *str= av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
2783 /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
2784 if(str && ((opt->flags & flags) == flags))
2785 av_set_string2(ctx, opt_names[i], str, 1);
2789 static void opt_input_file(const char *filename)
2791 AVFormatContext *ic;
2792 AVFormatParameters params, *ap = ¶ms;
2793 int err, i, ret, rfps, rfps_base;
2796 if (!strcmp(filename, "-"))
2799 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2800 !strcmp(filename, "/dev/stdin");
2802 /* get default parameters from command line */
2803 ic = av_alloc_format_context();
2805 memset(ap, 0, sizeof(*ap));
2806 ap->prealloced_context = 1;
2807 ap->sample_rate = audio_sample_rate;
2808 ap->channels = audio_channels;
2809 ap->time_base.den = frame_rate.num;
2810 ap->time_base.num = frame_rate.den;
2811 ap->width = frame_width + frame_padleft + frame_padright;
2812 ap->height = frame_height + frame_padtop + frame_padbottom;
2813 ap->pix_fmt = frame_pix_fmt;
2814 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2815 ap->channel = video_channel;
2816 ap->standard = video_standard;
2817 ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2818 ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2819 if(pgmyuv_compatibility_hack)
2820 ap->video_codec_id= CODEC_ID_PGMYUV;
2822 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2824 ic->video_codec_id = find_codec_or_die(video_codec_name , CODEC_TYPE_VIDEO , 0);
2825 ic->audio_codec_id = find_codec_or_die(audio_codec_name , CODEC_TYPE_AUDIO , 0);
2826 ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2828 /* open the input file with generic libav function */
2829 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2831 print_error(filename, err);
2836 for(i=0; i<ic->nb_programs; i++)
2837 if(ic->programs[i]->id != opt_programid)
2838 ic->programs[i]->discard = AVDISCARD_ALL;
2841 ic->loop_input = loop_input;
2843 /* If not enough info to get the stream parameters, we decode the
2844 first frames to get it. (used in mpeg case for example) */
2845 ret = av_find_stream_info(ic);
2846 if (ret < 0 && verbose >= 0) {
2847 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2851 timestamp = start_time;
2852 /* add the stream start time */
2853 if (ic->start_time != AV_NOPTS_VALUE)
2854 timestamp += ic->start_time;
2856 /* if seeking requested, we execute it */
2857 if (start_time != 0) {
2858 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2860 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2861 filename, (double)timestamp / AV_TIME_BASE);
2863 /* reset seek info */
2867 /* update the current parameters so that they match the one of the input stream */
2868 for(i=0;i<ic->nb_streams;i++) {
2869 AVCodecContext *enc = ic->streams[i]->codec;
2871 avcodec_thread_init(enc, thread_count);
2872 enc->thread_count= thread_count;
2873 switch(enc->codec_type) {
2874 case CODEC_TYPE_AUDIO:
2875 set_context_opts(enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2876 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2877 audio_channels = enc->channels;
2878 audio_sample_rate = enc->sample_rate;
2879 audio_sample_fmt = enc->sample_fmt;
2881 ic->streams[i]->discard= AVDISCARD_ALL;
2883 case CODEC_TYPE_VIDEO:
2884 set_context_opts(enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2885 frame_height = enc->height;
2886 frame_width = enc->width;
2887 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2888 frame_pix_fmt = enc->pix_fmt;
2889 rfps = ic->streams[i]->r_frame_rate.num;
2890 rfps_base = ic->streams[i]->r_frame_rate.den;
2891 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2893 enc->debug |= FF_DEBUG_MV;
2895 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2898 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2899 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2901 (float)rfps / rfps_base, rfps, rfps_base);
2903 /* update the current frame rate to match the stream frame rate */
2904 frame_rate.num = rfps;
2905 frame_rate.den = rfps_base;
2907 enc->rate_emu = rate_emu;
2909 ic->streams[i]->discard= AVDISCARD_ALL;
2910 else if(video_discard)
2911 ic->streams[i]->discard= video_discard;
2913 case CODEC_TYPE_DATA:
2915 case CODEC_TYPE_SUBTITLE:
2916 if(subtitle_disable)
2917 ic->streams[i]->discard = AVDISCARD_ALL;
2919 case CODEC_TYPE_ATTACHMENT:
2920 case CODEC_TYPE_UNKNOWN:
2927 input_files[nb_input_files] = ic;
2928 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2929 /* dump the file content */
2931 dump_format(ic, nb_input_files, filename, 0);
2934 file_iformat = NULL;
2935 file_oformat = NULL;
2940 av_freep(&video_codec_name);
2941 av_freep(&audio_codec_name);
2942 av_freep(&subtitle_codec_name);
2945 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2946 int *has_subtitle_ptr)
2948 int has_video, has_audio, has_subtitle, i, j;
2949 AVFormatContext *ic;
2954 for(j=0;j<nb_input_files;j++) {
2955 ic = input_files[j];
2956 for(i=0;i<ic->nb_streams;i++) {
2957 AVCodecContext *enc = ic->streams[i]->codec;
2958 switch(enc->codec_type) {
2959 case CODEC_TYPE_AUDIO:
2962 case CODEC_TYPE_VIDEO:
2965 case CODEC_TYPE_SUBTITLE:
2968 case CODEC_TYPE_DATA:
2969 case CODEC_TYPE_ATTACHMENT:
2970 case CODEC_TYPE_UNKNOWN:
2977 *has_video_ptr = has_video;
2978 *has_audio_ptr = has_audio;
2979 *has_subtitle_ptr = has_subtitle;
2982 static void new_video_stream(AVFormatContext *oc)
2985 AVCodecContext *video_enc;
2988 st = av_new_stream(oc, oc->nb_streams);
2990 fprintf(stderr, "Could not alloc stream\n");
2993 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2994 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2995 video_bitstream_filters= NULL;
2998 avcodec_thread_init(st->codec, thread_count);
3000 video_enc = st->codec;
3003 video_enc->codec_tag= video_codec_tag;
3005 if( (video_global_header&1)
3006 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3007 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3008 avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3010 if(video_global_header&2){
3011 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3012 avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3015 if (video_stream_copy) {
3016 st->stream_copy = 1;
3017 video_enc->codec_type = CODEC_TYPE_VIDEO;
3022 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3024 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3025 if (video_codec_name)
3026 codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3028 video_enc->codec_id = codec_id;
3029 codec = avcodec_find_encoder(codec_id);
3031 set_context_opts(video_enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3033 video_enc->time_base.den = fps.num;
3034 video_enc->time_base.num = fps.den;
3035 if(codec && codec->supported_framerates){
3036 const AVRational *p= codec->supported_framerates;
3037 const AVRational *best=NULL;
3038 AVRational best_error= (AVRational){INT_MAX, 1};
3039 for(; p->den!=0; p++){
3040 AVRational error= av_sub_q(fps, *p);
3041 if(error.num <0) error.num *= -1;
3042 if(av_cmp_q(error, best_error) < 0){
3047 video_enc->time_base.den= best->num;
3048 video_enc->time_base.num= best->den;
3051 video_enc->width = frame_width + frame_padright + frame_padleft;
3052 video_enc->height = frame_height + frame_padtop + frame_padbottom;
3053 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3054 video_enc->pix_fmt = frame_pix_fmt;
3056 if(codec && codec->pix_fmts){
3057 const enum PixelFormat *p= codec->pix_fmts;
3059 if(*p == video_enc->pix_fmt)
3063 video_enc->pix_fmt = codec->pix_fmts[0];
3067 video_enc->gop_size = 0;
3068 if (video_qscale || same_quality) {
3069 video_enc->flags |= CODEC_FLAG_QSCALE;
3070 video_enc->global_quality=
3071 st->quality = FF_QP2LAMBDA * video_qscale;
3075 video_enc->intra_matrix = intra_matrix;
3077 video_enc->inter_matrix = inter_matrix;
3079 video_enc->thread_count = thread_count;
3080 p= video_rc_override_string;
3083 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3085 fprintf(stderr, "error parsing rc_override\n");
3088 video_enc->rc_override=
3089 av_realloc(video_enc->rc_override,
3090 sizeof(RcOverride)*(i+1));
3091 video_enc->rc_override[i].start_frame= start;
3092 video_enc->rc_override[i].end_frame = end;
3094 video_enc->rc_override[i].qscale= q;
3095 video_enc->rc_override[i].quality_factor= 1.0;
3098 video_enc->rc_override[i].qscale= 0;
3099 video_enc->rc_override[i].quality_factor= -q/100.0;
3104 video_enc->rc_override_count=i;
3105 if (!video_enc->rc_initial_buffer_occupancy)
3106 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3107 video_enc->me_threshold= me_threshold;
3108 video_enc->intra_dc_precision= intra_dc_precision - 8;
3111 video_enc->flags|= CODEC_FLAG_PSNR;
3116 video_enc->flags |= CODEC_FLAG_PASS1;
3118 video_enc->flags |= CODEC_FLAG_PASS2;
3123 /* reset some key parameters */
3125 av_freep(&video_codec_name);
3126 video_stream_copy = 0;
3129 static void new_audio_stream(AVFormatContext *oc)
3132 AVCodecContext *audio_enc;
3135 st = av_new_stream(oc, oc->nb_streams);
3137 fprintf(stderr, "Could not alloc stream\n");
3140 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3142 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3143 audio_bitstream_filters= NULL;
3146 avcodec_thread_init(st->codec, thread_count);
3148 audio_enc = st->codec;
3149 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3152 audio_enc->codec_tag= audio_codec_tag;
3154 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3155 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3156 avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3158 if (audio_stream_copy) {
3159 st->stream_copy = 1;
3160 audio_enc->channels = audio_channels;
3163 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3165 set_context_opts(audio_enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3167 if (audio_codec_name)
3168 codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3169 audio_enc->codec_id = codec_id;
3170 codec = avcodec_find_encoder(codec_id);
3172 if (audio_qscale > QSCALE_NONE) {
3173 audio_enc->flags |= CODEC_FLAG_QSCALE;
3174 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3176 audio_enc->thread_count = thread_count;
3177 audio_enc->channels = audio_channels;
3178 audio_enc->sample_fmt = audio_sample_fmt;
3180 if(codec && codec->sample_fmts){
3181 const enum SampleFormat *p= codec->sample_fmts;
3183 if(*p == audio_enc->sample_fmt)
3187 audio_enc->sample_fmt = codec->sample_fmts[0];
3190 audio_enc->sample_rate = audio_sample_rate;
3191 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3192 if (audio_language) {
3193 av_strlcpy(st->language, audio_language, sizeof(st->language));
3194 av_free(audio_language);
3195 audio_language = NULL;
3198 /* reset some key parameters */
3200 av_freep(&audio_codec_name);
3201 audio_stream_copy = 0;
3204 static void new_subtitle_stream(AVFormatContext *oc)
3207 AVCodecContext *subtitle_enc;
3209 st = av_new_stream(oc, oc->nb_streams);
3211 fprintf(stderr, "Could not alloc stream\n");
3214 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3216 bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3217 subtitle_bitstream_filters= NULL;
3219 subtitle_enc = st->codec;
3220 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3221 if (subtitle_stream_copy) {
3222 st->stream_copy = 1;
3224 set_context_opts(avctx_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3225 subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3228 if (subtitle_language) {
3229 av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3230 av_free(subtitle_language);
3231 subtitle_language = NULL;
3234 subtitle_disable = 0;
3235 av_freep(&subtitle_codec_name);
3236 subtitle_stream_copy = 0;
3239 static void opt_new_audio_stream(void)
3241 AVFormatContext *oc;
3242 if (nb_output_files <= 0) {
3243 fprintf(stderr, "At least one output file must be specified\n");
3246 oc = output_files[nb_output_files - 1];
3247 new_audio_stream(oc);
3250 static void opt_new_video_stream(void)
3252 AVFormatContext *oc;
3253 if (nb_output_files <= 0) {
3254 fprintf(stderr, "At least one output file must be specified\n");
3257 oc = output_files[nb_output_files - 1];
3258 new_video_stream(oc);
3261 static void opt_new_subtitle_stream(void)
3263 AVFormatContext *oc;
3264 if (nb_output_files <= 0) {
3265 fprintf(stderr, "At least one output file must be specified\n");
3268 oc = output_files[nb_output_files - 1];
3269 new_subtitle_stream(oc);
3272 static void opt_output_file(const char *filename)
3274 AVFormatContext *oc;
3275 int use_video, use_audio, use_subtitle;
3276 int input_has_video, input_has_audio, input_has_subtitle;
3277 AVFormatParameters params, *ap = ¶ms;
3279 if (!strcmp(filename, "-"))
3282 oc = av_alloc_format_context();
3284 if (!file_oformat) {
3285 file_oformat = guess_format(NULL, filename, NULL);
3286 if (!file_oformat) {
3287 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3293 oc->oformat = file_oformat;
3294 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3296 if (!strcmp(file_oformat->name, "ffm") &&
3297 av_strstart(filename, "http:", NULL)) {
3298 /* special case for files sent to ffserver: we get the stream
3299 parameters from ffserver */
3300 int err = read_ffserver_streams(oc, filename);
3302 print_error(filename, err);
3306 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3307 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3308 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3310 /* disable if no corresponding type found and at least one
3312 if (nb_input_files > 0) {
3313 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3314 &input_has_subtitle);
3315 if (!input_has_video)
3317 if (!input_has_audio)
3319 if (!input_has_subtitle)
3323 /* manual disable */
3324 if (audio_disable) {
3327 if (video_disable) {
3330 if (subtitle_disable) {
3335 new_video_stream(oc);
3339 new_audio_stream(oc);
3343 new_subtitle_stream(oc);
3346 oc->timestamp = rec_timestamp;
3349 av_strlcpy(oc->title, str_title, sizeof(oc->title));
3351 av_strlcpy(oc->author, str_author, sizeof(oc->author));
3353 av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3355 av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3357 av_strlcpy(oc->album, str_album, sizeof(oc->album));
3359 av_strlcpy(oc->genre, str_genre, sizeof(oc->genre));
3362 output_files[nb_output_files++] = oc;
3364 /* check filename in case of an image number is expected */
3365 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3366 if (!av_filename_number_test(oc->filename)) {
3367 print_error(oc->filename, AVERROR_NUMEXPECTED);
3372 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3373 /* test if it already exists to avoid loosing precious files */
3374 if (!file_overwrite &&
3375 (strchr(filename, ':') == NULL ||
3376 filename[1] == ':' ||
3377 av_strstart(filename, "file:", NULL))) {
3378 if (url_exist(filename)) {
3382 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3385 if (toupper(c) != 'Y') {
3386 fprintf(stderr, "Not overwriting - exiting\n");
3391 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3398 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3399 fprintf(stderr, "Could not open '%s'\n", filename);
3404 memset(ap, 0, sizeof(*ap));
3405 if (av_set_parameters(oc, ap) < 0) {
3406 fprintf(stderr, "%s: Invalid encoding parameters\n",
3411 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3412 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3413 oc->loop_output = loop_output;
3415 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3417 /* reset some options */
3418 file_oformat = NULL;
3419 file_iformat = NULL;
3422 /* same option as mencoder */
3423 static void opt_pass(const char *pass_str)
3426 pass = atoi(pass_str);
3427 if (pass != 1 && pass != 2) {
3428 fprintf(stderr, "pass number can be only 1 or 2\n");
3434 static int64_t getutime(void)
3436 #ifdef HAVE_GETRUSAGE
3437 struct rusage rusage;
3439 getrusage(RUSAGE_SELF, &rusage);
3440 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3441 #elif defined(HAVE_GETPROCESSTIMES)
3443 FILETIME c, e, k, u;
3444 proc = GetCurrentProcess();
3445 GetProcessTimes(proc, &c, &e, &k, &u);
3446 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3448 return av_gettime();
3452 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3455 const char *p = str;
3462 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3469 static void opt_inter_matrix(const char *arg)
3471 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3472 parse_matrix_coeffs(inter_matrix, arg);
3475 static void opt_intra_matrix(const char *arg)
3477 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3478 parse_matrix_coeffs(intra_matrix, arg);
3482 * Trivial log callback.
3483 * Only suitable for show_help and similar since it lacks prefix handling.
3485 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3487 vfprintf(stdout, fmt, vl);
3490 static void show_help(void)
3492 av_log_set_callback(log_callback_help);
3493 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3494 "Hyper fast Audio and Video encoder\n");
3496 show_help_options(options, "Main options:\n",
3497 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3498 show_help_options(options, "\nAdvanced options:\n",
3499 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3501 show_help_options(options, "\nVideo options:\n",
3502 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3504 show_help_options(options, "\nAdvanced Video options:\n",
3505 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3506 OPT_VIDEO | OPT_EXPERT);
3507 show_help_options(options, "\nAudio options:\n",
3508 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3510 show_help_options(options, "\nAdvanced Audio options:\n",
3511 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3512 OPT_AUDIO | OPT_EXPERT);
3513 show_help_options(options, "\nSubtitle options:\n",
3514 OPT_SUBTITLE | OPT_GRAB,
3516 show_help_options(options, "\nAudio/Video grab options:\n",
3520 av_opt_show(avctx_opts[0], NULL);
3522 av_opt_show(avformat_opts, NULL);
3524 av_opt_show(sws_opts, NULL);
3527 static void opt_target(const char *arg)
3530 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3532 if(!strncmp(arg, "pal-", 4)) {
3535 } else if(!strncmp(arg, "ntsc-", 5)) {
3538 } else if(!strncmp(arg, "film-", 5)) {
3543 /* Calculate FR via float to avoid int overflow */
3544 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3547 } else if((fr == 29970) || (fr == 23976)) {
3550 /* Try to determine PAL/NTSC by peeking in the input files */
3551 if(nb_input_files) {
3553 for(j = 0; j < nb_input_files; j++) {
3554 for(i = 0; i < input_files[j]->nb_streams; i++) {
3555 AVCodecContext *c = input_files[j]->streams[i]->codec;
3556 if(c->codec_type != CODEC_TYPE_VIDEO)
3558 fr = c->time_base.den * 1000 / c->time_base.num;
3562 } else if((fr == 29970) || (fr == 23976)) {
3572 if(verbose && norm >= 0)
3573 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3577 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3578 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3579 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3583 if(!strcmp(arg, "vcd")) {
3585 opt_video_codec("mpeg1video");
3586 opt_audio_codec("mp2");
3589 opt_frame_size(norm ? "352x240" : "352x288");
3590 opt_frame_rate(frame_rates[norm]);
3591 opt_default("gop", norm ? "18" : "15");
3593 opt_default("b", "1150000");
3594 opt_default("maxrate", "1150000");
3595 opt_default("minrate", "1150000");
3596 opt_default("bufsize", "327680"); // 40*1024*8;
3598 opt_default("ab", "224000");
3599 audio_sample_rate = 44100;
3602 opt_default("packetsize", "2324");
3603 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3605 /* We have to offset the PTS, so that it is consistent with the SCR.
3606 SCR starts at 36000, but the first two packs contain only padding
3607 and the first pack from the other stream, respectively, may also have
3608 been written before.
3609 So the real data starts at SCR 36000+3*1200. */
3610 mux_preload= (36000+3*1200) / 90000.0; //0.44
3611 } else if(!strcmp(arg, "svcd")) {
3613 opt_video_codec("mpeg2video");
3614 opt_audio_codec("mp2");
3617 opt_frame_size(norm ? "480x480" : "480x576");
3618 opt_frame_rate(frame_rates[norm]);
3619 opt_default("gop", norm ? "18" : "15");
3621 opt_default("b", "2040000");
3622 opt_default("maxrate", "2516000");
3623 opt_default("minrate", "0"); //1145000;
3624 opt_default("bufsize", "1835008"); //224*1024*8;
3625 opt_default("flags", "+SCAN_OFFSET");
3628 opt_default("ab", "224000");
3629 audio_sample_rate = 44100;
3631 opt_default("packetsize", "2324");
3633 } else if(!strcmp(arg, "dvd")) {
3635 opt_video_codec("mpeg2video");
3636 opt_audio_codec("ac3");
3639 opt_frame_size(norm ? "720x480" : "720x576");
3640 opt_frame_rate(frame_rates[norm]);
3641 opt_default("gop", norm ? "18" : "15");
3643 opt_default("b", "6000000");
3644 opt_default("maxrate", "9000000");
3645 opt_default("minrate", "0"); //1500000;
3646 opt_default("bufsize", "1835008"); //224*1024*8;
3648 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3649 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3651 opt_default("ab", "448000");
3652 audio_sample_rate = 48000;
3654 } else if(!strncmp(arg, "dv", 2)) {
3658 opt_frame_size(norm ? "720x480" : "720x576");
3659 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3660 (norm ? "yuv411p" : "yuv420p"));
3661 opt_frame_rate(frame_rates[norm]);
3663 audio_sample_rate = 48000;
3667 fprintf(stderr, "Unknown target: %s\n", arg);
3672 static void opt_vstats_file (const char *arg)
3674 av_free (vstats_filename);
3675 vstats_filename=av_strdup (arg);
3678 static void opt_vstats (void)
3681 time_t today2 = time(NULL);
3682 struct tm *today = localtime(&today2);
3684 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3686 opt_vstats_file(filename);
3689 static int opt_bsf(const char *opt, const char *arg)
3691 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3692 AVBitStreamFilterContext **bsfp;
3695 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3699 bsfp= *opt == 'v' ? &video_bitstream_filters :
3700 *opt == 'a' ? &audio_bitstream_filters :
3701 &subtitle_bitstream_filters;
3703 bsfp= &(*bsfp)->next;
3710 static int opt_preset(const char *opt, const char *arg)
3713 char tmp[1000], tmp2[1000];
3715 const char *base[3]= { getenv("HOME"),
3720 for(i=!base[0]; i<3 && !f; i++){
3721 snprintf(tmp, sizeof(tmp), "%s/%sffmpeg/%s.ffpreset", base[i], i ? "" : ".", arg);
3724 char *codec_name= *opt == 'v' ? video_codec_name :
3725 *opt == 'a' ? audio_codec_name :
3726 subtitle_codec_name;
3727 snprintf(tmp, sizeof(tmp), "%s/%sffmpeg/%s-%s.ffpreset", base[i], i ? "" : ".", codec_name, arg);
3733 fprintf(stderr, "Preset file not found\n");
3738 int e= fscanf(f, "%999[^=]=%999[^\n]\n", tmp, tmp2);
3740 fprintf(stderr, "Preset file invalid\n");
3743 if(!strcmp(tmp, "acodec")){
3744 opt_audio_codec(tmp2);
3745 }else if(!strcmp(tmp, "vcodec")){
3746 opt_video_codec(tmp2);
3747 }else if(!strcmp(tmp, "scodec")){
3748 opt_subtitle_codec(tmp2);
3750 opt_default(tmp, tmp2);
3758 static const OptionDef options[] = {
3760 { "L", OPT_EXIT, {(void*)show_license}, "show license" },
3761 { "h", OPT_EXIT, {(void*)show_help}, "show help" },
3762 { "version", OPT_EXIT, {(void*)show_version}, "show version" },
3763 { "formats", OPT_EXIT, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3764 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3765 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3766 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3767 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3768 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3769 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3770 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3771 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3772 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3773 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
3774 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3775 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3776 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3777 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3778 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3779 { "genre", HAS_ARG | OPT_STRING, {(void*)&str_genre}, "set the genre", "string" },
3780 { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3781 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3782 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3783 "add timings for benchmarking" },
3784 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3785 "dump each input packet" },
3786 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3787 "when dumping packets, also dump the payload" },
3788 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3789 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3790 { "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)", "" },
3791 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set the logging verbosity level", "number" },
3792 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3793 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3794 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3795 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3796 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3797 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3798 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3799 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3800 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3801 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3804 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3805 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3806 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3807 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3808 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3809 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3810 { "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" },
3811 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3812 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3813 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3814 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3815 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3816 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3817 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3818 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3819 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3820 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3821 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3822 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3823 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3824 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3825 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3826 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
3827 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3828 "use same video quality as source (implies VBR)" },
3829 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3830 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3831 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3832 "deinterlace pictures" },
3833 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3834 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3835 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3837 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3839 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3840 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3841 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3842 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3843 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3844 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3845 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3848 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3849 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3850 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3851 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3852 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3853 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3854 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3855 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3856 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3857 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3858 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3859 { "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" },
3861 /* subtitle options */
3862 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3863 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3864 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3865 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3868 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3869 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3870 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3873 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3874 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3876 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3877 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3878 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3880 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3881 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3882 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3884 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3888 int main(int argc, char **argv)
3893 avcodec_register_all();
3894 avdevice_register_all();
3897 if(isatty(STDIN_FILENO))
3898 url_set_interrupt_cb(decode_interrupt_cb);
3900 for(i=0; i<CODEC_TYPE_NB; i++){
3901 avctx_opts[i]= avcodec_alloc_context2(i);
3903 avformat_opts = av_alloc_format_context();
3904 sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3913 parse_options(argc, argv, options, opt_output_file);
3915 /* file converter / grab */
3916 if (nb_output_files <= 0) {
3917 fprintf(stderr, "Must supply at least one output file\n");
3921 if (nb_input_files == 0) {
3922 fprintf(stderr, "Must supply at least one input file\n");
3927 av_encode(output_files, nb_output_files, input_files, nb_input_files,
3928 stream_maps, nb_stream_maps);
3929 ti = getutime() - ti;
3931 printf("bench: utime=%0.3fs\n", ti / 1000000.0);