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
30 #include "libavformat/avformat.h"
31 #include "libavdevice/avdevice.h"
32 #include "libswscale/swscale.h"
33 #include "libavformat/framehook.h"
34 #include "libavcodec/opt.h"
35 #include "libavutil/fifo.h"
36 #include "libavutil/avstring.h"
37 #include "libavformat/os_support.h"
39 #ifdef HAVE_SYS_RESOURCE_H
40 #include <sys/resource.h>
41 #elif defined(HAVE_GETPROCESSTIMES)
45 #if defined(HAVE_TERMIOS_H)
48 #include <sys/ioctl.h>
51 #elif defined(HAVE_CONIO_H)
54 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
65 static const char program_name[] = "FFmpeg";
66 static const int program_birth_year = 2000;
68 /* select an input stream for an output stream */
69 typedef struct AVStreamMap {
73 int sync_stream_index;
76 /** select an input file for an output file */
77 typedef struct AVMetaDataMap {
82 static const OptionDef options[];
86 static AVFormatContext *input_files[MAX_FILES];
87 static int64_t input_files_ts_offset[MAX_FILES];
88 static int nb_input_files = 0;
90 static AVFormatContext *output_files[MAX_FILES];
91 static int nb_output_files = 0;
93 static AVStreamMap stream_maps[MAX_FILES];
94 static int nb_stream_maps;
96 static AVMetaDataMap meta_data_maps[MAX_FILES];
97 static int nb_meta_data_maps;
99 static AVInputFormat *file_iformat;
100 static AVOutputFormat *file_oformat;
101 static int frame_width = 0;
102 static int frame_height = 0;
103 static float frame_aspect_ratio = 0;
104 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
105 static int frame_padtop = 0;
106 static int frame_padbottom = 0;
107 static int frame_padleft = 0;
108 static int frame_padright = 0;
109 static int padcolor[3] = {16,128,128}; /* default to black */
110 static int frame_topBand = 0;
111 static int frame_bottomBand = 0;
112 static int frame_leftBand = 0;
113 static int frame_rightBand = 0;
114 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
115 static AVRational frame_rate = (AVRational) {0,0};
116 static float video_qscale = 0;
117 static int video_qdiff = 3;
118 static uint16_t *intra_matrix = NULL;
119 static uint16_t *inter_matrix = NULL;
120 #if 0 //experimental, (can be removed)
121 static float video_rc_qsquish=1.0;
122 static float video_rc_qmod_amp=0;
123 static int video_rc_qmod_freq=0;
125 static const char *video_rc_override_string=NULL;
126 static int video_disable = 0;
127 static int video_discard = 0;
128 static char *video_codec_name = NULL;
129 static int video_codec_tag = 0;
130 static int same_quality = 0;
131 static int do_deinterlace = 0;
132 static int strict = 0;
133 static int top_field_first = -1;
134 static int me_threshold = 0;
135 static int intra_dc_precision = 8;
136 static int loop_input = 0;
137 static int loop_output = AVFMT_NOOUTPUTLOOP;
138 static int qp_hist = 0;
140 static int intra_only = 0;
141 static int audio_sample_rate = 44100;
142 #define QSCALE_NONE -99999
143 static float audio_qscale = QSCALE_NONE;
144 static int audio_disable = 0;
145 static int audio_channels = 1;
146 static char *audio_codec_name = NULL;
147 static int audio_codec_tag = 0;
148 static char *audio_language = NULL;
150 static int subtitle_disable = 0;
151 static char *subtitle_codec_name = NULL;
152 static char *subtitle_language = NULL;
154 static float mux_preload= 0.5;
155 static float mux_max_delay= 0.7;
157 static int64_t recording_time = 0;
158 static int64_t start_time = 0;
159 static int64_t rec_timestamp = 0;
160 static int64_t input_ts_offset = 0;
161 static int file_overwrite = 0;
162 static char *str_title = NULL;
163 static char *str_author = NULL;
164 static char *str_copyright = NULL;
165 static char *str_comment = NULL;
166 static char *str_genre = NULL;
167 static char *str_album = NULL;
168 static int do_benchmark = 0;
169 static int do_hex_dump = 0;
170 static int do_pkt_dump = 0;
171 static int do_psnr = 0;
172 static int do_pass = 0;
173 static char *pass_logfilename = NULL;
174 static int audio_stream_copy = 0;
175 static int video_stream_copy = 0;
176 static int subtitle_stream_copy = 0;
177 static int video_sync_method= 1;
178 static int audio_sync_method= 0;
179 static float audio_drift_threshold= 0.1;
180 static int copy_ts= 0;
181 static int opt_shortest = 0; //
182 static int video_global_header = 0;
183 static char *vstats_filename;
184 static FILE *vstats_file;
185 static int opt_programid = 0;
187 static int rate_emu = 0;
189 static int video_channel = 0;
190 static char *video_standard;
192 static int audio_volume = 256;
194 static int using_stdin = 0;
195 static int using_vhook = 0;
196 static int verbose = 1;
197 static int thread_count= 1;
198 static int q_pressed = 0;
199 static int64_t video_size = 0;
200 static int64_t audio_size = 0;
201 static int64_t extra_size = 0;
202 static int nb_frames_dup = 0;
203 static int nb_frames_drop = 0;
204 static int input_sync;
205 static uint64_t limit_filesize = 0; //
207 static int pgmyuv_compatibility_hack=0;
208 static float dts_delta_threshold = 10;
210 static unsigned int sws_flags = SWS_BICUBIC;
212 static const char **opt_names;
213 static int opt_name_count;
214 static AVCodecContext *avctx_opts[CODEC_TYPE_NB];
215 static AVFormatContext *avformat_opts;
216 static struct SwsContext *sws_opts;
217 static int64_t timer_start;
219 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
220 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
221 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
222 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
224 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
226 struct AVInputStream;
228 typedef struct AVOutputStream {
229 int file_index; /* file index */
230 int index; /* stream index in the output file */
231 int source_index; /* AVInputStream index */
232 AVStream *st; /* stream in the output file */
233 int encoding_needed; /* true if encoding needed for this stream */
235 /* input pts and corresponding output pts
237 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
238 struct AVInputStream *sync_ist; /* input stream to sync against */
239 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
242 AVFrame pict_tmp; /* temporary image for resampling */
243 struct SwsContext *img_resample_ctx; /* for image resampling */
247 int topBand; /* cropping area sizes */
251 int padtop; /* padding area sizes */
258 ReSampleContext *resample; /* for audio resampling */
259 AVFifoBuffer fifo; /* for compression: one audio fifo per codec */
263 typedef struct AVInputStream {
267 int discard; /* true if stream data should be discarded */
268 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
269 int64_t sample_index; /* current sample */
271 int64_t start; /* time when read started */
272 unsigned long frame; /* current frame */
273 int64_t next_pts; /* synthetic pts for cases where pkt.pts
275 int64_t pts; /* current pts */
276 int is_start; /* is 1 at the start and after a discontinuity */
279 typedef struct AVInputFile {
280 int eof_reached; /* true if eof reached */
281 int ist_index; /* index of first stream in ist_table */
282 int buffer_size; /* current total buffer size */
283 int nb_streams; /* nb streams we are aware of */
286 #ifdef HAVE_TERMIOS_H
288 /* init terminal so that we can grab keys */
289 static struct termios oldtty;
292 static void term_exit(void)
294 #ifdef HAVE_TERMIOS_H
295 tcsetattr (0, TCSANOW, &oldtty);
299 static volatile sig_atomic_t received_sigterm = 0;
302 sigterm_handler(int sig)
304 received_sigterm = sig;
308 static void term_init(void)
310 #ifdef HAVE_TERMIOS_H
316 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
317 |INLCR|IGNCR|ICRNL|IXON);
318 tty.c_oflag |= OPOST;
319 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
320 tty.c_cflag &= ~(CSIZE|PARENB);
325 tcsetattr (0, TCSANOW, &tty);
326 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
329 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
330 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
332 register a function to be called at normal program termination
335 #ifdef CONFIG_BEOS_NETSERVER
336 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
340 /* read a key without blocking */
341 static int read_key(void)
343 #if defined(HAVE_TERMIOS_H)
346 #ifndef CONFIG_BEOS_NETSERVER
354 n = select(1, &rfds, NULL, NULL, &tv);
363 #elif defined(HAVE_CONIO_H)
370 static int decode_interrupt_cb(void)
372 return q_pressed || (q_pressed = read_key() == 'q');
375 static int av_exit(int ret)
380 for(i=0;i<nb_output_files;i++) {
381 /* maybe av_close_output_file ??? */
382 AVFormatContext *s = output_files[i];
384 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
386 for(j=0;j<s->nb_streams;j++) {
387 av_free(s->streams[j]->codec);
388 av_free(s->streams[j]);
392 for(i=0;i<nb_input_files;i++)
393 av_close_input_file(input_files[i]);
397 av_free(intra_matrix);
398 av_free(inter_matrix);
402 av_free(vstats_filename);
406 av_free(video_codec_name);
407 av_free(audio_codec_name);
408 av_free(subtitle_codec_name);
410 av_free(video_standard);
412 #ifdef CONFIG_POWERPC_PERF
413 extern void powerpc_display_perf_report(void);
414 powerpc_display_perf_report();
415 #endif /* CONFIG_POWERPC_PERF */
417 if (received_sigterm) {
419 "Received signal %d: terminating.\n",
420 (int) received_sigterm);
424 exit(ret); /* not all OS-es handle main() return value */
428 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
433 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
436 /* copy stream format */
437 s->nb_streams = ic->nb_streams;
438 for(i=0;i<ic->nb_streams;i++) {
441 // FIXME: a more elegant solution is needed
442 st = av_mallocz(sizeof(AVStream));
443 memcpy(st, ic->streams[i], sizeof(AVStream));
444 st->codec = avcodec_alloc_context();
445 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
449 av_close_input_file(ic);
454 get_sync_ipts(const AVOutputStream *ost)
456 const AVInputStream *ist = ost->sync_ist;
457 return (double)(ist->pts - start_time)/AV_TIME_BASE;
460 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
464 AVPacket new_pkt= *pkt;
465 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
466 &new_pkt.data, &new_pkt.size,
467 pkt->data, pkt->size,
468 pkt->flags & PKT_FLAG_KEY);
471 new_pkt.destruct= av_destruct_packet;
473 fprintf(stderr, "%s failed for stream %d, codec %s",
474 bsfc->filter->name, pkt->stream_index,
475 avctx->codec ? avctx->codec->name : "copy");
483 ret= av_interleaved_write_frame(s, pkt);
485 print_error("av_interleaved_write_frame()", ret);
490 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
492 static void do_audio_out(AVFormatContext *s,
495 unsigned char *buf, int size)
498 static uint8_t *audio_buf = NULL;
499 static uint8_t *audio_out = NULL;
500 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
502 int size_out, frame_bytes, ret;
503 AVCodecContext *enc= ost->st->codec;
504 AVCodecContext *dec= ist->st->codec;
506 /* SC: dynamic allocation of buffers */
508 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
510 audio_out = av_malloc(audio_out_size);
511 if (!audio_buf || !audio_out)
512 return; /* Should signal an error ! */
514 if (enc->channels != dec->channels)
515 ost->audio_resample = 1;
517 if (ost->audio_resample && !ost->resample) {
518 ost->resample = audio_resample_init(enc->channels, dec->channels,
519 enc->sample_rate, dec->sample_rate);
520 if (!ost->resample) {
521 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
522 dec->channels, dec->sample_rate,
523 enc->channels, enc->sample_rate);
528 if(audio_sync_method){
529 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
530 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
531 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
532 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
534 //FIXME resample delay
535 if(fabs(delta) > 50){
536 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
538 byte_delta= FFMAX(byte_delta, -size);
542 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
547 static uint8_t *input_tmp= NULL;
548 input_tmp= av_realloc(input_tmp, byte_delta + size);
550 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
553 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
555 memset(input_tmp, 0, byte_delta);
556 memcpy(input_tmp + byte_delta, buf, size);
560 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
562 }else if(audio_sync_method>1){
563 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
564 assert(ost->audio_resample);
566 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
567 // 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));
568 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
572 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
573 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
575 if (ost->audio_resample) {
577 size_out = audio_resample(ost->resample,
578 (short *)buftmp, (short *)buf,
579 size / (ist->st->codec->channels * 2));
580 size_out = size_out * enc->channels * 2;
586 /* now encode as many frames as possible */
587 if (enc->frame_size > 1) {
588 /* output resampled raw samples */
589 av_fifo_realloc(&ost->fifo, av_fifo_size(&ost->fifo) + size_out + 1);
590 av_fifo_write(&ost->fifo, buftmp, size_out);
592 frame_bytes = enc->frame_size * 2 * enc->channels;
594 while (av_fifo_read(&ost->fifo, audio_buf, frame_bytes) == 0) {
596 av_init_packet(&pkt);
598 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
600 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
603 pkt.stream_index= ost->index;
606 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
607 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
608 pkt.flags |= PKT_FLAG_KEY;
609 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
611 ost->sync_opts += enc->frame_size;
615 av_init_packet(&pkt);
617 ost->sync_opts += size_out / (2 * enc->channels);
619 /* output a pcm frame */
620 /* XXX: change encoding codec API to avoid this ? */
621 switch(enc->codec->id) {
622 case CODEC_ID_PCM_S32LE:
623 case CODEC_ID_PCM_S32BE:
624 case CODEC_ID_PCM_U32LE:
625 case CODEC_ID_PCM_U32BE:
626 size_out = size_out << 1;
628 case CODEC_ID_PCM_S24LE:
629 case CODEC_ID_PCM_S24BE:
630 case CODEC_ID_PCM_U24LE:
631 case CODEC_ID_PCM_U24BE:
632 case CODEC_ID_PCM_S24DAUD:
633 size_out = size_out / 2 * 3;
635 case CODEC_ID_PCM_S16LE:
636 case CODEC_ID_PCM_S16BE:
637 case CODEC_ID_PCM_U16LE:
638 case CODEC_ID_PCM_U16BE:
641 size_out = size_out >> 1;
644 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
645 ret = avcodec_encode_audio(enc, audio_out, size_out,
648 pkt.stream_index= ost->index;
651 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
652 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
653 pkt.flags |= PKT_FLAG_KEY;
654 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
658 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
662 AVPicture picture_tmp;
665 dec = ist->st->codec;
667 /* deinterlace : must be done before any resize */
668 if (do_deinterlace || using_vhook) {
671 /* create temporary picture */
672 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
673 buf = av_malloc(size);
677 picture2 = &picture_tmp;
678 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
681 if(avpicture_deinterlace(picture2, picture,
682 dec->pix_fmt, dec->width, dec->height) < 0) {
683 /* if error, do not deinterlace */
689 av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
696 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,
697 1000000 * ist->pts / AV_TIME_BASE);
699 if (picture != picture2)
700 *picture = *picture2;
704 /* we begin to correct av delay at this threshold */
705 #define AV_DELAY_MAX 0.100
707 static void do_subtitle_out(AVFormatContext *s,
713 static uint8_t *subtitle_out = NULL;
714 int subtitle_out_max_size = 65536;
715 int subtitle_out_size, nb, i;
719 if (pts == AV_NOPTS_VALUE) {
720 fprintf(stderr, "Subtitle packets must have a pts\n");
724 enc = ost->st->codec;
727 subtitle_out = av_malloc(subtitle_out_max_size);
730 /* Note: DVB subtitle need one packet to draw them and one other
731 packet to clear them */
732 /* XXX: signal it in the codec context ? */
733 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
738 for(i = 0; i < nb; i++) {
739 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
740 subtitle_out_max_size, sub);
742 av_init_packet(&pkt);
743 pkt.stream_index = ost->index;
744 pkt.data = subtitle_out;
745 pkt.size = subtitle_out_size;
746 pkt.pts = av_rescale_q(pts, ist->st->time_base, ost->st->time_base);
747 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
748 /* XXX: the pts correction is handled here. Maybe handling
749 it in the codec would be better */
751 pkt.pts += 90 * sub->start_display_time;
753 pkt.pts += 90 * sub->end_display_time;
755 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
759 static int bit_buffer_size= 1024*256;
760 static uint8_t *bit_buffer= NULL;
762 static void do_video_out(AVFormatContext *s,
768 int nb_frames, i, ret;
769 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
770 AVFrame picture_crop_temp, picture_pad_temp;
771 AVCodecContext *enc, *dec;
773 avcodec_get_frame_defaults(&picture_crop_temp);
774 avcodec_get_frame_defaults(&picture_pad_temp);
776 enc = ost->st->codec;
777 dec = ist->st->codec;
779 /* by default, we output a single frame */
784 if(video_sync_method){
786 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
787 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
790 else if (video_sync_method == 2)
791 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
792 else if (vdelta > 1.1)
793 nb_frames = lrintf(vdelta);
794 //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);
798 fprintf(stderr, "*** drop!\n");
799 }else if (nb_frames > 1) {
800 nb_frames_dup += nb_frames;
802 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
805 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
807 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
811 if (ost->video_crop) {
812 if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
813 av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
816 formatted_picture = &picture_crop_temp;
818 formatted_picture = in_picture;
821 final_picture = formatted_picture;
822 padding_src = formatted_picture;
823 resampling_dst = &ost->pict_tmp;
824 if (ost->video_pad) {
825 final_picture = &ost->pict_tmp;
826 if (ost->video_resample) {
827 if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
828 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
831 resampling_dst = &picture_pad_temp;
835 if (ost->video_resample) {
837 final_picture = &ost->pict_tmp;
838 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
839 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
842 if (ost->video_pad) {
843 av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
844 enc->height, enc->width, enc->pix_fmt,
845 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
848 /* duplicates frame if needed */
849 for(i=0;i<nb_frames;i++) {
851 av_init_packet(&pkt);
852 pkt.stream_index= ost->index;
854 if (s->oformat->flags & AVFMT_RAWPICTURE) {
855 /* raw pictures are written as AVPicture structure to
856 avoid any copies. We support temorarily the older
858 AVFrame* old_frame = enc->coded_frame;
859 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
860 pkt.data= (uint8_t *)final_picture;
861 pkt.size= sizeof(AVPicture);
862 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
863 pkt.flags |= PKT_FLAG_KEY;
865 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
866 enc->coded_frame = old_frame;
870 big_picture= *final_picture;
871 /* better than nothing: use input picture interlaced
873 big_picture.interlaced_frame = in_picture->interlaced_frame;
874 if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
875 if(top_field_first == -1)
876 big_picture.top_field_first = in_picture->top_field_first;
878 big_picture.top_field_first = top_field_first;
881 /* handles sameq here. This is not correct because it may
882 not be a global option */
884 big_picture.quality = ist->st->quality;
886 big_picture.quality = ost->st->quality;
888 big_picture.pict_type = 0;
889 // big_picture.pts = AV_NOPTS_VALUE;
890 big_picture.pts= ost->sync_opts;
891 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
892 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
893 ret = avcodec_encode_video(enc,
894 bit_buffer, bit_buffer_size,
897 fprintf(stderr, "Video encoding failed\n");
900 //enc->frame_number = enc->real_pict_num;
902 pkt.data= bit_buffer;
904 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
905 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
906 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
907 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
908 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
910 if(enc->coded_frame && enc->coded_frame->key_frame)
911 pkt.flags |= PKT_FLAG_KEY;
912 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
914 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
915 // enc->frame_number-1, enc->real_pict_num, ret,
917 /* if two pass, output log */
918 if (ost->logfile && enc->stats_out) {
919 fprintf(ost->logfile, "%s", enc->stats_out);
928 static double psnr(double d){
929 return -10.0*log(d)/log(10.0);
932 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
937 double ti1, bitrate, avg_bitrate;
939 /* this is executed just the first time do_video_stats is called */
941 vstats_file = fopen(vstats_filename, "w");
948 enc = ost->st->codec;
949 if (enc->codec_type == CODEC_TYPE_VIDEO) {
950 frame_number = ost->frame_number;
951 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
952 if (enc->flags&CODEC_FLAG_PSNR)
953 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
955 fprintf(vstats_file,"f_size= %6d ", frame_size);
956 /* compute pts value */
957 ti1 = ost->sync_opts * av_q2d(enc->time_base);
961 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
962 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
963 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
964 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
965 fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
969 static void print_report(AVFormatContext **output_files,
970 AVOutputStream **ost_table, int nb_ostreams,
975 AVFormatContext *oc, *os;
978 int frame_number, vid, i;
979 double bitrate, ti1, pts;
980 static int64_t last_time = -1;
981 static int qp_histogram[52];
983 if (!is_last_report) {
985 /* display the report every 0.5 seconds */
986 cur_time = av_gettime();
987 if (last_time == -1) {
988 last_time = cur_time;
991 if ((cur_time - last_time) < 500000)
993 last_time = cur_time;
997 oc = output_files[0];
999 total_size = url_fsize(oc->pb);
1000 if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1001 total_size= url_ftell(oc->pb);
1006 for(i=0;i<nb_ostreams;i++) {
1008 os = output_files[ost->file_index];
1009 enc = ost->st->codec;
1010 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1011 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1012 enc->coded_frame && !ost->st->stream_copy ?
1013 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1015 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1016 float t = (av_gettime()-timer_start) / 1000000.0;
1018 frame_number = ost->frame_number;
1019 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1020 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1021 enc->coded_frame && !ost->st->stream_copy ?
1022 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1024 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1025 if(qp_hist && enc->coded_frame){
1027 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1028 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
1031 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1033 if (enc->flags&CODEC_FLAG_PSNR){
1035 double error, error_sum=0;
1036 double scale, scale_sum=0;
1037 char type[3]= {'Y','U','V'};
1038 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1041 error= enc->error[j];
1042 scale= enc->width*enc->height*255.0*255.0*frame_number;
1044 error= enc->coded_frame->error[j];
1045 scale= enc->width*enc->height*255.0*255.0;
1050 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1052 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1056 /* compute min output value */
1057 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1058 if ((pts < ti1) && (pts > 0))
1064 if (verbose || is_last_report) {
1065 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1067 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1068 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1069 (double)total_size / 1024, ti1, bitrate);
1072 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1073 nb_frames_dup, nb_frames_drop);
1076 fprintf(stderr, "%s \r", buf);
1081 if (is_last_report && verbose >= 0){
1082 int64_t raw= audio_size + video_size + extra_size;
1083 fprintf(stderr, "\n");
1084 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1088 100.0*(total_size - raw)/raw
1093 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1094 static int output_packet(AVInputStream *ist, int ist_index,
1095 AVOutputStream **ost_table, int nb_ostreams,
1096 const AVPacket *pkt)
1098 AVFormatContext *os;
1099 AVOutputStream *ost;
1103 int data_size, got_picture;
1105 void *buffer_to_free;
1106 static unsigned int samples_size= 0;
1107 static short *samples= NULL;
1108 AVSubtitle subtitle, *subtitle_to_free;
1111 if(ist->next_pts == AV_NOPTS_VALUE)
1112 ist->next_pts= ist->pts;
1121 if(pkt->dts != AV_NOPTS_VALUE)
1122 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1128 ist->pts= ist->next_pts;
1130 if(len && len != pkt->size && verbose>0)
1131 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1133 /* decode the packet if needed */
1134 data_buf = NULL; /* fail safe */
1136 subtitle_to_free = NULL;
1137 if (ist->decoding_needed) {
1138 switch(ist->st->codec->codec_type) {
1139 case CODEC_TYPE_AUDIO:{
1141 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE));
1142 data_size= samples_size;
1143 /* XXX: could avoid copy if PCM 16 bits with same
1144 endianness as CPU */
1145 ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1151 /* Some bug in mpeg audio decoder gives */
1152 /* data_size < 0, it seems they are overflows */
1153 if (data_size <= 0) {
1154 /* no audio frame */
1157 data_buf = (uint8_t *)samples;
1158 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1159 (ist->st->codec->sample_rate * ist->st->codec->channels);
1161 case CODEC_TYPE_VIDEO:
1162 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1163 /* XXX: allocate picture correctly */
1164 avcodec_get_frame_defaults(&picture);
1166 ret = avcodec_decode_video(ist->st->codec,
1167 &picture, &got_picture, ptr, len);
1168 ist->st->quality= picture.quality;
1172 /* no picture yet */
1173 goto discard_packet;
1175 if (ist->st->codec->time_base.num != 0) {
1176 ist->next_pts += ((int64_t)AV_TIME_BASE *
1177 ist->st->codec->time_base.num) /
1178 ist->st->codec->time_base.den;
1182 case CODEC_TYPE_SUBTITLE:
1183 ret = avcodec_decode_subtitle(ist->st->codec,
1184 &subtitle, &got_subtitle, ptr, len);
1187 if (!got_subtitle) {
1188 goto discard_packet;
1190 subtitle_to_free = &subtitle;
1197 switch(ist->st->codec->codec_type) {
1198 case CODEC_TYPE_AUDIO:
1199 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1200 ist->st->codec->sample_rate;
1202 case CODEC_TYPE_VIDEO:
1203 if (ist->st->codec->time_base.num != 0) {
1204 ist->next_pts += ((int64_t)AV_TIME_BASE *
1205 ist->st->codec->time_base.num) /
1206 ist->st->codec->time_base.den;
1216 buffer_to_free = NULL;
1217 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1218 pre_process_video_frame(ist, (AVPicture *)&picture,
1222 // preprocess audio (volume)
1223 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1224 if (audio_volume != 256) {
1227 for(i=0;i<(data_size / sizeof(short));i++) {
1228 int v = ((*volp) * audio_volume + 128) >> 8;
1229 if (v < -32768) v = -32768;
1230 if (v > 32767) v = 32767;
1236 /* frame rate emulation */
1237 if (ist->st->codec->rate_emu) {
1238 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1239 int64_t now = av_gettime() - ist->start;
1247 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1248 is the one of the next displayed one */
1249 /* XXX: add mpeg4 too ? */
1250 if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1251 if (ist->st->codec->pict_type != B_TYPE) {
1253 tmp = ist->last_ip_pts;
1254 ist->last_ip_pts = ist->frac_pts.val;
1255 ist->frac_pts.val = tmp;
1259 /* if output time reached then transcode raw format,
1260 encode packets and output them */
1261 if (start_time == 0 || ist->pts >= start_time)
1262 for(i=0;i<nb_ostreams;i++) {
1266 if (ost->source_index == ist_index) {
1267 os = output_files[ost->file_index];
1270 printf("%d: got pts=%0.3f %0.3f\n", i,
1271 (double)pkt->pts / AV_TIME_BASE,
1272 ((double)ist->pts / AV_TIME_BASE) -
1273 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1275 /* set the input output pts pairs */
1276 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1278 if (ost->encoding_needed) {
1279 switch(ost->st->codec->codec_type) {
1280 case CODEC_TYPE_AUDIO:
1281 do_audio_out(os, ost, ist, data_buf, data_size);
1283 case CODEC_TYPE_VIDEO:
1284 do_video_out(os, ost, ist, &picture, &frame_size);
1285 video_size += frame_size;
1286 if (vstats_filename && frame_size)
1287 do_video_stats(os, ost, frame_size);
1289 case CODEC_TYPE_SUBTITLE:
1290 do_subtitle_out(os, ost, ist, &subtitle,
1297 AVFrame avframe; //FIXME/XXX remove this
1299 av_init_packet(&opkt);
1301 if (!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY))
1304 /* no reencoding needed : output the packet directly */
1305 /* force the input stream PTS */
1307 avcodec_get_frame_defaults(&avframe);
1308 ost->st->codec->coded_frame= &avframe;
1309 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1311 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1312 audio_size += data_size;
1313 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1314 video_size += data_size;
1318 opkt.stream_index= ost->index;
1319 if(pkt->pts != AV_NOPTS_VALUE)
1320 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1322 opkt.pts= AV_NOPTS_VALUE;
1324 if (pkt->dts == AV_NOPTS_VALUE)
1325 opkt.dts = av_rescale_q(ist->next_pts, AV_TIME_BASE_Q, ost->st->time_base);
1327 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1329 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1330 opkt.flags= pkt->flags;
1332 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1333 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1334 opkt.destruct= av_destruct_packet;
1336 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1337 ost->st->codec->frame_number++;
1338 ost->frame_number++;
1339 av_free_packet(&opkt);
1343 av_free(buffer_to_free);
1344 /* XXX: allocate the subtitles in the codec ? */
1345 if (subtitle_to_free) {
1346 if (subtitle_to_free->rects != NULL) {
1347 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1348 av_free(subtitle_to_free->rects[i].bitmap);
1349 av_free(subtitle_to_free->rects[i].rgba_palette);
1351 av_freep(&subtitle_to_free->rects);
1353 subtitle_to_free->num_rects = 0;
1354 subtitle_to_free = NULL;
1361 for(i=0;i<nb_ostreams;i++) {
1363 if (ost->source_index == ist_index) {
1364 AVCodecContext *enc= ost->st->codec;
1365 os = output_files[ost->file_index];
1367 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1369 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1372 if (ost->encoding_needed) {
1376 av_init_packet(&pkt);
1377 pkt.stream_index= ost->index;
1379 switch(ost->st->codec->codec_type) {
1380 case CODEC_TYPE_AUDIO:
1381 fifo_bytes = av_fifo_size(&ost->fifo);
1383 /* encode any samples remaining in fifo */
1384 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1385 int fs_tmp = enc->frame_size;
1386 enc->frame_size = fifo_bytes / (2 * enc->channels);
1387 if(av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes) == 0) {
1388 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1390 enc->frame_size = fs_tmp;
1393 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1396 pkt.flags |= PKT_FLAG_KEY;
1398 case CODEC_TYPE_VIDEO:
1399 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1401 if(enc->coded_frame && enc->coded_frame->key_frame)
1402 pkt.flags |= PKT_FLAG_KEY;
1403 if (ost->logfile && enc->stats_out) {
1404 fprintf(ost->logfile, "%s", enc->stats_out);
1413 pkt.data= bit_buffer;
1415 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1416 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1417 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1429 static void print_sdp(AVFormatContext **avc, int n)
1433 avf_sdp_create(avc, n, sdp, sizeof(sdp));
1434 printf("SDP:\n%s\n", sdp);
1437 static int stream_index_from_inputs(AVFormatContext **input_files,
1439 AVInputFile *file_table,
1440 AVInputStream **ist_table,
1441 enum CodecType type,
1445 for(z=0; z<nb_input_files; z++) {
1446 AVFormatContext *ic = input_files[z];
1447 for(p=0; p<ic->nb_programs; p++) {
1448 AVProgram *program = ic->programs[p];
1449 if(program->id != programid)
1451 for(q=0; q<program->nb_stream_indexes; q++) {
1452 int sidx = program->stream_index[q];
1453 int ris = file_table[z].ist_index + sidx;
1454 if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1464 * The following code is the main loop of the file converter
1466 static int av_encode(AVFormatContext **output_files,
1467 int nb_output_files,
1468 AVFormatContext **input_files,
1470 AVStreamMap *stream_maps, int nb_stream_maps)
1472 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1473 AVFormatContext *is, *os;
1474 AVCodecContext *codec, *icodec;
1475 AVOutputStream *ost, **ost_table = NULL;
1476 AVInputStream *ist, **ist_table = NULL;
1477 AVInputFile *file_table;
1481 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1485 /* input stream init */
1487 for(i=0;i<nb_input_files;i++) {
1488 is = input_files[i];
1489 file_table[i].ist_index = j;
1490 file_table[i].nb_streams = is->nb_streams;
1491 j += is->nb_streams;
1495 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1499 for(i=0;i<nb_istreams;i++) {
1500 ist = av_mallocz(sizeof(AVInputStream));
1506 for(i=0;i<nb_input_files;i++) {
1507 is = input_files[i];
1508 for(k=0;k<is->nb_streams;k++) {
1509 ist = ist_table[j++];
1510 ist->st = is->streams[k];
1511 ist->file_index = i;
1513 ist->discard = 1; /* the stream is discarded by default
1516 if (ist->st->codec->rate_emu) {
1517 ist->start = av_gettime();
1523 /* output stream init */
1525 for(i=0;i<nb_output_files;i++) {
1526 os = output_files[i];
1527 if (!os->nb_streams) {
1528 fprintf(stderr, "Output file does not contain any stream\n");
1531 nb_ostreams += os->nb_streams;
1533 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1534 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1538 /* Sanity check the mapping args -- do the input files & streams exist? */
1539 for(i=0;i<nb_stream_maps;i++) {
1540 int fi = stream_maps[i].file_index;
1541 int si = stream_maps[i].stream_index;
1543 if (fi < 0 || fi > nb_input_files - 1 ||
1544 si < 0 || si > file_table[fi].nb_streams - 1) {
1545 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1548 fi = stream_maps[i].sync_file_index;
1549 si = stream_maps[i].sync_stream_index;
1550 if (fi < 0 || fi > nb_input_files - 1 ||
1551 si < 0 || si > file_table[fi].nb_streams - 1) {
1552 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1557 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1560 for(i=0;i<nb_ostreams;i++) {
1561 ost = av_mallocz(sizeof(AVOutputStream));
1568 for(k=0;k<nb_output_files;k++) {
1569 os = output_files[k];
1570 for(i=0;i<os->nb_streams;i++) {
1572 ost = ost_table[n++];
1573 ost->file_index = k;
1575 ost->st = os->streams[i];
1576 if (nb_stream_maps > 0) {
1577 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1578 stream_maps[n-1].stream_index;
1580 /* Sanity check that the stream types match */
1581 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1582 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1583 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1584 ost->file_index, ost->index);
1591 j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1593 ost->source_index = j;
1597 /* get corresponding input stream index : we select the first one with the right type */
1599 for(j=0;j<nb_istreams;j++) {
1602 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1603 ost->source_index = j;
1611 if(! opt_programid) {
1612 /* try again and reuse existing stream */
1613 for(j=0;j<nb_istreams;j++) {
1615 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1616 ost->source_index = j;
1622 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1623 ost->file_index, ost->index);
1628 ist = ist_table[ost->source_index];
1630 ost->sync_ist = (nb_stream_maps > 0) ?
1631 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1632 stream_maps[n-1].sync_stream_index] : ist;
1636 /* for each output stream, we compute the right encoding parameters */
1637 for(i=0;i<nb_ostreams;i++) {
1639 os = output_files[ost->file_index];
1640 ist = ist_table[ost->source_index];
1642 codec = ost->st->codec;
1643 icodec = ist->st->codec;
1645 if (!ost->st->language[0])
1646 av_strlcpy(ost->st->language, ist->st->language,
1647 sizeof(ost->st->language));
1649 ost->st->disposition = ist->st->disposition;
1651 if (ost->st->stream_copy) {
1652 /* if stream_copy is selected, no need to decode or encode */
1653 codec->codec_id = icodec->codec_id;
1654 codec->codec_type = icodec->codec_type;
1656 if(!codec->codec_tag){
1657 if( !os->oformat->codec_tag
1658 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1659 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1660 codec->codec_tag = icodec->codec_tag;
1663 codec->bit_rate = icodec->bit_rate;
1664 codec->extradata= icodec->extradata;
1665 codec->extradata_size= icodec->extradata_size;
1666 if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1667 codec->time_base = icodec->time_base;
1669 codec->time_base = ist->st->time_base;
1670 switch(codec->codec_type) {
1671 case CODEC_TYPE_AUDIO:
1672 codec->sample_rate = icodec->sample_rate;
1673 codec->channels = icodec->channels;
1674 codec->frame_size = icodec->frame_size;
1675 codec->block_align= icodec->block_align;
1676 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1677 codec->block_align= 0;
1679 case CODEC_TYPE_VIDEO:
1681 fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1684 codec->pix_fmt = icodec->pix_fmt;
1685 codec->width = icodec->width;
1686 codec->height = icodec->height;
1687 codec->has_b_frames = icodec->has_b_frames;
1689 case CODEC_TYPE_SUBTITLE:
1695 switch(codec->codec_type) {
1696 case CODEC_TYPE_AUDIO:
1697 if (av_fifo_init(&ost->fifo, 1024))
1699 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1700 icodec->request_channels = codec->channels;
1701 ist->decoding_needed = 1;
1702 ost->encoding_needed = 1;
1704 case CODEC_TYPE_VIDEO:
1705 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1706 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1707 ost->video_resample = ((codec->width != icodec->width -
1708 (frame_leftBand + frame_rightBand) +
1709 (frame_padleft + frame_padright)) ||
1710 (codec->height != icodec->height -
1711 (frame_topBand + frame_bottomBand) +
1712 (frame_padtop + frame_padbottom)) ||
1713 (codec->pix_fmt != icodec->pix_fmt));
1714 if (ost->video_crop) {
1715 ost->topBand = frame_topBand;
1716 ost->leftBand = frame_leftBand;
1718 if (ost->video_pad) {
1719 ost->padtop = frame_padtop;
1720 ost->padleft = frame_padleft;
1721 ost->padbottom = frame_padbottom;
1722 ost->padright = frame_padright;
1723 if (!ost->video_resample) {
1724 avcodec_get_frame_defaults(&ost->pict_tmp);
1725 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1726 codec->width, codec->height ) )
1730 if (ost->video_resample) {
1731 avcodec_get_frame_defaults(&ost->pict_tmp);
1732 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1733 codec->width, codec->height ) ) {
1734 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1737 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1738 ost->img_resample_ctx = sws_getContext(
1739 icodec->width - (frame_leftBand + frame_rightBand),
1740 icodec->height - (frame_topBand + frame_bottomBand),
1742 codec->width - (frame_padleft + frame_padright),
1743 codec->height - (frame_padtop + frame_padbottom),
1745 sws_flags, NULL, NULL, NULL);
1746 if (ost->img_resample_ctx == NULL) {
1747 fprintf(stderr, "Cannot get resampling context\n");
1750 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1752 ost->encoding_needed = 1;
1753 ist->decoding_needed = 1;
1755 case CODEC_TYPE_SUBTITLE:
1756 ost->encoding_needed = 1;
1757 ist->decoding_needed = 1;
1764 if (ost->encoding_needed &&
1765 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1766 char logfilename[1024];
1771 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1773 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1774 if (codec->flags & CODEC_FLAG_PASS1) {
1775 f = fopen(logfilename, "w");
1777 perror(logfilename);
1782 /* read the log file */
1783 f = fopen(logfilename, "r");
1785 perror(logfilename);
1788 fseek(f, 0, SEEK_END);
1790 fseek(f, 0, SEEK_SET);
1791 logbuffer = av_malloc(size + 1);
1793 fprintf(stderr, "Could not allocate log buffer\n");
1796 size = fread(logbuffer, 1, size, f);
1798 logbuffer[size] = '\0';
1799 codec->stats_in = logbuffer;
1803 if(codec->codec_type == CODEC_TYPE_VIDEO){
1804 int size= codec->width * codec->height;
1805 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1810 bit_buffer = av_malloc(bit_buffer_size);
1814 /* dump the file output parameters - cannot be done before in case
1816 for(i=0;i<nb_output_files;i++) {
1817 dump_format(output_files[i], i, output_files[i]->filename, 1);
1820 /* dump the stream mapping */
1822 fprintf(stderr, "Stream mapping:\n");
1823 for(i=0;i<nb_ostreams;i++) {
1825 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1826 ist_table[ost->source_index]->file_index,
1827 ist_table[ost->source_index]->index,
1830 if (ost->sync_ist != ist_table[ost->source_index])
1831 fprintf(stderr, " [sync #%d.%d]",
1832 ost->sync_ist->file_index,
1833 ost->sync_ist->index);
1834 fprintf(stderr, "\n");
1838 /* open each encoder */
1839 for(i=0;i<nb_ostreams;i++) {
1841 if (ost->encoding_needed) {
1843 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1845 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1846 ost->file_index, ost->index);
1849 if (avcodec_open(ost->st->codec, codec) < 0) {
1850 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1851 ost->file_index, ost->index);
1854 extra_size += ost->st->codec->extradata_size;
1858 /* open each decoder */
1859 for(i=0;i<nb_istreams;i++) {
1861 if (ist->decoding_needed) {
1863 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1865 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1866 ist->st->codec->codec_id, ist->file_index, ist->index);
1869 if (avcodec_open(ist->st->codec, codec) < 0) {
1870 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1871 ist->file_index, ist->index);
1874 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1875 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1880 for(i=0;i<nb_istreams;i++) {
1882 is = input_files[ist->file_index];
1884 ist->next_pts = AV_NOPTS_VALUE;
1888 /* set meta data information from input file if required */
1889 for (i=0;i<nb_meta_data_maps;i++) {
1890 AVFormatContext *out_file;
1891 AVFormatContext *in_file;
1893 int out_file_index = meta_data_maps[i].out_file;
1894 int in_file_index = meta_data_maps[i].in_file;
1895 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1896 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1897 ret = AVERROR(EINVAL);
1900 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1901 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1902 ret = AVERROR(EINVAL);
1906 out_file = output_files[out_file_index];
1907 in_file = input_files[in_file_index];
1909 strcpy(out_file->title, in_file->title);
1910 strcpy(out_file->author, in_file->author);
1911 strcpy(out_file->copyright, in_file->copyright);
1912 strcpy(out_file->comment, in_file->comment);
1913 strcpy(out_file->album, in_file->album);
1914 out_file->year = in_file->year;
1915 out_file->track = in_file->track;
1916 strcpy(out_file->genre, in_file->genre);
1919 /* open files and write file headers */
1920 for(i=0;i<nb_output_files;i++) {
1921 os = output_files[i];
1922 if (av_write_header(os) < 0) {
1923 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1924 ret = AVERROR(EINVAL);
1927 if (strcmp(output_files[i]->oformat->name, "rtp")) {
1932 print_sdp(output_files, nb_output_files);
1935 if ( !using_stdin && verbose >= 0) {
1936 fprintf(stderr, "Press [q] to stop encoding\n");
1937 url_set_interrupt_cb(decode_interrupt_cb);
1942 timer_start = av_gettime();
1944 for(; received_sigterm == 0;) {
1945 int file_index, ist_index;
1953 /* if 'q' pressed, exits */
1957 /* read_key() returns 0 on EOF */
1963 /* select the stream that we must read now by looking at the
1964 smallest output pts */
1966 for(i=0;i<nb_ostreams;i++) {
1969 os = output_files[ost->file_index];
1970 ist = ist_table[ost->source_index];
1971 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1972 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1974 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1975 ipts = (double)ist->pts;
1976 if (!file_table[ist->file_index].eof_reached){
1977 if(ipts < ipts_min) {
1979 if(input_sync ) file_index = ist->file_index;
1981 if(opts < opts_min) {
1983 if(!input_sync) file_index = ist->file_index;
1986 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1991 /* if none, if is finished */
1992 if (file_index < 0) {
1996 /* finish if recording time exhausted */
1997 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
2000 /* finish if limit size exhausted */
2001 if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2004 /* read a frame from it and output it in the fifo */
2005 is = input_files[file_index];
2006 if (av_read_frame(is, &pkt) < 0) {
2007 file_table[file_index].eof_reached = 1;
2015 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2017 /* the following test is needed in case new streams appear
2018 dynamically in stream : we ignore them */
2019 if (pkt.stream_index >= file_table[file_index].nb_streams)
2020 goto discard_packet;
2021 ist_index = file_table[file_index].ist_index + pkt.stream_index;
2022 ist = ist_table[ist_index];
2024 goto discard_packet;
2026 if (pkt.dts != AV_NOPTS_VALUE)
2027 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2028 if (pkt.pts != AV_NOPTS_VALUE)
2029 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2031 // 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);
2032 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
2033 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2034 int64_t delta= pkt_dts - ist->next_pts;
2035 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2036 input_files_ts_offset[ist->file_index]-= delta;
2038 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2039 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2040 if(pkt.pts != AV_NOPTS_VALUE)
2041 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2045 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2046 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2049 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2050 ist->file_index, ist->index);
2052 av_free_packet(&pkt);
2057 av_free_packet(&pkt);
2059 /* dump report by using the output first video and audio streams */
2060 print_report(output_files, ost_table, nb_ostreams, 0);
2063 /* at the end of stream, we must flush the decoder buffers */
2064 for(i=0;i<nb_istreams;i++) {
2066 if (ist->decoding_needed) {
2067 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2073 /* write the trailer if needed and close file */
2074 for(i=0;i<nb_output_files;i++) {
2075 os = output_files[i];
2076 av_write_trailer(os);
2079 /* dump report by using the first video and audio streams */
2080 print_report(output_files, ost_table, nb_ostreams, 1);
2082 /* close each encoder */
2083 for(i=0;i<nb_ostreams;i++) {
2085 if (ost->encoding_needed) {
2086 av_freep(&ost->st->codec->stats_in);
2087 avcodec_close(ost->st->codec);
2091 /* close each decoder */
2092 for(i=0;i<nb_istreams;i++) {
2094 if (ist->decoding_needed) {
2095 avcodec_close(ist->st->codec);
2103 av_freep(&bit_buffer);
2104 av_free(file_table);
2107 for(i=0;i<nb_istreams;i++) {
2114 for(i=0;i<nb_ostreams;i++) {
2118 fclose(ost->logfile);
2119 ost->logfile = NULL;
2121 av_fifo_free(&ost->fifo); /* works even if fifo is not
2122 initialized but set to zero */
2123 av_free(ost->pict_tmp.data[0]);
2124 if (ost->video_resample)
2125 sws_freeContext(ost->img_resample_ctx);
2127 audio_resample_close(ost->resample);
2135 ret = AVERROR(ENOMEM);
2140 int file_read(const char *filename)
2143 unsigned char buffer[1024];
2146 if (url_open(&h, filename, O_RDONLY) < 0) {
2147 printf("could not open '%s'\n", filename);
2151 len = url_read(h, buffer, sizeof(buffer));
2154 for(i=0;i<len;i++) putchar(buffer[i]);
2161 static void opt_format(const char *arg)
2163 /* compatibility stuff for pgmyuv */
2164 if (!strcmp(arg, "pgmyuv")) {
2165 pgmyuv_compatibility_hack=1;
2166 // opt_image_format(arg);
2168 fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2171 file_iformat = av_find_input_format(arg);
2172 file_oformat = guess_format(arg, NULL, NULL);
2173 if (!file_iformat && !file_oformat) {
2174 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2179 extern int ffm_nopts;
2181 static int opt_default(const char *opt, const char *arg){
2183 const AVOption *o= NULL;
2184 int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
2186 for(type=0; type<CODEC_TYPE_NB; type++){
2187 const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
2189 o = av_set_string(avctx_opts[type], opt, arg);
2192 o = av_set_string(avformat_opts, opt, arg);
2194 o = av_set_string(sws_opts, opt, arg);
2197 o = av_set_string(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg);
2198 else if(opt[0] == 'v')
2199 o = av_set_string(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg);
2200 else if(opt[0] == 's')
2201 o = av_set_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg);
2206 // 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));
2208 //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
2209 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
2210 opt_names[opt_name_count++]= o->name;
2212 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
2213 /* disable generate of real time pts in ffm (need to be supressed anyway) */
2214 if(avctx_opts[0]->flags & CODEC_FLAG_BITEXACT)
2218 if(avctx_opts[0]->debug)
2219 av_log_set_level(AV_LOG_DEBUG);
2223 static void opt_video_rc_override_string(const char *arg)
2225 video_rc_override_string = arg;
2228 static int opt_me_threshold(const char *opt, const char *arg)
2230 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2234 static int opt_verbose(const char *opt, const char *arg)
2236 verbose = parse_number_or_die(opt, arg, OPT_INT64, AV_LOG_QUIET, AV_LOG_DEBUG);
2237 av_log_set_level(verbose);
2241 static void opt_frame_rate(const char *arg)
2243 if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2244 fprintf(stderr, "Incorrect frame rate\n");
2249 static int opt_bitrate(const char *opt, const char *arg)
2251 int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2253 opt_default(opt, arg);
2255 if (av_get_int(avctx_opts[codec_type], "b", NULL) < 1000)
2256 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2261 static void opt_frame_crop_top(const char *arg)
2263 frame_topBand = atoi(arg);
2264 if (frame_topBand < 0) {
2265 fprintf(stderr, "Incorrect top crop size\n");
2268 if ((frame_topBand % 2) != 0) {
2269 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2272 if ((frame_topBand) >= frame_height){
2273 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2276 frame_height -= frame_topBand;
2279 static void opt_frame_crop_bottom(const char *arg)
2281 frame_bottomBand = atoi(arg);
2282 if (frame_bottomBand < 0) {
2283 fprintf(stderr, "Incorrect bottom crop size\n");
2286 if ((frame_bottomBand % 2) != 0) {
2287 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2290 if ((frame_bottomBand) >= frame_height){
2291 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2294 frame_height -= frame_bottomBand;
2297 static void opt_frame_crop_left(const char *arg)
2299 frame_leftBand = atoi(arg);
2300 if (frame_leftBand < 0) {
2301 fprintf(stderr, "Incorrect left crop size\n");
2304 if ((frame_leftBand % 2) != 0) {
2305 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2308 if ((frame_leftBand) >= frame_width){
2309 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2312 frame_width -= frame_leftBand;
2315 static void opt_frame_crop_right(const char *arg)
2317 frame_rightBand = atoi(arg);
2318 if (frame_rightBand < 0) {
2319 fprintf(stderr, "Incorrect right crop size\n");
2322 if ((frame_rightBand % 2) != 0) {
2323 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2326 if ((frame_rightBand) >= frame_width){
2327 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2330 frame_width -= frame_rightBand;
2333 static void opt_frame_size(const char *arg)
2335 if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2336 fprintf(stderr, "Incorrect frame size\n");
2339 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2340 fprintf(stderr, "Frame size must be a multiple of 2\n");
2346 #define SCALEBITS 10
2347 #define ONE_HALF (1 << (SCALEBITS - 1))
2348 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2350 #define RGB_TO_Y(r, g, b) \
2351 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2352 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2354 #define RGB_TO_U(r1, g1, b1, shift)\
2355 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2356 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2358 #define RGB_TO_V(r1, g1, b1, shift)\
2359 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2360 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2362 static void opt_pad_color(const char *arg) {
2363 /* Input is expected to be six hex digits similar to
2364 how colors are expressed in html tags (but without the #) */
2365 int rgb = strtol(arg, NULL, 16);
2369 g = ((rgb >> 8) & 255);
2372 padcolor[0] = RGB_TO_Y(r,g,b);
2373 padcolor[1] = RGB_TO_U(r,g,b,0);
2374 padcolor[2] = RGB_TO_V(r,g,b,0);
2377 static void opt_frame_pad_top(const char *arg)
2379 frame_padtop = atoi(arg);
2380 if (frame_padtop < 0) {
2381 fprintf(stderr, "Incorrect top pad size\n");
2384 if ((frame_padtop % 2) != 0) {
2385 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2390 static void opt_frame_pad_bottom(const char *arg)
2392 frame_padbottom = atoi(arg);
2393 if (frame_padbottom < 0) {
2394 fprintf(stderr, "Incorrect bottom pad size\n");
2397 if ((frame_padbottom % 2) != 0) {
2398 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2404 static void opt_frame_pad_left(const char *arg)
2406 frame_padleft = atoi(arg);
2407 if (frame_padleft < 0) {
2408 fprintf(stderr, "Incorrect left pad size\n");
2411 if ((frame_padleft % 2) != 0) {
2412 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2418 static void opt_frame_pad_right(const char *arg)
2420 frame_padright = atoi(arg);
2421 if (frame_padright < 0) {
2422 fprintf(stderr, "Incorrect right pad size\n");
2425 if ((frame_padright % 2) != 0) {
2426 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2431 static void list_pix_fmts(void)
2434 char pix_fmt_str[128];
2435 for (i=-1; i < PIX_FMT_NB; i++) {
2436 avcodec_pix_fmt_string (pix_fmt_str, sizeof(pix_fmt_str), i);
2437 fprintf(stdout, "%s\n", pix_fmt_str);
2441 static void opt_frame_pix_fmt(const char *arg)
2443 if (strcmp(arg, "list"))
2444 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2451 static void opt_frame_aspect_ratio(const char *arg)
2458 p = strchr(arg, ':');
2460 x = strtol(arg, &end, 10);
2462 y = strtol(end+1, &end, 10);
2464 ar = (double)x / (double)y;
2466 ar = strtod(arg, NULL);
2469 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2472 frame_aspect_ratio = ar;
2475 static void opt_qscale(const char *arg)
2477 video_qscale = atof(arg);
2478 if (video_qscale <= 0 ||
2479 video_qscale > 255) {
2480 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2485 static void opt_qdiff(const char *arg)
2487 video_qdiff = atoi(arg);
2488 if (video_qdiff < 0 ||
2490 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2495 static void opt_strict(const char *arg)
2500 static void opt_top_field_first(const char *arg)
2502 top_field_first= atoi(arg);
2505 static void opt_thread_count(const char *arg)
2507 thread_count= atoi(arg);
2508 #if !defined(HAVE_THREADS)
2510 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2514 static int opt_audio_rate(const char *opt, const char *arg)
2516 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2520 static int opt_audio_channels(const char *opt, const char *arg)
2522 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2526 static void opt_video_channel(const char *arg)
2528 video_channel = strtol(arg, NULL, 0);
2531 static void opt_video_standard(const char *arg)
2533 video_standard = av_strdup(arg);
2536 static void opt_codec(int *pstream_copy, char **pcodec_name,
2537 int codec_type, const char *arg)
2539 av_freep(pcodec_name);
2540 if (!strcmp(arg, "copy")) {
2543 *pcodec_name = av_strdup(arg);
2547 static void opt_audio_codec(const char *arg)
2549 opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2552 static void opt_audio_tag(const char *arg)
2555 audio_codec_tag= strtol(arg, &tail, 0);
2558 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2561 static void opt_video_tag(const char *arg)
2564 video_codec_tag= strtol(arg, &tail, 0);
2567 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2571 static void add_frame_hooker(const char *arg)
2576 char *args = av_strdup(arg);
2580 argv[0] = strtok(args, " ");
2581 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2584 i = frame_hook_add(argc, argv);
2587 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2593 static void opt_video_codec(const char *arg)
2595 opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2598 static void opt_subtitle_codec(const char *arg)
2600 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2603 static void opt_map(const char *arg)
2608 m = &stream_maps[nb_stream_maps++];
2610 m->file_index = strtol(arg, &p, 0);
2614 m->stream_index = strtol(p, &p, 0);
2617 m->sync_file_index = strtol(p, &p, 0);
2620 m->sync_stream_index = strtol(p, &p, 0);
2622 m->sync_file_index = m->file_index;
2623 m->sync_stream_index = m->stream_index;
2627 static void opt_map_meta_data(const char *arg)
2632 m = &meta_data_maps[nb_meta_data_maps++];
2634 m->out_file = strtol(arg, &p, 0);
2638 m->in_file = strtol(p, &p, 0);
2641 static int opt_recording_time(const char *opt, const char *arg)
2643 recording_time = parse_time_or_die(opt, arg, 1);
2647 static int opt_start_time(const char *opt, const char *arg)
2649 start_time = parse_time_or_die(opt, arg, 1);
2653 static int opt_rec_timestamp(const char *opt, const char *arg)
2655 rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2659 static int opt_input_ts_offset(const char *opt, const char *arg)
2661 input_ts_offset = parse_time_or_die(opt, arg, 1);
2665 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2667 const char *codec_string = encoder ? "encoder" : "decoder";
2671 return CODEC_ID_NONE;
2673 avcodec_find_encoder_by_name(name) :
2674 avcodec_find_decoder_by_name(name);
2676 av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2679 if(codec->type != type) {
2680 av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2686 static void opt_input_file(const char *filename)
2688 AVFormatContext *ic;
2689 AVFormatParameters params, *ap = ¶ms;
2690 int err, i, ret, rfps, rfps_base;
2693 if (!strcmp(filename, "-"))
2696 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2697 !strcmp( filename, "/dev/stdin" );
2699 /* get default parameters from command line */
2700 ic = av_alloc_format_context();
2702 memset(ap, 0, sizeof(*ap));
2703 ap->prealloced_context = 1;
2704 ap->sample_rate = audio_sample_rate;
2705 ap->channels = audio_channels;
2706 ap->time_base.den = frame_rate.num;
2707 ap->time_base.num = frame_rate.den;
2708 ap->width = frame_width + frame_padleft + frame_padright;
2709 ap->height = frame_height + frame_padtop + frame_padbottom;
2710 ap->pix_fmt = frame_pix_fmt;
2711 ap->channel = video_channel;
2712 ap->standard = video_standard;
2713 ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2714 ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2715 if(pgmyuv_compatibility_hack)
2716 ap->video_codec_id= CODEC_ID_PGMYUV;
2718 for(i=0; i<opt_name_count; i++){
2720 const AVOption *opt;
2721 const char *str= av_get_string(avformat_opts, opt_names[i], &opt, buf, sizeof(buf));
2722 if(str && (opt->flags & AV_OPT_FLAG_DECODING_PARAM))
2723 av_set_string(ic, opt_names[i], str);
2726 ic->video_codec_id = find_codec_or_die(video_codec_name , CODEC_TYPE_VIDEO , 0);
2727 ic->audio_codec_id = find_codec_or_die(audio_codec_name , CODEC_TYPE_AUDIO , 0);
2728 ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2730 /* open the input file with generic libav function */
2731 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2733 print_error(filename, err);
2738 for(i=0; i<ic->nb_programs; i++)
2739 if(ic->programs[i]->id != opt_programid)
2740 ic->programs[i]->discard = AVDISCARD_ALL;
2743 ic->loop_input = loop_input;
2745 /* If not enough info to get the stream parameters, we decode the
2746 first frames to get it. (used in mpeg case for example) */
2747 ret = av_find_stream_info(ic);
2748 if (ret < 0 && verbose >= 0) {
2749 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2753 timestamp = start_time;
2754 /* add the stream start time */
2755 if (ic->start_time != AV_NOPTS_VALUE)
2756 timestamp += ic->start_time;
2758 /* if seeking requested, we execute it */
2759 if (start_time != 0) {
2760 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2762 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2763 filename, (double)timestamp / AV_TIME_BASE);
2765 /* reset seek info */
2769 /* update the current parameters so that they match the one of the input stream */
2770 for(i=0;i<ic->nb_streams;i++) {
2772 AVCodecContext *enc = ic->streams[i]->codec;
2774 avcodec_thread_init(enc, thread_count);
2775 enc->thread_count= thread_count;
2776 switch(enc->codec_type) {
2777 case CODEC_TYPE_AUDIO:
2778 for(j=0; j<opt_name_count; j++){
2780 const AVOption *opt;
2781 const char *str= av_get_string(avctx_opts[CODEC_TYPE_AUDIO], opt_names[j], &opt, buf, sizeof(buf));
2782 if(str && (opt->flags & AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags & AV_OPT_FLAG_DECODING_PARAM))
2783 av_set_string(enc, opt_names[j], str);
2785 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2786 audio_channels = enc->channels;
2787 audio_sample_rate = enc->sample_rate;
2789 ic->streams[i]->discard= AVDISCARD_ALL;
2791 case CODEC_TYPE_VIDEO:
2792 for(j=0; j<opt_name_count; j++){
2794 const AVOption *opt;
2795 const char *str= av_get_string(avctx_opts[CODEC_TYPE_VIDEO], opt_names[j], &opt, buf, sizeof(buf));
2796 if(str && (opt->flags & AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags & AV_OPT_FLAG_DECODING_PARAM))
2797 av_set_string(enc, opt_names[j], str);
2799 frame_height = enc->height;
2800 frame_width = enc->width;
2801 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2802 frame_pix_fmt = enc->pix_fmt;
2803 rfps = ic->streams[i]->r_frame_rate.num;
2804 rfps_base = ic->streams[i]->r_frame_rate.den;
2805 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2807 enc->debug |= FF_DEBUG_MV;
2809 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2812 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2813 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2815 (float)rfps / rfps_base, rfps, rfps_base);
2817 /* update the current frame rate to match the stream frame rate */
2818 frame_rate.num = rfps;
2819 frame_rate.den = rfps_base;
2821 enc->rate_emu = rate_emu;
2823 ic->streams[i]->discard= AVDISCARD_ALL;
2824 else if(video_discard)
2825 ic->streams[i]->discard= video_discard;
2827 case CODEC_TYPE_DATA:
2829 case CODEC_TYPE_SUBTITLE:
2830 if(subtitle_disable)
2831 ic->streams[i]->discard = AVDISCARD_ALL;
2833 case CODEC_TYPE_ATTACHMENT:
2834 case CODEC_TYPE_UNKNOWN:
2841 input_files[nb_input_files] = ic;
2842 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2843 /* dump the file content */
2845 dump_format(ic, nb_input_files, filename, 0);
2848 file_iformat = NULL;
2849 file_oformat = NULL;
2854 av_freep(&video_codec_name);
2855 av_freep(&audio_codec_name);
2856 av_freep(&subtitle_codec_name);
2859 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2860 int *has_subtitle_ptr)
2862 int has_video, has_audio, has_subtitle, i, j;
2863 AVFormatContext *ic;
2868 for(j=0;j<nb_input_files;j++) {
2869 ic = input_files[j];
2870 for(i=0;i<ic->nb_streams;i++) {
2871 AVCodecContext *enc = ic->streams[i]->codec;
2872 switch(enc->codec_type) {
2873 case CODEC_TYPE_AUDIO:
2876 case CODEC_TYPE_VIDEO:
2879 case CODEC_TYPE_SUBTITLE:
2882 case CODEC_TYPE_DATA:
2883 case CODEC_TYPE_ATTACHMENT:
2884 case CODEC_TYPE_UNKNOWN:
2891 *has_video_ptr = has_video;
2892 *has_audio_ptr = has_audio;
2893 *has_subtitle_ptr = has_subtitle;
2896 static void new_video_stream(AVFormatContext *oc)
2899 AVCodecContext *video_enc;
2902 st = av_new_stream(oc, oc->nb_streams);
2904 fprintf(stderr, "Could not alloc stream\n");
2907 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2908 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2909 video_bitstream_filters= NULL;
2912 avcodec_thread_init(st->codec, thread_count);
2914 video_enc = st->codec;
2917 video_enc->codec_tag= video_codec_tag;
2919 if( (video_global_header&1)
2920 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2921 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2922 avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2924 if(video_global_header&2){
2925 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2926 avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2929 if (video_stream_copy) {
2930 st->stream_copy = 1;
2931 video_enc->codec_type = CODEC_TYPE_VIDEO;
2936 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
2938 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2939 if (video_codec_name)
2940 codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
2942 video_enc->codec_id = codec_id;
2943 codec = avcodec_find_encoder(codec_id);
2945 for(i=0; i<opt_name_count; i++){
2947 const AVOption *opt;
2948 const char *str= av_get_string(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt, buf, sizeof(buf));
2949 if(str && (opt->flags & AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
2950 av_set_string(video_enc, opt_names[i], str);
2953 video_enc->time_base.den = fps.num;
2954 video_enc->time_base.num = fps.den;
2955 if(codec && codec->supported_framerates){
2956 const AVRational *p= codec->supported_framerates;
2957 const AVRational *best=NULL;
2958 AVRational best_error= (AVRational){INT_MAX, 1};
2959 for(; p->den!=0; p++){
2960 AVRational error= av_sub_q(fps, *p);
2961 if(error.num <0) error.num *= -1;
2962 if(av_cmp_q(error, best_error) < 0){
2967 video_enc->time_base.den= best->num;
2968 video_enc->time_base.num= best->den;
2971 video_enc->width = frame_width + frame_padright + frame_padleft;
2972 video_enc->height = frame_height + frame_padtop + frame_padbottom;
2973 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2974 video_enc->pix_fmt = frame_pix_fmt;
2976 if(codec && codec->pix_fmts){
2977 const enum PixelFormat *p= codec->pix_fmts;
2979 if(*p == video_enc->pix_fmt)
2983 video_enc->pix_fmt = codec->pix_fmts[0];
2987 video_enc->gop_size = 0;
2988 if (video_qscale || same_quality) {
2989 video_enc->flags |= CODEC_FLAG_QSCALE;
2990 video_enc->global_quality=
2991 st->quality = FF_QP2LAMBDA * video_qscale;
2995 video_enc->intra_matrix = intra_matrix;
2997 video_enc->inter_matrix = inter_matrix;
2999 video_enc->max_qdiff = video_qdiff;
3000 video_enc->thread_count = thread_count;
3001 p= video_rc_override_string;
3004 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3006 fprintf(stderr, "error parsing rc_override\n");
3009 video_enc->rc_override=
3010 av_realloc(video_enc->rc_override,
3011 sizeof(RcOverride)*(i+1));
3012 video_enc->rc_override[i].start_frame= start;
3013 video_enc->rc_override[i].end_frame = end;
3015 video_enc->rc_override[i].qscale= q;
3016 video_enc->rc_override[i].quality_factor= 1.0;
3019 video_enc->rc_override[i].qscale= 0;
3020 video_enc->rc_override[i].quality_factor= -q/100.0;
3025 video_enc->rc_override_count=i;
3026 if (!video_enc->rc_initial_buffer_occupancy)
3027 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3028 video_enc->me_threshold= me_threshold;
3029 video_enc->intra_dc_precision= intra_dc_precision - 8;
3030 video_enc->strict_std_compliance = strict;
3033 video_enc->flags|= CODEC_FLAG_PSNR;
3038 video_enc->flags |= CODEC_FLAG_PASS1;
3040 video_enc->flags |= CODEC_FLAG_PASS2;
3045 /* reset some key parameters */
3047 av_freep(&video_codec_name);
3048 video_stream_copy = 0;
3051 static void new_audio_stream(AVFormatContext *oc)
3054 AVCodecContext *audio_enc;
3057 st = av_new_stream(oc, oc->nb_streams);
3059 fprintf(stderr, "Could not alloc stream\n");
3062 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3064 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3065 audio_bitstream_filters= NULL;
3068 avcodec_thread_init(st->codec, thread_count);
3070 audio_enc = st->codec;
3071 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3072 audio_enc->strict_std_compliance = strict;
3075 audio_enc->codec_tag= audio_codec_tag;
3077 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3078 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3079 avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3081 if (audio_stream_copy) {
3082 st->stream_copy = 1;
3083 audio_enc->channels = audio_channels;
3085 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3087 for(i=0; i<opt_name_count; i++){
3089 const AVOption *opt;
3090 const char *str= av_get_string(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt, buf, sizeof(buf));
3091 if(str && (opt->flags & AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3092 av_set_string(audio_enc, opt_names[i], str);
3095 if (audio_codec_name)
3096 codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3097 audio_enc->codec_id = codec_id;
3099 if (audio_qscale > QSCALE_NONE) {
3100 audio_enc->flags |= CODEC_FLAG_QSCALE;
3101 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3103 audio_enc->thread_count = thread_count;
3104 audio_enc->channels = audio_channels;
3106 audio_enc->sample_rate = audio_sample_rate;
3107 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3108 if (audio_language) {
3109 av_strlcpy(st->language, audio_language, sizeof(st->language));
3110 av_free(audio_language);
3111 audio_language = NULL;
3114 /* reset some key parameters */
3116 av_freep(&audio_codec_name);
3117 audio_stream_copy = 0;
3120 static void new_subtitle_stream(AVFormatContext *oc)
3123 AVCodecContext *subtitle_enc;
3126 st = av_new_stream(oc, oc->nb_streams);
3128 fprintf(stderr, "Could not alloc stream\n");
3131 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3133 bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3134 subtitle_bitstream_filters= NULL;
3136 subtitle_enc = st->codec;
3137 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3138 if (subtitle_stream_copy) {
3139 st->stream_copy = 1;
3141 for(i=0; i<opt_name_count; i++){
3143 const AVOption *opt;
3144 const char *str= av_get_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt_names[i], &opt, buf, sizeof(buf));
3145 if(str && (opt->flags & AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3146 av_set_string(subtitle_enc, opt_names[i], str);
3148 subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3151 if (subtitle_language) {
3152 av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3153 av_free(subtitle_language);
3154 subtitle_language = NULL;
3157 subtitle_disable = 0;
3158 av_freep(&subtitle_codec_name);
3159 subtitle_stream_copy = 0;
3162 static void opt_new_audio_stream(void)
3164 AVFormatContext *oc;
3165 if (nb_output_files <= 0) {
3166 fprintf(stderr, "At least one output file must be specified\n");
3169 oc = output_files[nb_output_files - 1];
3170 new_audio_stream(oc);
3173 static void opt_new_video_stream(void)
3175 AVFormatContext *oc;
3176 if (nb_output_files <= 0) {
3177 fprintf(stderr, "At least one output file must be specified\n");
3180 oc = output_files[nb_output_files - 1];
3181 new_video_stream(oc);
3184 static void opt_new_subtitle_stream(void)
3186 AVFormatContext *oc;
3187 if (nb_output_files <= 0) {
3188 fprintf(stderr, "At least one output file must be specified\n");
3191 oc = output_files[nb_output_files - 1];
3192 new_subtitle_stream(oc);
3195 static void opt_output_file(const char *filename)
3197 AVFormatContext *oc;
3198 int use_video, use_audio, use_subtitle;
3199 int input_has_video, input_has_audio, input_has_subtitle, i;
3200 AVFormatParameters params, *ap = ¶ms;
3202 if (!strcmp(filename, "-"))
3205 oc = av_alloc_format_context();
3207 if (!file_oformat) {
3208 file_oformat = guess_format(NULL, filename, NULL);
3209 if (!file_oformat) {
3210 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3216 oc->oformat = file_oformat;
3217 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3219 if (!strcmp(file_oformat->name, "ffm") &&
3220 av_strstart(filename, "http:", NULL)) {
3221 /* special case for files sent to ffserver: we get the stream
3222 parameters from ffserver */
3223 if (read_ffserver_streams(oc, filename) < 0) {
3224 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3228 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3229 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3230 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3232 /* disable if no corresponding type found and at least one
3234 if (nb_input_files > 0) {
3235 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3236 &input_has_subtitle);
3237 if (!input_has_video)
3239 if (!input_has_audio)
3241 if (!input_has_subtitle)
3245 /* manual disable */
3246 if (audio_disable) {
3249 if (video_disable) {
3252 if (subtitle_disable) {
3257 new_video_stream(oc);
3261 new_audio_stream(oc);
3265 new_subtitle_stream(oc);
3268 oc->timestamp = rec_timestamp;
3271 av_strlcpy(oc->title, str_title, sizeof(oc->title));
3273 av_strlcpy(oc->author, str_author, sizeof(oc->author));
3275 av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3277 av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3279 av_strlcpy(oc->album, str_album, sizeof(oc->album));
3281 av_strlcpy(oc->genre, str_genre, sizeof(oc->genre));
3284 output_files[nb_output_files++] = oc;
3286 /* check filename in case of an image number is expected */
3287 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3288 if (!av_filename_number_test(oc->filename)) {
3289 print_error(oc->filename, AVERROR_NUMEXPECTED);
3294 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3295 /* test if it already exists to avoid loosing precious files */
3296 if (!file_overwrite &&
3297 (strchr(filename, ':') == NULL ||
3298 filename[1] == ':' ||
3299 av_strstart(filename, "file:", NULL))) {
3300 if (url_exist(filename)) {
3303 if ( !using_stdin ) {
3304 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3307 if (toupper(c) != 'Y') {
3308 fprintf(stderr, "Not overwriting - exiting\n");
3313 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3320 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3321 fprintf(stderr, "Could not open '%s'\n", filename);
3326 memset(ap, 0, sizeof(*ap));
3327 if (av_set_parameters(oc, ap) < 0) {
3328 fprintf(stderr, "%s: Invalid encoding parameters\n",
3333 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3334 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3335 oc->loop_output = loop_output;
3337 for(i=0; i<opt_name_count; i++){
3339 const AVOption *opt;
3340 const char *str= av_get_string(avformat_opts, opt_names[i], &opt, buf, sizeof(buf));
3341 if(str && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3342 av_set_string(oc, opt_names[i], str);
3345 /* reset some options */
3346 file_oformat = NULL;
3347 file_iformat = NULL;
3350 /* same option as mencoder */
3351 static void opt_pass(const char *pass_str)
3354 pass = atoi(pass_str);
3355 if (pass != 1 && pass != 2) {
3356 fprintf(stderr, "pass number can be only 1 or 2\n");
3362 static int64_t getutime(void)
3364 #ifdef HAVE_GETRUSAGE
3365 struct rusage rusage;
3367 getrusage(RUSAGE_SELF, &rusage);
3368 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3369 #elif defined(HAVE_GETPROCESSTIMES)
3371 FILETIME c, e, k, u;
3372 proc = GetCurrentProcess();
3373 GetProcessTimes(proc, &c, &e, &k, &u);
3374 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3376 return av_gettime();
3380 static void opt_show_formats(void)
3382 AVInputFormat *ifmt=NULL;
3383 AVOutputFormat *ofmt=NULL;
3384 URLProtocol *up=NULL;
3385 AVCodec *p=NULL, *p2;
3386 AVBitStreamFilter *bsf=NULL;
3387 const char *last_name;
3389 printf("File formats:\n");
3394 const char *name=NULL;
3395 const char *long_name=NULL;
3397 while((ofmt= av_oformat_next(ofmt))) {
3398 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3399 strcmp(ofmt->name, last_name)>0){
3401 long_name= ofmt->long_name;
3405 while((ifmt= av_iformat_next(ifmt))) {
3406 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3407 strcmp(ifmt->name, last_name)>0){
3409 long_name= ifmt->long_name;
3412 if(name && strcmp(ifmt->name, name)==0)
3424 long_name ? long_name:" ");
3428 printf("Codecs:\n");
3434 const char *type_str;
3437 while((p= av_codec_next(p))) {
3438 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3439 strcmp(p->name, last_name)>0){
3441 decode= encode= cap=0;
3443 if(p2 && strcmp(p->name, p2->name)==0){
3444 if(p->decode) decode=1;
3445 if(p->encode) encode=1;
3446 cap |= p->capabilities;
3451 last_name= p2->name;
3454 case CODEC_TYPE_VIDEO:
3457 case CODEC_TYPE_AUDIO:
3460 case CODEC_TYPE_SUBTITLE:
3469 decode ? "D": (/*p2->decoder ? "d":*/" "),
3472 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3473 cap & CODEC_CAP_DR1 ? "D":" ",
3474 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3476 /* if(p2->decoder && decode==0)
3477 printf(" use %s for decoding", p2->decoder->name);*/
3482 printf("Bitstream filters:\n");
3483 while((bsf = av_bitstream_filter_next(bsf)))
3484 printf(" %s", bsf->name);
3487 printf("Supported file protocols:\n");
3488 while((up = av_protocol_next(up)))
3489 printf(" %s:", up->name);
3492 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3495 "Note, the names of encoders and decoders do not always match, so there are\n"
3496 "several cases where the above table shows encoder only or decoder only entries\n"
3497 "even though both encoding and decoding are supported. For example, the h263\n"
3498 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
3503 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3506 const char *p = str;
3513 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3520 static void opt_inter_matrix(const char *arg)
3522 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3523 parse_matrix_coeffs(inter_matrix, arg);
3526 static void opt_intra_matrix(const char *arg)
3528 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3529 parse_matrix_coeffs(intra_matrix, arg);
3533 * Trivial log callback.
3534 * Only suitable for show_help and similar since it lacks prefix handling.
3536 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3538 vfprintf(stdout, fmt, vl);
3541 static void show_help(void)
3543 av_log_set_callback(log_callback_help);
3544 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3545 "Hyper fast Audio and Video encoder\n");
3547 show_help_options(options, "Main options:\n",
3548 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3549 show_help_options(options, "\nVideo options:\n",
3550 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3552 show_help_options(options, "\nAdvanced Video options:\n",
3553 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3554 OPT_VIDEO | OPT_EXPERT);
3555 show_help_options(options, "\nAudio options:\n",
3556 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3558 show_help_options(options, "\nAdvanced Audio options:\n",
3559 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3560 OPT_AUDIO | OPT_EXPERT);
3561 show_help_options(options, "\nSubtitle options:\n",
3562 OPT_SUBTITLE | OPT_GRAB,
3564 show_help_options(options, "\nAudio/Video grab options:\n",
3567 show_help_options(options, "\nAdvanced options:\n",
3568 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3570 av_opt_show(avctx_opts[0], NULL);
3571 av_opt_show(avformat_opts, NULL);
3572 av_opt_show(sws_opts, NULL);
3575 static void opt_show_help(void)
3581 static void opt_target(const char *arg)
3584 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3586 if(!strncmp(arg, "pal-", 4)) {
3589 } else if(!strncmp(arg, "ntsc-", 5)) {
3592 } else if(!strncmp(arg, "film-", 5)) {
3597 /* Calculate FR via float to avoid int overflow */
3598 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3601 } else if((fr == 29970) || (fr == 23976)) {
3604 /* Try to determine PAL/NTSC by peeking in the input files */
3605 if(nb_input_files) {
3607 for(j = 0; j < nb_input_files; j++) {
3608 for(i = 0; i < input_files[j]->nb_streams; i++) {
3609 AVCodecContext *c = input_files[j]->streams[i]->codec;
3610 if(c->codec_type != CODEC_TYPE_VIDEO)
3612 fr = c->time_base.den * 1000 / c->time_base.num;
3616 } else if((fr == 29970) || (fr == 23976)) {
3626 if(verbose && norm >= 0)
3627 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3631 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3632 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3633 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3637 if(!strcmp(arg, "vcd")) {
3639 opt_video_codec("mpeg1video");
3640 opt_audio_codec("mp2");
3643 opt_frame_size(norm ? "352x240" : "352x288");
3644 opt_frame_rate(frame_rates[norm]);
3645 opt_default("gop", norm ? "18" : "15");
3647 opt_default("b", "1150000");
3648 opt_default("maxrate", "1150000");
3649 opt_default("minrate", "1150000");
3650 opt_default("bufsize", "327680"); // 40*1024*8;
3652 opt_default("ab", "224000");
3653 audio_sample_rate = 44100;
3656 opt_default("packetsize", "2324");
3657 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3659 /* We have to offset the PTS, so that it is consistent with the SCR.
3660 SCR starts at 36000, but the first two packs contain only padding
3661 and the first pack from the other stream, respectively, may also have
3662 been written before.
3663 So the real data starts at SCR 36000+3*1200. */
3664 mux_preload= (36000+3*1200) / 90000.0; //0.44
3665 } else if(!strcmp(arg, "svcd")) {
3667 opt_video_codec("mpeg2video");
3668 opt_audio_codec("mp2");
3671 opt_frame_size(norm ? "480x480" : "480x576");
3672 opt_frame_rate(frame_rates[norm]);
3673 opt_default("gop", norm ? "18" : "15");
3675 opt_default("b", "2040000");
3676 opt_default("maxrate", "2516000");
3677 opt_default("minrate", "0"); //1145000;
3678 opt_default("bufsize", "1835008"); //224*1024*8;
3679 opt_default("flags", "+SCAN_OFFSET");
3682 opt_default("ab", "224000");
3683 audio_sample_rate = 44100;
3685 opt_default("packetsize", "2324");
3687 } else if(!strcmp(arg, "dvd")) {
3689 opt_video_codec("mpeg2video");
3690 opt_audio_codec("ac3");
3693 opt_frame_size(norm ? "720x480" : "720x576");
3694 opt_frame_rate(frame_rates[norm]);
3695 opt_default("gop", norm ? "18" : "15");
3697 opt_default("b", "6000000");
3698 opt_default("maxrate", "9000000");
3699 opt_default("minrate", "0"); //1500000;
3700 opt_default("bufsize", "1835008"); //224*1024*8;
3702 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3703 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3705 opt_default("ab", "448000");
3706 audio_sample_rate = 48000;
3708 } else if(!strncmp(arg, "dv", 2)) {
3712 opt_frame_size(norm ? "720x480" : "720x576");
3713 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3714 (norm ? "yuv411p" : "yuv420p"));
3715 opt_frame_rate(frame_rates[norm]);
3717 audio_sample_rate = 48000;
3721 fprintf(stderr, "Unknown target: %s\n", arg);
3726 static void opt_vstats_file (const char *arg)
3728 av_free (vstats_filename);
3729 vstats_filename=av_strdup (arg);
3732 static void opt_vstats (void)
3735 time_t today2 = time(NULL);
3736 struct tm *today = localtime(&today2);
3738 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3740 opt_vstats_file(filename);
3743 static int opt_bsf(const char *opt, const char *arg)
3745 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3746 AVBitStreamFilterContext **bsfp;
3749 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3753 bsfp= *opt == 'v' ? &video_bitstream_filters :
3754 *opt == 'a' ? &audio_bitstream_filters :
3755 &subtitle_bitstream_filters;
3757 bsfp= &(*bsfp)->next;
3764 static void opt_show_license(void)
3770 static void opt_show_version(void)
3772 show_version(program_name);
3776 static const OptionDef options[] = {
3778 { "L", 0, {(void*)opt_show_license}, "show license" },
3779 { "h", 0, {(void*)opt_show_help}, "show help" },
3780 { "version", 0, {(void*)opt_show_version}, "show version" },
3781 { "formats", 0, {(void*)opt_show_formats}, "show available formats, codecs, protocols, ..." },
3782 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3783 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3784 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3785 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3786 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3787 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3788 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3789 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3790 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3791 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3792 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3793 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3794 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3795 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3796 { "genre", HAS_ARG | OPT_STRING, {(void*)&str_genre}, "set the genre", "string" },
3797 { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3798 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3799 "add timings for benchmarking" },
3800 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3801 "dump each input packet" },
3802 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3803 "when dumping packets, also dump the payload" },
3804 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3805 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3806 { "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)", "" },
3807 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set the logging verbosity level", "number" },
3808 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3809 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3810 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3811 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3812 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3813 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3814 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3815 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3816 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3817 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3820 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3821 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3822 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3823 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3824 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3825 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3826 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3827 { "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" },
3828 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3829 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3830 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3831 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3832 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3833 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3834 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3835 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3836 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3837 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3838 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3839 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3840 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3841 { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantizer scale (VBR)", "q" },
3842 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3843 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3844 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
3845 { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3846 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3847 "use same video quality as source (implies VBR)" },
3848 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3849 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3850 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3851 "deinterlace pictures" },
3852 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3853 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3854 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3856 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3858 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3859 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3860 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3861 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3862 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3863 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3864 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3867 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3868 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3869 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3870 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3871 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3872 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3873 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3874 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3875 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3876 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3877 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3879 /* subtitle options */
3880 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3881 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3882 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3883 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3886 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3887 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3888 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3891 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3892 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3894 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" },
3895 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" },
3896 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" },
3898 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3902 int main(int argc, char **argv)
3907 avcodec_register_all();
3908 avdevice_register_all();
3911 for(i=0; i<CODEC_TYPE_NB; i++){
3912 avctx_opts[i]= avcodec_alloc_context2(i);
3914 avformat_opts = av_alloc_format_context();
3915 sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3917 show_banner(program_name, program_birth_year);
3924 parse_options(argc, argv, options, opt_output_file);
3926 /* file converter / grab */
3927 if (nb_output_files <= 0) {
3928 fprintf(stderr, "Must supply at least one output file\n");
3932 if (nb_input_files == 0) {
3933 fprintf(stderr, "Must supply at least one input file\n");
3938 av_encode(output_files, nb_output_files, input_files, nb_input_files,
3939 stream_maps, nb_stream_maps);
3940 ti = getutime() - ti;
3942 printf("bench: utime=%0.3fs\n", ti / 1000000.0);