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/types.h>
41 #include <sys/resource.h>
42 #elif defined(HAVE_GETPROCESSTIMES)
46 #if defined(HAVE_TERMIOS_H)
49 #include <sys/ioctl.h>
52 #elif defined(HAVE_CONIO_H)
55 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
65 const char program_name[] = "FFmpeg";
66 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]);
395 av_free(intra_matrix);
396 av_free(inter_matrix);
400 av_free(vstats_filename);
404 av_free(video_codec_name);
405 av_free(audio_codec_name);
406 av_free(subtitle_codec_name);
408 av_free(video_standard);
410 #ifdef CONFIG_POWERPC_PERF
411 extern void powerpc_display_perf_report(void);
412 powerpc_display_perf_report();
413 #endif /* CONFIG_POWERPC_PERF */
415 if (received_sigterm) {
417 "Received signal %d: terminating.\n",
418 (int) received_sigterm);
422 exit(ret); /* not all OS-es handle main() return value */
426 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
432 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
435 /* copy stream format */
436 s->nb_streams = ic->nb_streams;
437 for(i=0;i<ic->nb_streams;i++) {
440 // FIXME: a more elegant solution is needed
441 st = av_mallocz(sizeof(AVStream));
442 memcpy(st, ic->streams[i], sizeof(AVStream));
443 st->codec = avcodec_alloc_context();
444 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
446 if(st->codec->flags & CODEC_FLAG_BITEXACT)
451 s->timestamp = av_gettime();
453 av_close_input_file(ic);
458 get_sync_ipts(const AVOutputStream *ost)
460 const AVInputStream *ist = ost->sync_ist;
461 return (double)(ist->pts - start_time)/AV_TIME_BASE;
464 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
468 AVPacket new_pkt= *pkt;
469 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
470 &new_pkt.data, &new_pkt.size,
471 pkt->data, pkt->size,
472 pkt->flags & PKT_FLAG_KEY);
475 new_pkt.destruct= av_destruct_packet;
477 fprintf(stderr, "%s failed for stream %d, codec %s",
478 bsfc->filter->name, pkt->stream_index,
479 avctx->codec ? avctx->codec->name : "copy");
487 ret= av_interleaved_write_frame(s, pkt);
489 print_error("av_interleaved_write_frame()", ret);
494 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
496 static void do_audio_out(AVFormatContext *s,
499 unsigned char *buf, int size)
502 static uint8_t *audio_buf = NULL;
503 static uint8_t *audio_out = NULL;
504 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
506 int size_out, frame_bytes, ret;
507 AVCodecContext *enc= ost->st->codec;
508 AVCodecContext *dec= ist->st->codec;
510 /* SC: dynamic allocation of buffers */
512 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
514 audio_out = av_malloc(audio_out_size);
515 if (!audio_buf || !audio_out)
516 return; /* Should signal an error ! */
518 if (enc->channels != dec->channels)
519 ost->audio_resample = 1;
521 if (ost->audio_resample && !ost->resample) {
522 ost->resample = audio_resample_init(enc->channels, dec->channels,
523 enc->sample_rate, dec->sample_rate);
524 if (!ost->resample) {
525 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
526 dec->channels, dec->sample_rate,
527 enc->channels, enc->sample_rate);
532 if(audio_sync_method){
533 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
534 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
535 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
536 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
538 //FIXME resample delay
539 if(fabs(delta) > 50){
540 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
542 byte_delta= FFMAX(byte_delta, -size);
546 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
551 static uint8_t *input_tmp= NULL;
552 input_tmp= av_realloc(input_tmp, byte_delta + size);
554 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
557 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
559 memset(input_tmp, 0, byte_delta);
560 memcpy(input_tmp + byte_delta, buf, size);
564 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
566 }else if(audio_sync_method>1){
567 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
568 assert(ost->audio_resample);
570 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
571 // 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));
572 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
576 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
577 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
579 if (ost->audio_resample) {
581 size_out = audio_resample(ost->resample,
582 (short *)buftmp, (short *)buf,
583 size / (ist->st->codec->channels * 2));
584 size_out = size_out * enc->channels * 2;
590 /* now encode as many frames as possible */
591 if (enc->frame_size > 1) {
592 /* output resampled raw samples */
593 av_fifo_realloc(&ost->fifo, av_fifo_size(&ost->fifo) + size_out);
594 av_fifo_generic_write(&ost->fifo, buftmp, size_out, NULL);
596 frame_bytes = enc->frame_size * 2 * enc->channels;
598 while (av_fifo_size(&ost->fifo) >= frame_bytes) {
600 av_init_packet(&pkt);
602 av_fifo_read(&ost->fifo, audio_buf, frame_bytes);
604 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
606 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
609 pkt.stream_index= ost->index;
612 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
613 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
614 pkt.flags |= PKT_FLAG_KEY;
615 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
617 ost->sync_opts += enc->frame_size;
621 av_init_packet(&pkt);
623 ost->sync_opts += size_out / (2 * enc->channels);
625 /* output a pcm frame */
626 /* XXX: change encoding codec API to avoid this ? */
627 switch(enc->codec->id) {
628 case CODEC_ID_PCM_S32LE:
629 case CODEC_ID_PCM_S32BE:
630 case CODEC_ID_PCM_U32LE:
631 case CODEC_ID_PCM_U32BE:
632 size_out = size_out << 1;
634 case CODEC_ID_PCM_S24LE:
635 case CODEC_ID_PCM_S24BE:
636 case CODEC_ID_PCM_U24LE:
637 case CODEC_ID_PCM_U24BE:
638 case CODEC_ID_PCM_S24DAUD:
639 size_out = size_out / 2 * 3;
641 case CODEC_ID_PCM_S16LE:
642 case CODEC_ID_PCM_S16BE:
643 case CODEC_ID_PCM_U16LE:
644 case CODEC_ID_PCM_U16BE:
647 size_out = size_out >> 1;
650 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
651 ret = avcodec_encode_audio(enc, audio_out, size_out,
654 pkt.stream_index= ost->index;
657 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
658 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
659 pkt.flags |= PKT_FLAG_KEY;
660 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
664 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
668 AVPicture picture_tmp;
671 dec = ist->st->codec;
673 /* deinterlace : must be done before any resize */
674 if (do_deinterlace || using_vhook) {
677 /* create temporary picture */
678 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
679 buf = av_malloc(size);
683 picture2 = &picture_tmp;
684 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
687 if(avpicture_deinterlace(picture2, picture,
688 dec->pix_fmt, dec->width, dec->height) < 0) {
689 /* if error, do not deinterlace */
695 av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
702 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,
703 1000000 * ist->pts / AV_TIME_BASE);
705 if (picture != picture2)
706 *picture = *picture2;
710 /* we begin to correct av delay at this threshold */
711 #define AV_DELAY_MAX 0.100
713 static void do_subtitle_out(AVFormatContext *s,
719 static uint8_t *subtitle_out = NULL;
720 int subtitle_out_max_size = 65536;
721 int subtitle_out_size, nb, i;
725 if (pts == AV_NOPTS_VALUE) {
726 fprintf(stderr, "Subtitle packets must have a pts\n");
730 enc = ost->st->codec;
733 subtitle_out = av_malloc(subtitle_out_max_size);
736 /* Note: DVB subtitle need one packet to draw them and one other
737 packet to clear them */
738 /* XXX: signal it in the codec context ? */
739 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
744 for(i = 0; i < nb; i++) {
745 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
746 subtitle_out_max_size, sub);
748 av_init_packet(&pkt);
749 pkt.stream_index = ost->index;
750 pkt.data = subtitle_out;
751 pkt.size = subtitle_out_size;
752 pkt.pts = av_rescale_q(pts, ist->st->time_base, ost->st->time_base);
753 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
754 /* XXX: the pts correction is handled here. Maybe handling
755 it in the codec would be better */
757 pkt.pts += 90 * sub->start_display_time;
759 pkt.pts += 90 * sub->end_display_time;
761 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
765 static int bit_buffer_size= 1024*256;
766 static uint8_t *bit_buffer= NULL;
768 static void do_video_out(AVFormatContext *s,
774 int nb_frames, i, ret;
775 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
776 AVFrame picture_crop_temp, picture_pad_temp;
777 AVCodecContext *enc, *dec;
779 avcodec_get_frame_defaults(&picture_crop_temp);
780 avcodec_get_frame_defaults(&picture_pad_temp);
782 enc = ost->st->codec;
783 dec = ist->st->codec;
785 /* by default, we output a single frame */
790 if(video_sync_method){
792 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
793 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
796 else if (video_sync_method == 2)
797 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
798 else if (vdelta > 1.1)
799 nb_frames = lrintf(vdelta);
800 //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);
804 fprintf(stderr, "*** drop!\n");
805 }else if (nb_frames > 1) {
806 nb_frames_dup += nb_frames;
808 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
811 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
813 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
817 if (ost->video_crop) {
818 if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
819 av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
822 formatted_picture = &picture_crop_temp;
824 formatted_picture = in_picture;
827 final_picture = formatted_picture;
828 padding_src = formatted_picture;
829 resampling_dst = &ost->pict_tmp;
830 if (ost->video_pad) {
831 final_picture = &ost->pict_tmp;
832 if (ost->video_resample) {
833 if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
834 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
837 resampling_dst = &picture_pad_temp;
841 if (ost->video_resample) {
843 final_picture = &ost->pict_tmp;
844 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
845 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
848 if (ost->video_pad) {
849 av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
850 enc->height, enc->width, enc->pix_fmt,
851 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
854 /* duplicates frame if needed */
855 for(i=0;i<nb_frames;i++) {
857 av_init_packet(&pkt);
858 pkt.stream_index= ost->index;
860 if (s->oformat->flags & AVFMT_RAWPICTURE) {
861 /* raw pictures are written as AVPicture structure to
862 avoid any copies. We support temorarily the older
864 AVFrame* old_frame = enc->coded_frame;
865 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
866 pkt.data= (uint8_t *)final_picture;
867 pkt.size= sizeof(AVPicture);
868 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
869 pkt.flags |= PKT_FLAG_KEY;
871 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
872 enc->coded_frame = old_frame;
876 big_picture= *final_picture;
877 /* better than nothing: use input picture interlaced
879 big_picture.interlaced_frame = in_picture->interlaced_frame;
880 if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
881 if(top_field_first == -1)
882 big_picture.top_field_first = in_picture->top_field_first;
884 big_picture.top_field_first = top_field_first;
887 /* handles sameq here. This is not correct because it may
888 not be a global option */
890 big_picture.quality = ist->st->quality;
892 big_picture.quality = ost->st->quality;
894 big_picture.pict_type = 0;
895 // big_picture.pts = AV_NOPTS_VALUE;
896 big_picture.pts= ost->sync_opts;
897 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
898 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
899 ret = avcodec_encode_video(enc,
900 bit_buffer, bit_buffer_size,
903 fprintf(stderr, "Video encoding failed\n");
906 //enc->frame_number = enc->real_pict_num;
908 pkt.data= bit_buffer;
910 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
911 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
912 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
913 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
914 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
916 if(enc->coded_frame->key_frame)
917 pkt.flags |= PKT_FLAG_KEY;
918 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
920 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
921 // enc->frame_number-1, enc->real_pict_num, ret,
923 /* if two pass, output log */
924 if (ost->logfile && enc->stats_out) {
925 fprintf(ost->logfile, "%s", enc->stats_out);
934 static double psnr(double d){
935 return -10.0*log(d)/log(10.0);
938 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
943 double ti1, bitrate, avg_bitrate;
945 /* this is executed just the first time do_video_stats is called */
947 vstats_file = fopen(vstats_filename, "w");
954 enc = ost->st->codec;
955 if (enc->codec_type == CODEC_TYPE_VIDEO) {
956 frame_number = ost->frame_number;
957 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
958 if (enc->flags&CODEC_FLAG_PSNR)
959 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
961 fprintf(vstats_file,"f_size= %6d ", frame_size);
962 /* compute pts value */
963 ti1 = ost->sync_opts * av_q2d(enc->time_base);
967 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
968 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
969 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
970 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
971 fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
975 static void print_report(AVFormatContext **output_files,
976 AVOutputStream **ost_table, int nb_ostreams,
981 AVFormatContext *oc, *os;
984 int frame_number, vid, i;
985 double bitrate, ti1, pts;
986 static int64_t last_time = -1;
987 static int qp_histogram[52];
989 if (!is_last_report) {
991 /* display the report every 0.5 seconds */
992 cur_time = av_gettime();
993 if (last_time == -1) {
994 last_time = cur_time;
997 if ((cur_time - last_time) < 500000)
999 last_time = cur_time;
1003 oc = output_files[0];
1005 total_size = url_fsize(oc->pb);
1006 if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1007 total_size= url_ftell(oc->pb);
1012 for(i=0;i<nb_ostreams;i++) {
1014 os = output_files[ost->file_index];
1015 enc = ost->st->codec;
1016 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1017 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1018 !ost->st->stream_copy ?
1019 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1021 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1022 float t = (av_gettime()-timer_start) / 1000000.0;
1024 frame_number = ost->frame_number;
1025 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1026 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1027 !ost->st->stream_copy ?
1028 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1030 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1033 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1034 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
1037 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1039 if (enc->flags&CODEC_FLAG_PSNR){
1041 double error, error_sum=0;
1042 double scale, scale_sum=0;
1043 char type[3]= {'Y','U','V'};
1044 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1047 error= enc->error[j];
1048 scale= enc->width*enc->height*255.0*255.0*frame_number;
1050 error= enc->coded_frame->error[j];
1051 scale= enc->width*enc->height*255.0*255.0;
1056 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1058 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1062 /* compute min output value */
1063 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1064 if ((pts < ti1) && (pts > 0))
1070 if (verbose || is_last_report) {
1071 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1073 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1074 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1075 (double)total_size / 1024, ti1, bitrate);
1078 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1079 nb_frames_dup, nb_frames_drop);
1082 fprintf(stderr, "%s \r", buf);
1087 if (is_last_report && verbose >= 0){
1088 int64_t raw= audio_size + video_size + extra_size;
1089 fprintf(stderr, "\n");
1090 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1094 100.0*(total_size - raw)/raw
1099 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1100 static int output_packet(AVInputStream *ist, int ist_index,
1101 AVOutputStream **ost_table, int nb_ostreams,
1102 const AVPacket *pkt)
1104 AVFormatContext *os;
1105 AVOutputStream *ost;
1109 int data_size, got_picture;
1111 void *buffer_to_free;
1112 static unsigned int samples_size= 0;
1113 static short *samples= NULL;
1114 AVSubtitle subtitle, *subtitle_to_free;
1117 if(ist->next_pts == AV_NOPTS_VALUE)
1118 ist->next_pts= ist->pts;
1127 if(pkt->dts != AV_NOPTS_VALUE)
1128 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1134 ist->pts= ist->next_pts;
1136 if(len && len != pkt->size && verbose>0)
1137 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1139 /* decode the packet if needed */
1140 data_buf = NULL; /* fail safe */
1142 subtitle_to_free = NULL;
1143 if (ist->decoding_needed) {
1144 switch(ist->st->codec->codec_type) {
1145 case CODEC_TYPE_AUDIO:{
1147 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE));
1148 data_size= samples_size;
1149 /* XXX: could avoid copy if PCM 16 bits with same
1150 endianness as CPU */
1151 ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1157 /* Some bug in mpeg audio decoder gives */
1158 /* data_size < 0, it seems they are overflows */
1159 if (data_size <= 0) {
1160 /* no audio frame */
1163 data_buf = (uint8_t *)samples;
1164 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1165 (ist->st->codec->sample_rate * ist->st->codec->channels);
1167 case CODEC_TYPE_VIDEO:
1168 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1169 /* XXX: allocate picture correctly */
1170 avcodec_get_frame_defaults(&picture);
1172 ret = avcodec_decode_video(ist->st->codec,
1173 &picture, &got_picture, ptr, len);
1174 ist->st->quality= picture.quality;
1178 /* no picture yet */
1179 goto discard_packet;
1181 if (ist->st->codec->time_base.num != 0) {
1182 ist->next_pts += ((int64_t)AV_TIME_BASE *
1183 ist->st->codec->time_base.num) /
1184 ist->st->codec->time_base.den;
1188 case CODEC_TYPE_SUBTITLE:
1189 ret = avcodec_decode_subtitle(ist->st->codec,
1190 &subtitle, &got_subtitle, ptr, len);
1193 if (!got_subtitle) {
1194 goto discard_packet;
1196 subtitle_to_free = &subtitle;
1203 switch(ist->st->codec->codec_type) {
1204 case CODEC_TYPE_AUDIO:
1205 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1206 ist->st->codec->sample_rate;
1208 case CODEC_TYPE_VIDEO:
1209 if (ist->st->codec->time_base.num != 0) {
1210 ist->next_pts += ((int64_t)AV_TIME_BASE *
1211 ist->st->codec->time_base.num) /
1212 ist->st->codec->time_base.den;
1222 buffer_to_free = NULL;
1223 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1224 pre_process_video_frame(ist, (AVPicture *)&picture,
1228 // preprocess audio (volume)
1229 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1230 if (audio_volume != 256) {
1233 for(i=0;i<(data_size / sizeof(short));i++) {
1234 int v = ((*volp) * audio_volume + 128) >> 8;
1235 if (v < -32768) v = -32768;
1236 if (v > 32767) v = 32767;
1242 /* frame rate emulation */
1243 if (ist->st->codec->rate_emu) {
1244 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1245 int64_t now = av_gettime() - ist->start;
1253 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1254 is the one of the next displayed one */
1255 /* XXX: add mpeg4 too ? */
1256 if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1257 if (ist->st->codec->pict_type != B_TYPE) {
1259 tmp = ist->last_ip_pts;
1260 ist->last_ip_pts = ist->frac_pts.val;
1261 ist->frac_pts.val = tmp;
1265 /* if output time reached then transcode raw format,
1266 encode packets and output them */
1267 if (start_time == 0 || ist->pts >= start_time)
1268 for(i=0;i<nb_ostreams;i++) {
1272 if (ost->source_index == ist_index) {
1273 os = output_files[ost->file_index];
1276 printf("%d: got pts=%0.3f %0.3f\n", i,
1277 (double)pkt->pts / AV_TIME_BASE,
1278 ((double)ist->pts / AV_TIME_BASE) -
1279 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1281 /* set the input output pts pairs */
1282 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1284 if (ost->encoding_needed) {
1285 switch(ost->st->codec->codec_type) {
1286 case CODEC_TYPE_AUDIO:
1287 do_audio_out(os, ost, ist, data_buf, data_size);
1289 case CODEC_TYPE_VIDEO:
1290 do_video_out(os, ost, ist, &picture, &frame_size);
1291 video_size += frame_size;
1292 if (vstats_filename && frame_size)
1293 do_video_stats(os, ost, frame_size);
1295 case CODEC_TYPE_SUBTITLE:
1296 do_subtitle_out(os, ost, ist, &subtitle,
1303 AVFrame avframe; //FIXME/XXX remove this
1305 av_init_packet(&opkt);
1307 if (!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY))
1310 /* no reencoding needed : output the packet directly */
1311 /* force the input stream PTS */
1313 avcodec_get_frame_defaults(&avframe);
1314 ost->st->codec->coded_frame= &avframe;
1315 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1317 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1318 audio_size += data_size;
1319 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1320 video_size += data_size;
1324 opkt.stream_index= ost->index;
1325 if(pkt->pts != AV_NOPTS_VALUE)
1326 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1328 opkt.pts= AV_NOPTS_VALUE;
1330 if (pkt->dts == AV_NOPTS_VALUE)
1331 opkt.dts = av_rescale_q(ist->next_pts, AV_TIME_BASE_Q, ost->st->time_base);
1333 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1335 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1336 opkt.flags= pkt->flags;
1338 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1339 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1340 opkt.destruct= av_destruct_packet;
1342 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1343 ost->st->codec->frame_number++;
1344 ost->frame_number++;
1345 av_free_packet(&opkt);
1349 av_free(buffer_to_free);
1350 /* XXX: allocate the subtitles in the codec ? */
1351 if (subtitle_to_free) {
1352 if (subtitle_to_free->rects != NULL) {
1353 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1354 av_free(subtitle_to_free->rects[i].bitmap);
1355 av_free(subtitle_to_free->rects[i].rgba_palette);
1357 av_freep(&subtitle_to_free->rects);
1359 subtitle_to_free->num_rects = 0;
1360 subtitle_to_free = NULL;
1367 for(i=0;i<nb_ostreams;i++) {
1369 if (ost->source_index == ist_index) {
1370 AVCodecContext *enc= ost->st->codec;
1371 os = output_files[ost->file_index];
1373 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1375 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1378 if (ost->encoding_needed) {
1382 av_init_packet(&pkt);
1383 pkt.stream_index= ost->index;
1385 switch(ost->st->codec->codec_type) {
1386 case CODEC_TYPE_AUDIO:
1387 fifo_bytes = av_fifo_size(&ost->fifo);
1389 /* encode any samples remaining in fifo */
1390 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1391 int fs_tmp = enc->frame_size;
1392 enc->frame_size = fifo_bytes / (2 * enc->channels);
1393 av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes);
1394 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1395 enc->frame_size = fs_tmp;
1398 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1401 pkt.flags |= PKT_FLAG_KEY;
1403 case CODEC_TYPE_VIDEO:
1404 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1406 if(enc->coded_frame && enc->coded_frame->key_frame)
1407 pkt.flags |= PKT_FLAG_KEY;
1408 if (ost->logfile && enc->stats_out) {
1409 fprintf(ost->logfile, "%s", enc->stats_out);
1418 pkt.data= bit_buffer;
1420 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1421 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1422 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1434 static void print_sdp(AVFormatContext **avc, int n)
1438 avf_sdp_create(avc, n, sdp, sizeof(sdp));
1439 printf("SDP:\n%s\n", sdp);
1442 static int stream_index_from_inputs(AVFormatContext **input_files,
1444 AVInputFile *file_table,
1445 AVInputStream **ist_table,
1446 enum CodecType type,
1450 for(z=0; z<nb_input_files; z++) {
1451 AVFormatContext *ic = input_files[z];
1452 for(p=0; p<ic->nb_programs; p++) {
1453 AVProgram *program = ic->programs[p];
1454 if(program->id != programid)
1456 for(q=0; q<program->nb_stream_indexes; q++) {
1457 int sidx = program->stream_index[q];
1458 int ris = file_table[z].ist_index + sidx;
1459 if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1469 * The following code is the main loop of the file converter
1471 static int av_encode(AVFormatContext **output_files,
1472 int nb_output_files,
1473 AVFormatContext **input_files,
1475 AVStreamMap *stream_maps, int nb_stream_maps)
1477 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1478 AVFormatContext *is, *os;
1479 AVCodecContext *codec, *icodec;
1480 AVOutputStream *ost, **ost_table = NULL;
1481 AVInputStream *ist, **ist_table = NULL;
1482 AVInputFile *file_table;
1486 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1490 /* input stream init */
1492 for(i=0;i<nb_input_files;i++) {
1493 is = input_files[i];
1494 file_table[i].ist_index = j;
1495 file_table[i].nb_streams = is->nb_streams;
1496 j += is->nb_streams;
1500 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1504 for(i=0;i<nb_istreams;i++) {
1505 ist = av_mallocz(sizeof(AVInputStream));
1511 for(i=0;i<nb_input_files;i++) {
1512 is = input_files[i];
1513 for(k=0;k<is->nb_streams;k++) {
1514 ist = ist_table[j++];
1515 ist->st = is->streams[k];
1516 ist->file_index = i;
1518 ist->discard = 1; /* the stream is discarded by default
1521 if (ist->st->codec->rate_emu) {
1522 ist->start = av_gettime();
1528 /* output stream init */
1530 for(i=0;i<nb_output_files;i++) {
1531 os = output_files[i];
1532 if (!os->nb_streams) {
1533 fprintf(stderr, "Output file does not contain any stream\n");
1536 nb_ostreams += os->nb_streams;
1538 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1539 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1543 /* Sanity check the mapping args -- do the input files & streams exist? */
1544 for(i=0;i<nb_stream_maps;i++) {
1545 int fi = stream_maps[i].file_index;
1546 int si = stream_maps[i].stream_index;
1548 if (fi < 0 || fi > nb_input_files - 1 ||
1549 si < 0 || si > file_table[fi].nb_streams - 1) {
1550 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1553 fi = stream_maps[i].sync_file_index;
1554 si = stream_maps[i].sync_stream_index;
1555 if (fi < 0 || fi > nb_input_files - 1 ||
1556 si < 0 || si > file_table[fi].nb_streams - 1) {
1557 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1562 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1565 for(i=0;i<nb_ostreams;i++) {
1566 ost = av_mallocz(sizeof(AVOutputStream));
1573 for(k=0;k<nb_output_files;k++) {
1574 os = output_files[k];
1575 for(i=0;i<os->nb_streams;i++) {
1577 ost = ost_table[n++];
1578 ost->file_index = k;
1580 ost->st = os->streams[i];
1581 if (nb_stream_maps > 0) {
1582 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1583 stream_maps[n-1].stream_index;
1585 /* Sanity check that the stream types match */
1586 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1587 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1588 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1589 ost->file_index, ost->index);
1596 j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1598 ost->source_index = j;
1602 /* get corresponding input stream index : we select the first one with the right type */
1604 for(j=0;j<nb_istreams;j++) {
1607 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1608 ost->source_index = j;
1616 if(! opt_programid) {
1617 /* try again and reuse existing stream */
1618 for(j=0;j<nb_istreams;j++) {
1620 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1621 ost->source_index = j;
1627 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1628 ost->file_index, ost->index);
1633 ist = ist_table[ost->source_index];
1635 ost->sync_ist = (nb_stream_maps > 0) ?
1636 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1637 stream_maps[n-1].sync_stream_index] : ist;
1641 /* for each output stream, we compute the right encoding parameters */
1642 for(i=0;i<nb_ostreams;i++) {
1644 os = output_files[ost->file_index];
1645 ist = ist_table[ost->source_index];
1647 codec = ost->st->codec;
1648 icodec = ist->st->codec;
1650 if (!ost->st->language[0])
1651 av_strlcpy(ost->st->language, ist->st->language,
1652 sizeof(ost->st->language));
1654 ost->st->disposition = ist->st->disposition;
1656 if (ost->st->stream_copy) {
1657 /* if stream_copy is selected, no need to decode or encode */
1658 codec->codec_id = icodec->codec_id;
1659 codec->codec_type = icodec->codec_type;
1661 if(!codec->codec_tag){
1662 if( !os->oformat->codec_tag
1663 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1664 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1665 codec->codec_tag = icodec->codec_tag;
1668 codec->bit_rate = icodec->bit_rate;
1669 codec->extradata= icodec->extradata;
1670 codec->extradata_size= icodec->extradata_size;
1671 if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1672 codec->time_base = icodec->time_base;
1674 codec->time_base = ist->st->time_base;
1675 switch(codec->codec_type) {
1676 case CODEC_TYPE_AUDIO:
1677 codec->sample_rate = icodec->sample_rate;
1678 codec->channels = icodec->channels;
1679 codec->frame_size = icodec->frame_size;
1680 codec->block_align= icodec->block_align;
1681 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1682 codec->block_align= 0;
1683 if(codec->codec_id == CODEC_ID_AC3)
1684 codec->block_align= 0;
1686 case CODEC_TYPE_VIDEO:
1688 fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1691 codec->pix_fmt = icodec->pix_fmt;
1692 codec->width = icodec->width;
1693 codec->height = icodec->height;
1694 codec->has_b_frames = icodec->has_b_frames;
1696 case CODEC_TYPE_SUBTITLE:
1702 switch(codec->codec_type) {
1703 case CODEC_TYPE_AUDIO:
1704 if (av_fifo_init(&ost->fifo, 1024))
1706 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1707 icodec->request_channels = codec->channels;
1708 ist->decoding_needed = 1;
1709 ost->encoding_needed = 1;
1711 case CODEC_TYPE_VIDEO:
1712 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1713 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1714 ost->video_resample = ((codec->width != icodec->width -
1715 (frame_leftBand + frame_rightBand) +
1716 (frame_padleft + frame_padright)) ||
1717 (codec->height != icodec->height -
1718 (frame_topBand + frame_bottomBand) +
1719 (frame_padtop + frame_padbottom)) ||
1720 (codec->pix_fmt != icodec->pix_fmt));
1721 if (ost->video_crop) {
1722 ost->topBand = frame_topBand;
1723 ost->leftBand = frame_leftBand;
1725 if (ost->video_pad) {
1726 ost->padtop = frame_padtop;
1727 ost->padleft = frame_padleft;
1728 ost->padbottom = frame_padbottom;
1729 ost->padright = frame_padright;
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))
1737 if (ost->video_resample) {
1738 avcodec_get_frame_defaults(&ost->pict_tmp);
1739 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1740 codec->width, codec->height)) {
1741 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1744 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1745 ost->img_resample_ctx = sws_getContext(
1746 icodec->width - (frame_leftBand + frame_rightBand),
1747 icodec->height - (frame_topBand + frame_bottomBand),
1749 codec->width - (frame_padleft + frame_padright),
1750 codec->height - (frame_padtop + frame_padbottom),
1752 sws_flags, NULL, NULL, NULL);
1753 if (ost->img_resample_ctx == NULL) {
1754 fprintf(stderr, "Cannot get resampling context\n");
1757 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1759 ost->encoding_needed = 1;
1760 ist->decoding_needed = 1;
1762 case CODEC_TYPE_SUBTITLE:
1763 ost->encoding_needed = 1;
1764 ist->decoding_needed = 1;
1771 if (ost->encoding_needed &&
1772 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1773 char logfilename[1024];
1778 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1780 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1781 if (codec->flags & CODEC_FLAG_PASS1) {
1782 f = fopen(logfilename, "w");
1784 perror(logfilename);
1789 /* read the log file */
1790 f = fopen(logfilename, "r");
1792 perror(logfilename);
1795 fseek(f, 0, SEEK_END);
1797 fseek(f, 0, SEEK_SET);
1798 logbuffer = av_malloc(size + 1);
1800 fprintf(stderr, "Could not allocate log buffer\n");
1803 size = fread(logbuffer, 1, size, f);
1805 logbuffer[size] = '\0';
1806 codec->stats_in = logbuffer;
1810 if(codec->codec_type == CODEC_TYPE_VIDEO){
1811 int size= codec->width * codec->height;
1812 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1817 bit_buffer = av_malloc(bit_buffer_size);
1821 /* dump the file output parameters - cannot be done before in case
1823 for(i=0;i<nb_output_files;i++) {
1824 dump_format(output_files[i], i, output_files[i]->filename, 1);
1827 /* dump the stream mapping */
1829 fprintf(stderr, "Stream mapping:\n");
1830 for(i=0;i<nb_ostreams;i++) {
1832 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1833 ist_table[ost->source_index]->file_index,
1834 ist_table[ost->source_index]->index,
1837 if (ost->sync_ist != ist_table[ost->source_index])
1838 fprintf(stderr, " [sync #%d.%d]",
1839 ost->sync_ist->file_index,
1840 ost->sync_ist->index);
1841 fprintf(stderr, "\n");
1845 /* open each encoder */
1846 for(i=0;i<nb_ostreams;i++) {
1848 if (ost->encoding_needed) {
1850 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1852 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1853 ost->file_index, ost->index);
1856 if (avcodec_open(ost->st->codec, codec) < 0) {
1857 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1858 ost->file_index, ost->index);
1861 extra_size += ost->st->codec->extradata_size;
1865 /* open each decoder */
1866 for(i=0;i<nb_istreams;i++) {
1868 if (ist->decoding_needed) {
1870 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1872 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1873 ist->st->codec->codec_id, ist->file_index, ist->index);
1876 if (avcodec_open(ist->st->codec, codec) < 0) {
1877 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1878 ist->file_index, ist->index);
1881 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1882 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1887 for(i=0;i<nb_istreams;i++) {
1889 is = input_files[ist->file_index];
1891 ist->next_pts = AV_NOPTS_VALUE;
1895 /* set meta data information from input file if required */
1896 for (i=0;i<nb_meta_data_maps;i++) {
1897 AVFormatContext *out_file;
1898 AVFormatContext *in_file;
1900 int out_file_index = meta_data_maps[i].out_file;
1901 int in_file_index = meta_data_maps[i].in_file;
1902 if (out_file_index < 0 || out_file_index >= nb_output_files) {
1903 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1904 ret = AVERROR(EINVAL);
1907 if (in_file_index < 0 || in_file_index >= nb_input_files) {
1908 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1909 ret = AVERROR(EINVAL);
1913 out_file = output_files[out_file_index];
1914 in_file = input_files[in_file_index];
1916 strcpy(out_file->title, in_file->title);
1917 strcpy(out_file->author, in_file->author);
1918 strcpy(out_file->copyright, in_file->copyright);
1919 strcpy(out_file->comment, in_file->comment);
1920 strcpy(out_file->album, in_file->album);
1921 out_file->year = in_file->year;
1922 out_file->track = in_file->track;
1923 strcpy(out_file->genre, in_file->genre);
1926 /* open files and write file headers */
1927 for(i=0;i<nb_output_files;i++) {
1928 os = output_files[i];
1929 if (av_write_header(os) < 0) {
1930 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1931 ret = AVERROR(EINVAL);
1934 if (strcmp(output_files[i]->oformat->name, "rtp")) {
1939 print_sdp(output_files, nb_output_files);
1942 if (!using_stdin && verbose >= 0) {
1943 fprintf(stderr, "Press [q] to stop encoding\n");
1944 url_set_interrupt_cb(decode_interrupt_cb);
1949 timer_start = av_gettime();
1951 for(; received_sigterm == 0;) {
1952 int file_index, ist_index;
1960 /* if 'q' pressed, exits */
1964 /* read_key() returns 0 on EOF */
1970 /* select the stream that we must read now by looking at the
1971 smallest output pts */
1973 for(i=0;i<nb_ostreams;i++) {
1976 os = output_files[ost->file_index];
1977 ist = ist_table[ost->source_index];
1978 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1979 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1981 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1982 ipts = (double)ist->pts;
1983 if (!file_table[ist->file_index].eof_reached){
1984 if(ipts < ipts_min) {
1986 if(input_sync ) file_index = ist->file_index;
1988 if(opts < opts_min) {
1990 if(!input_sync) file_index = ist->file_index;
1993 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1998 /* if none, if is finished */
1999 if (file_index < 0) {
2003 /* finish if recording time exhausted */
2004 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
2007 /* finish if limit size exhausted */
2008 if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2011 /* read a frame from it and output it in the fifo */
2012 is = input_files[file_index];
2013 if (av_read_frame(is, &pkt) < 0) {
2014 file_table[file_index].eof_reached = 1;
2022 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2024 /* the following test is needed in case new streams appear
2025 dynamically in stream : we ignore them */
2026 if (pkt.stream_index >= file_table[file_index].nb_streams)
2027 goto discard_packet;
2028 ist_index = file_table[file_index].ist_index + pkt.stream_index;
2029 ist = ist_table[ist_index];
2031 goto discard_packet;
2033 if (pkt.dts != AV_NOPTS_VALUE)
2034 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2035 if (pkt.pts != AV_NOPTS_VALUE)
2036 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2038 // 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);
2039 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
2040 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2041 int64_t delta= pkt_dts - ist->next_pts;
2042 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2043 input_files_ts_offset[ist->file_index]-= delta;
2045 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2046 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2047 if(pkt.pts != AV_NOPTS_VALUE)
2048 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2052 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2053 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2056 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2057 ist->file_index, ist->index);
2059 av_free_packet(&pkt);
2064 av_free_packet(&pkt);
2066 /* dump report by using the output first video and audio streams */
2067 print_report(output_files, ost_table, nb_ostreams, 0);
2070 /* at the end of stream, we must flush the decoder buffers */
2071 for(i=0;i<nb_istreams;i++) {
2073 if (ist->decoding_needed) {
2074 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2080 /* write the trailer if needed and close file */
2081 for(i=0;i<nb_output_files;i++) {
2082 os = output_files[i];
2083 av_write_trailer(os);
2086 /* dump report by using the first video and audio streams */
2087 print_report(output_files, ost_table, nb_ostreams, 1);
2089 /* close each encoder */
2090 for(i=0;i<nb_ostreams;i++) {
2092 if (ost->encoding_needed) {
2093 av_freep(&ost->st->codec->stats_in);
2094 avcodec_close(ost->st->codec);
2098 /* close each decoder */
2099 for(i=0;i<nb_istreams;i++) {
2101 if (ist->decoding_needed) {
2102 avcodec_close(ist->st->codec);
2110 av_freep(&bit_buffer);
2111 av_free(file_table);
2114 for(i=0;i<nb_istreams;i++) {
2121 for(i=0;i<nb_ostreams;i++) {
2125 fclose(ost->logfile);
2126 ost->logfile = NULL;
2128 av_fifo_free(&ost->fifo); /* works even if fifo is not
2129 initialized but set to zero */
2130 av_free(ost->pict_tmp.data[0]);
2131 if (ost->video_resample)
2132 sws_freeContext(ost->img_resample_ctx);
2134 audio_resample_close(ost->resample);
2142 ret = AVERROR(ENOMEM);
2147 int file_read(const char *filename)
2150 unsigned char buffer[1024];
2153 if (url_open(&h, filename, O_RDONLY) < 0) {
2154 printf("could not open '%s'\n", filename);
2158 len = url_read(h, buffer, sizeof(buffer));
2161 for(i=0;i<len;i++) putchar(buffer[i]);
2168 static void opt_format(const char *arg)
2170 /* compatibility stuff for pgmyuv */
2171 if (!strcmp(arg, "pgmyuv")) {
2172 pgmyuv_compatibility_hack=1;
2173 // opt_image_format(arg);
2175 fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2178 file_iformat = av_find_input_format(arg);
2179 file_oformat = guess_format(arg, NULL, NULL);
2180 if (!file_iformat && !file_oformat) {
2181 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2186 static int opt_default(const char *opt, const char *arg){
2188 const AVOption *o= NULL;
2189 int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
2191 for(type=0; type<CODEC_TYPE_NB; type++){
2192 const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
2194 o = av_set_string(avctx_opts[type], opt, arg);
2197 o = av_set_string(avformat_opts, opt, arg);
2199 o = av_set_string(sws_opts, opt, arg);
2202 o = av_set_string(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg);
2203 else if(opt[0] == 'v')
2204 o = av_set_string(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg);
2205 else if(opt[0] == 's')
2206 o = av_set_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg);
2211 // 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));
2213 //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
2214 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
2215 opt_names[opt_name_count++]= o->name;
2217 if(avctx_opts[0]->debug)
2218 av_log_set_level(AV_LOG_DEBUG);
2222 static void opt_video_rc_override_string(const char *arg)
2224 video_rc_override_string = arg;
2227 static int opt_me_threshold(const char *opt, const char *arg)
2229 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2233 static int opt_verbose(const char *opt, const char *arg)
2235 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2236 av_log_set_level(verbose);
2240 static void opt_frame_rate(const char *arg)
2242 if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2243 fprintf(stderr, "Incorrect frame rate\n");
2248 static int opt_bitrate(const char *opt, const char *arg)
2250 int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2252 opt_default(opt, arg);
2254 if (av_get_int(avctx_opts[codec_type], "b", NULL) < 1000)
2255 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2260 static void opt_frame_crop_top(const char *arg)
2262 frame_topBand = atoi(arg);
2263 if (frame_topBand < 0) {
2264 fprintf(stderr, "Incorrect top crop size\n");
2267 if ((frame_topBand % 2) != 0) {
2268 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2271 if ((frame_topBand) >= frame_height){
2272 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2275 frame_height -= frame_topBand;
2278 static void opt_frame_crop_bottom(const char *arg)
2280 frame_bottomBand = atoi(arg);
2281 if (frame_bottomBand < 0) {
2282 fprintf(stderr, "Incorrect bottom crop size\n");
2285 if ((frame_bottomBand % 2) != 0) {
2286 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2289 if ((frame_bottomBand) >= frame_height){
2290 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2293 frame_height -= frame_bottomBand;
2296 static void opt_frame_crop_left(const char *arg)
2298 frame_leftBand = atoi(arg);
2299 if (frame_leftBand < 0) {
2300 fprintf(stderr, "Incorrect left crop size\n");
2303 if ((frame_leftBand % 2) != 0) {
2304 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2307 if ((frame_leftBand) >= frame_width){
2308 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2311 frame_width -= frame_leftBand;
2314 static void opt_frame_crop_right(const char *arg)
2316 frame_rightBand = atoi(arg);
2317 if (frame_rightBand < 0) {
2318 fprintf(stderr, "Incorrect right crop size\n");
2321 if ((frame_rightBand % 2) != 0) {
2322 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2325 if ((frame_rightBand) >= frame_width){
2326 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2329 frame_width -= frame_rightBand;
2332 static void opt_frame_size(const char *arg)
2334 if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2335 fprintf(stderr, "Incorrect frame size\n");
2338 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2339 fprintf(stderr, "Frame size must be a multiple of 2\n");
2345 #define SCALEBITS 10
2346 #define ONE_HALF (1 << (SCALEBITS - 1))
2347 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2349 #define RGB_TO_Y(r, g, b) \
2350 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2351 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2353 #define RGB_TO_U(r1, g1, b1, shift)\
2354 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2355 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2357 #define RGB_TO_V(r1, g1, b1, shift)\
2358 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2359 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2361 static void opt_pad_color(const char *arg) {
2362 /* Input is expected to be six hex digits similar to
2363 how colors are expressed in html tags (but without the #) */
2364 int rgb = strtol(arg, NULL, 16);
2368 g = ((rgb >> 8) & 255);
2371 padcolor[0] = RGB_TO_Y(r,g,b);
2372 padcolor[1] = RGB_TO_U(r,g,b,0);
2373 padcolor[2] = RGB_TO_V(r,g,b,0);
2376 static void opt_frame_pad_top(const char *arg)
2378 frame_padtop = atoi(arg);
2379 if (frame_padtop < 0) {
2380 fprintf(stderr, "Incorrect top pad size\n");
2383 if ((frame_padtop % 2) != 0) {
2384 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2389 static void opt_frame_pad_bottom(const char *arg)
2391 frame_padbottom = atoi(arg);
2392 if (frame_padbottom < 0) {
2393 fprintf(stderr, "Incorrect bottom pad size\n");
2396 if ((frame_padbottom % 2) != 0) {
2397 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2403 static void opt_frame_pad_left(const char *arg)
2405 frame_padleft = atoi(arg);
2406 if (frame_padleft < 0) {
2407 fprintf(stderr, "Incorrect left pad size\n");
2410 if ((frame_padleft % 2) != 0) {
2411 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2417 static void opt_frame_pad_right(const char *arg)
2419 frame_padright = atoi(arg);
2420 if (frame_padright < 0) {
2421 fprintf(stderr, "Incorrect right pad size\n");
2424 if ((frame_padright % 2) != 0) {
2425 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2430 static void list_pix_fmts(void)
2433 char pix_fmt_str[128];
2434 for (i=-1; i < PIX_FMT_NB; i++) {
2435 avcodec_pix_fmt_string (pix_fmt_str, sizeof(pix_fmt_str), i);
2436 fprintf(stdout, "%s\n", pix_fmt_str);
2440 static void opt_frame_pix_fmt(const char *arg)
2442 if (strcmp(arg, "list"))
2443 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2450 static void opt_frame_aspect_ratio(const char *arg)
2457 p = strchr(arg, ':');
2459 x = strtol(arg, &end, 10);
2461 y = strtol(end+1, &end, 10);
2463 ar = (double)x / (double)y;
2465 ar = strtod(arg, NULL);
2468 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2471 frame_aspect_ratio = ar;
2474 static void opt_qscale(const char *arg)
2476 video_qscale = atof(arg);
2477 if (video_qscale <= 0 ||
2478 video_qscale > 255) {
2479 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2484 static void opt_qdiff(const char *arg)
2486 video_qdiff = atoi(arg);
2487 if (video_qdiff < 0 ||
2489 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2494 static void opt_strict(const char *arg)
2499 static void opt_top_field_first(const char *arg)
2501 top_field_first= atoi(arg);
2504 static void opt_thread_count(const char *arg)
2506 thread_count= atoi(arg);
2507 #if !defined(HAVE_THREADS)
2509 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2513 static int opt_audio_rate(const char *opt, const char *arg)
2515 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2519 static int opt_audio_channels(const char *opt, const char *arg)
2521 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2525 static void opt_video_channel(const char *arg)
2527 video_channel = strtol(arg, NULL, 0);
2530 static void opt_video_standard(const char *arg)
2532 video_standard = av_strdup(arg);
2535 static void opt_codec(int *pstream_copy, char **pcodec_name,
2536 int codec_type, const char *arg)
2538 av_freep(pcodec_name);
2539 if (!strcmp(arg, "copy")) {
2542 *pcodec_name = av_strdup(arg);
2546 static void opt_audio_codec(const char *arg)
2548 opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2551 static void opt_audio_tag(const char *arg)
2554 audio_codec_tag= strtol(arg, &tail, 0);
2557 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2560 static void opt_video_tag(const char *arg)
2563 video_codec_tag= strtol(arg, &tail, 0);
2566 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2570 static void add_frame_hooker(const char *arg)
2575 char *args = av_strdup(arg);
2579 argv[0] = strtok(args, " ");
2580 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2583 i = frame_hook_add(argc, argv);
2586 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2592 static void opt_video_codec(const char *arg)
2594 opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2597 static void opt_subtitle_codec(const char *arg)
2599 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2602 static void opt_map(const char *arg)
2607 m = &stream_maps[nb_stream_maps++];
2609 m->file_index = strtol(arg, &p, 0);
2613 m->stream_index = strtol(p, &p, 0);
2616 m->sync_file_index = strtol(p, &p, 0);
2619 m->sync_stream_index = strtol(p, &p, 0);
2621 m->sync_file_index = m->file_index;
2622 m->sync_stream_index = m->stream_index;
2626 static void opt_map_meta_data(const char *arg)
2631 m = &meta_data_maps[nb_meta_data_maps++];
2633 m->out_file = strtol(arg, &p, 0);
2637 m->in_file = strtol(p, &p, 0);
2640 static int opt_recording_time(const char *opt, const char *arg)
2642 recording_time = parse_time_or_die(opt, arg, 1);
2646 static int opt_start_time(const char *opt, const char *arg)
2648 start_time = parse_time_or_die(opt, arg, 1);
2652 static int opt_rec_timestamp(const char *opt, const char *arg)
2654 rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2658 static int opt_input_ts_offset(const char *opt, const char *arg)
2660 input_ts_offset = parse_time_or_die(opt, arg, 1);
2664 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2666 const char *codec_string = encoder ? "encoder" : "decoder";
2670 return CODEC_ID_NONE;
2672 avcodec_find_encoder_by_name(name) :
2673 avcodec_find_decoder_by_name(name);
2675 av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2678 if(codec->type != type) {
2679 av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2685 static void opt_input_file(const char *filename)
2687 AVFormatContext *ic;
2688 AVFormatParameters params, *ap = ¶ms;
2689 int err, i, ret, rfps, rfps_base;
2692 if (!strcmp(filename, "-"))
2695 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2696 !strcmp(filename, "/dev/stdin");
2698 /* get default parameters from command line */
2699 ic = av_alloc_format_context();
2701 memset(ap, 0, sizeof(*ap));
2702 ap->prealloced_context = 1;
2703 ap->sample_rate = audio_sample_rate;
2704 ap->channels = audio_channels;
2705 ap->time_base.den = frame_rate.num;
2706 ap->time_base.num = frame_rate.den;
2707 ap->width = frame_width + frame_padleft + frame_padright;
2708 ap->height = frame_height + frame_padtop + frame_padbottom;
2709 ap->pix_fmt = frame_pix_fmt;
2710 ap->channel = video_channel;
2711 ap->standard = video_standard;
2712 ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2713 ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2714 if(pgmyuv_compatibility_hack)
2715 ap->video_codec_id= CODEC_ID_PGMYUV;
2717 for(i=0; i<opt_name_count; i++){
2719 const AVOption *opt;
2720 const char *str= av_get_string(avformat_opts, opt_names[i], &opt, buf, sizeof(buf));
2721 if(str && (opt->flags & AV_OPT_FLAG_DECODING_PARAM))
2722 av_set_string(ic, opt_names[i], str);
2725 ic->video_codec_id = find_codec_or_die(video_codec_name , CODEC_TYPE_VIDEO , 0);
2726 ic->audio_codec_id = find_codec_or_die(audio_codec_name , CODEC_TYPE_AUDIO , 0);
2727 ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2729 /* open the input file with generic libav function */
2730 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2732 print_error(filename, err);
2737 for(i=0; i<ic->nb_programs; i++)
2738 if(ic->programs[i]->id != opt_programid)
2739 ic->programs[i]->discard = AVDISCARD_ALL;
2742 ic->loop_input = loop_input;
2744 /* If not enough info to get the stream parameters, we decode the
2745 first frames to get it. (used in mpeg case for example) */
2746 ret = av_find_stream_info(ic);
2747 if (ret < 0 && verbose >= 0) {
2748 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2752 timestamp = start_time;
2753 /* add the stream start time */
2754 if (ic->start_time != AV_NOPTS_VALUE)
2755 timestamp += ic->start_time;
2757 /* if seeking requested, we execute it */
2758 if (start_time != 0) {
2759 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2761 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2762 filename, (double)timestamp / AV_TIME_BASE);
2764 /* reset seek info */
2768 /* update the current parameters so that they match the one of the input stream */
2769 for(i=0;i<ic->nb_streams;i++) {
2771 AVCodecContext *enc = ic->streams[i]->codec;
2773 avcodec_thread_init(enc, thread_count);
2774 enc->thread_count= thread_count;
2775 switch(enc->codec_type) {
2776 case CODEC_TYPE_AUDIO:
2777 for(j=0; j<opt_name_count; j++){
2779 const AVOption *opt;
2780 const char *str= av_get_string(avctx_opts[CODEC_TYPE_AUDIO], opt_names[j], &opt, buf, sizeof(buf));
2781 if(str && (opt->flags & AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags & AV_OPT_FLAG_DECODING_PARAM))
2782 av_set_string(enc, opt_names[j], str);
2784 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2785 audio_channels = enc->channels;
2786 audio_sample_rate = enc->sample_rate;
2788 ic->streams[i]->discard= AVDISCARD_ALL;
2790 case CODEC_TYPE_VIDEO:
2791 for(j=0; j<opt_name_count; j++){
2793 const AVOption *opt;
2794 const char *str= av_get_string(avctx_opts[CODEC_TYPE_VIDEO], opt_names[j], &opt, buf, sizeof(buf));
2795 if(str && (opt->flags & AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags & AV_OPT_FLAG_DECODING_PARAM))
2796 av_set_string(enc, opt_names[j], str);
2798 frame_height = enc->height;
2799 frame_width = enc->width;
2800 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2801 frame_pix_fmt = enc->pix_fmt;
2802 rfps = ic->streams[i]->r_frame_rate.num;
2803 rfps_base = ic->streams[i]->r_frame_rate.den;
2804 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2806 enc->debug |= FF_DEBUG_MV;
2808 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2811 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2812 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2814 (float)rfps / rfps_base, rfps, rfps_base);
2816 /* update the current frame rate to match the stream frame rate */
2817 frame_rate.num = rfps;
2818 frame_rate.den = rfps_base;
2820 enc->rate_emu = rate_emu;
2822 ic->streams[i]->discard= AVDISCARD_ALL;
2823 else if(video_discard)
2824 ic->streams[i]->discard= video_discard;
2826 case CODEC_TYPE_DATA:
2828 case CODEC_TYPE_SUBTITLE:
2829 if(subtitle_disable)
2830 ic->streams[i]->discard = AVDISCARD_ALL;
2832 case CODEC_TYPE_ATTACHMENT:
2833 case CODEC_TYPE_UNKNOWN:
2840 input_files[nb_input_files] = ic;
2841 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2842 /* dump the file content */
2844 dump_format(ic, nb_input_files, filename, 0);
2847 file_iformat = NULL;
2848 file_oformat = NULL;
2853 av_freep(&video_codec_name);
2854 av_freep(&audio_codec_name);
2855 av_freep(&subtitle_codec_name);
2858 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2859 int *has_subtitle_ptr)
2861 int has_video, has_audio, has_subtitle, i, j;
2862 AVFormatContext *ic;
2867 for(j=0;j<nb_input_files;j++) {
2868 ic = input_files[j];
2869 for(i=0;i<ic->nb_streams;i++) {
2870 AVCodecContext *enc = ic->streams[i]->codec;
2871 switch(enc->codec_type) {
2872 case CODEC_TYPE_AUDIO:
2875 case CODEC_TYPE_VIDEO:
2878 case CODEC_TYPE_SUBTITLE:
2881 case CODEC_TYPE_DATA:
2882 case CODEC_TYPE_ATTACHMENT:
2883 case CODEC_TYPE_UNKNOWN:
2890 *has_video_ptr = has_video;
2891 *has_audio_ptr = has_audio;
2892 *has_subtitle_ptr = has_subtitle;
2895 static void new_video_stream(AVFormatContext *oc)
2898 AVCodecContext *video_enc;
2901 st = av_new_stream(oc, oc->nb_streams);
2903 fprintf(stderr, "Could not alloc stream\n");
2906 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2907 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2908 video_bitstream_filters= NULL;
2911 avcodec_thread_init(st->codec, thread_count);
2913 video_enc = st->codec;
2916 video_enc->codec_tag= video_codec_tag;
2918 if( (video_global_header&1)
2919 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2920 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2921 avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2923 if(video_global_header&2){
2924 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2925 avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2928 if (video_stream_copy) {
2929 st->stream_copy = 1;
2930 video_enc->codec_type = CODEC_TYPE_VIDEO;
2935 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
2937 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2938 if (video_codec_name)
2939 codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
2941 video_enc->codec_id = codec_id;
2942 codec = avcodec_find_encoder(codec_id);
2944 for(i=0; i<opt_name_count; i++){
2946 const AVOption *opt;
2947 const char *str= av_get_string(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt, buf, sizeof(buf));
2948 if(str && (opt->flags & AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
2949 av_set_string(video_enc, opt_names[i], str);
2952 video_enc->time_base.den = fps.num;
2953 video_enc->time_base.num = fps.den;
2954 if(codec && codec->supported_framerates){
2955 const AVRational *p= codec->supported_framerates;
2956 const AVRational *best=NULL;
2957 AVRational best_error= (AVRational){INT_MAX, 1};
2958 for(; p->den!=0; p++){
2959 AVRational error= av_sub_q(fps, *p);
2960 if(error.num <0) error.num *= -1;
2961 if(av_cmp_q(error, best_error) < 0){
2966 video_enc->time_base.den= best->num;
2967 video_enc->time_base.num= best->den;
2970 video_enc->width = frame_width + frame_padright + frame_padleft;
2971 video_enc->height = frame_height + frame_padtop + frame_padbottom;
2972 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2973 video_enc->pix_fmt = frame_pix_fmt;
2975 if(codec && codec->pix_fmts){
2976 const enum PixelFormat *p= codec->pix_fmts;
2978 if(*p == video_enc->pix_fmt)
2982 video_enc->pix_fmt = codec->pix_fmts[0];
2986 video_enc->gop_size = 0;
2987 if (video_qscale || same_quality) {
2988 video_enc->flags |= CODEC_FLAG_QSCALE;
2989 video_enc->global_quality=
2990 st->quality = FF_QP2LAMBDA * video_qscale;
2994 video_enc->intra_matrix = intra_matrix;
2996 video_enc->inter_matrix = inter_matrix;
2998 video_enc->max_qdiff = video_qdiff;
2999 video_enc->thread_count = thread_count;
3000 p= video_rc_override_string;
3003 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3005 fprintf(stderr, "error parsing rc_override\n");
3008 video_enc->rc_override=
3009 av_realloc(video_enc->rc_override,
3010 sizeof(RcOverride)*(i+1));
3011 video_enc->rc_override[i].start_frame= start;
3012 video_enc->rc_override[i].end_frame = end;
3014 video_enc->rc_override[i].qscale= q;
3015 video_enc->rc_override[i].quality_factor= 1.0;
3018 video_enc->rc_override[i].qscale= 0;
3019 video_enc->rc_override[i].quality_factor= -q/100.0;
3024 video_enc->rc_override_count=i;
3025 if (!video_enc->rc_initial_buffer_occupancy)
3026 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3027 video_enc->me_threshold= me_threshold;
3028 video_enc->intra_dc_precision= intra_dc_precision - 8;
3029 video_enc->strict_std_compliance = strict;
3032 video_enc->flags|= CODEC_FLAG_PSNR;
3037 video_enc->flags |= CODEC_FLAG_PASS1;
3039 video_enc->flags |= CODEC_FLAG_PASS2;
3044 /* reset some key parameters */
3046 av_freep(&video_codec_name);
3047 video_stream_copy = 0;
3050 static void new_audio_stream(AVFormatContext *oc)
3053 AVCodecContext *audio_enc;
3056 st = av_new_stream(oc, oc->nb_streams);
3058 fprintf(stderr, "Could not alloc stream\n");
3061 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3063 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3064 audio_bitstream_filters= NULL;
3067 avcodec_thread_init(st->codec, thread_count);
3069 audio_enc = st->codec;
3070 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3071 audio_enc->strict_std_compliance = strict;
3074 audio_enc->codec_tag= audio_codec_tag;
3076 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3077 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3078 avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3080 if (audio_stream_copy) {
3081 st->stream_copy = 1;
3082 audio_enc->channels = audio_channels;
3084 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3086 for(i=0; i<opt_name_count; i++){
3088 const AVOption *opt;
3089 const char *str= av_get_string(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt, buf, sizeof(buf));
3090 if(str && (opt->flags & AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3091 av_set_string(audio_enc, opt_names[i], str);
3094 if (audio_codec_name)
3095 codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3096 audio_enc->codec_id = codec_id;
3098 if (audio_qscale > QSCALE_NONE) {
3099 audio_enc->flags |= CODEC_FLAG_QSCALE;
3100 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3102 audio_enc->thread_count = thread_count;
3103 audio_enc->channels = audio_channels;
3105 audio_enc->sample_rate = audio_sample_rate;
3106 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3107 if (audio_language) {
3108 av_strlcpy(st->language, audio_language, sizeof(st->language));
3109 av_free(audio_language);
3110 audio_language = NULL;
3113 /* reset some key parameters */
3115 av_freep(&audio_codec_name);
3116 audio_stream_copy = 0;
3119 static void new_subtitle_stream(AVFormatContext *oc)
3122 AVCodecContext *subtitle_enc;
3125 st = av_new_stream(oc, oc->nb_streams);
3127 fprintf(stderr, "Could not alloc stream\n");
3130 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3132 bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3133 subtitle_bitstream_filters= NULL;
3135 subtitle_enc = st->codec;
3136 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3137 if (subtitle_stream_copy) {
3138 st->stream_copy = 1;
3140 for(i=0; i<opt_name_count; i++){
3142 const AVOption *opt;
3143 const char *str= av_get_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt_names[i], &opt, buf, sizeof(buf));
3144 if(str && (opt->flags & AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3145 av_set_string(subtitle_enc, opt_names[i], str);
3147 subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3150 if (subtitle_language) {
3151 av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3152 av_free(subtitle_language);
3153 subtitle_language = NULL;
3156 subtitle_disable = 0;
3157 av_freep(&subtitle_codec_name);
3158 subtitle_stream_copy = 0;
3161 static void opt_new_audio_stream(void)
3163 AVFormatContext *oc;
3164 if (nb_output_files <= 0) {
3165 fprintf(stderr, "At least one output file must be specified\n");
3168 oc = output_files[nb_output_files - 1];
3169 new_audio_stream(oc);
3172 static void opt_new_video_stream(void)
3174 AVFormatContext *oc;
3175 if (nb_output_files <= 0) {
3176 fprintf(stderr, "At least one output file must be specified\n");
3179 oc = output_files[nb_output_files - 1];
3180 new_video_stream(oc);
3183 static void opt_new_subtitle_stream(void)
3185 AVFormatContext *oc;
3186 if (nb_output_files <= 0) {
3187 fprintf(stderr, "At least one output file must be specified\n");
3190 oc = output_files[nb_output_files - 1];
3191 new_subtitle_stream(oc);
3194 static void opt_output_file(const char *filename)
3196 AVFormatContext *oc;
3197 int use_video, use_audio, use_subtitle;
3198 int input_has_video, input_has_audio, input_has_subtitle, i;
3199 AVFormatParameters params, *ap = ¶ms;
3201 if (!strcmp(filename, "-"))
3204 oc = av_alloc_format_context();
3206 if (!file_oformat) {
3207 file_oformat = guess_format(NULL, filename, NULL);
3208 if (!file_oformat) {
3209 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3215 oc->oformat = file_oformat;
3216 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3218 if (!strcmp(file_oformat->name, "ffm") &&
3219 av_strstart(filename, "http:", NULL)) {
3220 /* special case for files sent to ffserver: we get the stream
3221 parameters from ffserver */
3222 if (read_ffserver_streams(oc, filename) < 0) {
3223 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3227 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3228 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3229 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3231 /* disable if no corresponding type found and at least one
3233 if (nb_input_files > 0) {
3234 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3235 &input_has_subtitle);
3236 if (!input_has_video)
3238 if (!input_has_audio)
3240 if (!input_has_subtitle)
3244 /* manual disable */
3245 if (audio_disable) {
3248 if (video_disable) {
3251 if (subtitle_disable) {
3256 new_video_stream(oc);
3260 new_audio_stream(oc);
3264 new_subtitle_stream(oc);
3267 oc->timestamp = rec_timestamp;
3270 av_strlcpy(oc->title, str_title, sizeof(oc->title));
3272 av_strlcpy(oc->author, str_author, sizeof(oc->author));
3274 av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3276 av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3278 av_strlcpy(oc->album, str_album, sizeof(oc->album));
3280 av_strlcpy(oc->genre, str_genre, sizeof(oc->genre));
3283 output_files[nb_output_files++] = oc;
3285 /* check filename in case of an image number is expected */
3286 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3287 if (!av_filename_number_test(oc->filename)) {
3288 print_error(oc->filename, AVERROR_NUMEXPECTED);
3293 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3294 /* test if it already exists to avoid loosing precious files */
3295 if (!file_overwrite &&
3296 (strchr(filename, ':') == NULL ||
3297 filename[1] == ':' ||
3298 av_strstart(filename, "file:", NULL))) {
3299 if (url_exist(filename)) {
3303 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3306 if (toupper(c) != 'Y') {
3307 fprintf(stderr, "Not overwriting - exiting\n");
3312 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3319 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3320 fprintf(stderr, "Could not open '%s'\n", filename);
3325 memset(ap, 0, sizeof(*ap));
3326 if (av_set_parameters(oc, ap) < 0) {
3327 fprintf(stderr, "%s: Invalid encoding parameters\n",
3332 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3333 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3334 oc->loop_output = loop_output;
3336 for(i=0; i<opt_name_count; i++){
3338 const AVOption *opt;
3339 const char *str= av_get_string(avformat_opts, opt_names[i], &opt, buf, sizeof(buf));
3340 if(str && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3341 av_set_string(oc, opt_names[i], str);
3344 /* reset some options */
3345 file_oformat = NULL;
3346 file_iformat = NULL;
3349 /* same option as mencoder */
3350 static void opt_pass(const char *pass_str)
3353 pass = atoi(pass_str);
3354 if (pass != 1 && pass != 2) {
3355 fprintf(stderr, "pass number can be only 1 or 2\n");
3361 static int64_t getutime(void)
3363 #ifdef HAVE_GETRUSAGE
3364 struct rusage rusage;
3366 getrusage(RUSAGE_SELF, &rusage);
3367 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3368 #elif defined(HAVE_GETPROCESSTIMES)
3370 FILETIME c, e, k, u;
3371 proc = GetCurrentProcess();
3372 GetProcessTimes(proc, &c, &e, &k, &u);
3373 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3375 return av_gettime();
3379 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3382 const char *p = str;
3389 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3396 static void opt_inter_matrix(const char *arg)
3398 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3399 parse_matrix_coeffs(inter_matrix, arg);
3402 static void opt_intra_matrix(const char *arg)
3404 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3405 parse_matrix_coeffs(intra_matrix, arg);
3409 * Trivial log callback.
3410 * Only suitable for show_help and similar since it lacks prefix handling.
3412 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3414 vfprintf(stdout, fmt, vl);
3417 static void show_help(void)
3419 av_log_set_callback(log_callback_help);
3420 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3421 "Hyper fast Audio and Video encoder\n");
3423 show_help_options(options, "Main options:\n",
3424 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3425 show_help_options(options, "\nVideo options:\n",
3426 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3428 show_help_options(options, "\nAdvanced Video options:\n",
3429 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3430 OPT_VIDEO | OPT_EXPERT);
3431 show_help_options(options, "\nAudio options:\n",
3432 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3434 show_help_options(options, "\nAdvanced Audio options:\n",
3435 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3436 OPT_AUDIO | OPT_EXPERT);
3437 show_help_options(options, "\nSubtitle options:\n",
3438 OPT_SUBTITLE | OPT_GRAB,
3440 show_help_options(options, "\nAudio/Video grab options:\n",
3443 show_help_options(options, "\nAdvanced options:\n",
3444 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3447 av_opt_show(avctx_opts[0], NULL);
3449 av_opt_show(avformat_opts, NULL);
3451 av_opt_show(sws_opts, NULL);
3454 static void opt_target(const char *arg)
3457 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3459 if(!strncmp(arg, "pal-", 4)) {
3462 } else if(!strncmp(arg, "ntsc-", 5)) {
3465 } else if(!strncmp(arg, "film-", 5)) {
3470 /* Calculate FR via float to avoid int overflow */
3471 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3474 } else if((fr == 29970) || (fr == 23976)) {
3477 /* Try to determine PAL/NTSC by peeking in the input files */
3478 if(nb_input_files) {
3480 for(j = 0; j < nb_input_files; j++) {
3481 for(i = 0; i < input_files[j]->nb_streams; i++) {
3482 AVCodecContext *c = input_files[j]->streams[i]->codec;
3483 if(c->codec_type != CODEC_TYPE_VIDEO)
3485 fr = c->time_base.den * 1000 / c->time_base.num;
3489 } else if((fr == 29970) || (fr == 23976)) {
3499 if(verbose && norm >= 0)
3500 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3504 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3505 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3506 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3510 if(!strcmp(arg, "vcd")) {
3512 opt_video_codec("mpeg1video");
3513 opt_audio_codec("mp2");
3516 opt_frame_size(norm ? "352x240" : "352x288");
3517 opt_frame_rate(frame_rates[norm]);
3518 opt_default("gop", norm ? "18" : "15");
3520 opt_default("b", "1150000");
3521 opt_default("maxrate", "1150000");
3522 opt_default("minrate", "1150000");
3523 opt_default("bufsize", "327680"); // 40*1024*8;
3525 opt_default("ab", "224000");
3526 audio_sample_rate = 44100;
3529 opt_default("packetsize", "2324");
3530 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3532 /* We have to offset the PTS, so that it is consistent with the SCR.
3533 SCR starts at 36000, but the first two packs contain only padding
3534 and the first pack from the other stream, respectively, may also have
3535 been written before.
3536 So the real data starts at SCR 36000+3*1200. */
3537 mux_preload= (36000+3*1200) / 90000.0; //0.44
3538 } else if(!strcmp(arg, "svcd")) {
3540 opt_video_codec("mpeg2video");
3541 opt_audio_codec("mp2");
3544 opt_frame_size(norm ? "480x480" : "480x576");
3545 opt_frame_rate(frame_rates[norm]);
3546 opt_default("gop", norm ? "18" : "15");
3548 opt_default("b", "2040000");
3549 opt_default("maxrate", "2516000");
3550 opt_default("minrate", "0"); //1145000;
3551 opt_default("bufsize", "1835008"); //224*1024*8;
3552 opt_default("flags", "+SCAN_OFFSET");
3555 opt_default("ab", "224000");
3556 audio_sample_rate = 44100;
3558 opt_default("packetsize", "2324");
3560 } else if(!strcmp(arg, "dvd")) {
3562 opt_video_codec("mpeg2video");
3563 opt_audio_codec("ac3");
3566 opt_frame_size(norm ? "720x480" : "720x576");
3567 opt_frame_rate(frame_rates[norm]);
3568 opt_default("gop", norm ? "18" : "15");
3570 opt_default("b", "6000000");
3571 opt_default("maxrate", "9000000");
3572 opt_default("minrate", "0"); //1500000;
3573 opt_default("bufsize", "1835008"); //224*1024*8;
3575 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3576 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3578 opt_default("ab", "448000");
3579 audio_sample_rate = 48000;
3581 } else if(!strncmp(arg, "dv", 2)) {
3585 opt_frame_size(norm ? "720x480" : "720x576");
3586 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3587 (norm ? "yuv411p" : "yuv420p"));
3588 opt_frame_rate(frame_rates[norm]);
3590 audio_sample_rate = 48000;
3594 fprintf(stderr, "Unknown target: %s\n", arg);
3599 static void opt_vstats_file (const char *arg)
3601 av_free (vstats_filename);
3602 vstats_filename=av_strdup (arg);
3605 static void opt_vstats (void)
3608 time_t today2 = time(NULL);
3609 struct tm *today = localtime(&today2);
3611 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3613 opt_vstats_file(filename);
3616 static int opt_bsf(const char *opt, const char *arg)
3618 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3619 AVBitStreamFilterContext **bsfp;
3622 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3626 bsfp= *opt == 'v' ? &video_bitstream_filters :
3627 *opt == 'a' ? &audio_bitstream_filters :
3628 &subtitle_bitstream_filters;
3630 bsfp= &(*bsfp)->next;
3637 static int opt_preset(const char *opt, const char *arg)
3640 char tmp[1000], tmp2[1000];
3642 const char *base[3]= { getenv("HOME"),
3647 for(i=!base[0]; i<3 && !f; i++){
3648 snprintf(tmp, sizeof(tmp), "%s/%sffmpeg/%s.ffpreset", base[i], i ? "" : ".", arg);
3651 char *codec_name= *opt == 'v' ? video_codec_name :
3652 *opt == 'a' ? audio_codec_name :
3653 subtitle_codec_name;
3654 snprintf(tmp, sizeof(tmp), "%s/%sffmpeg/%s-%s.ffpreset", base[i], i ? "" : ".", codec_name, arg);
3660 fprintf(stderr, "Preset file not found\n");
3665 int e= fscanf(f, "%999[^=]=%999[^\n]\n", tmp, tmp2);
3667 fprintf(stderr, "Preset file invalid\n");
3670 opt_default(tmp, tmp2);
3678 static const OptionDef options[] = {
3680 { "L", OPT_EXIT, {(void*)show_license}, "show license" },
3681 { "h", OPT_EXIT, {(void*)show_help}, "show help" },
3682 { "version", OPT_EXIT, {(void*)show_version}, "show version" },
3683 { "formats", OPT_EXIT, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3684 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3685 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3686 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3687 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3688 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3689 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3690 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3691 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3692 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3693 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3694 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3695 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3696 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3697 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3698 { "genre", HAS_ARG | OPT_STRING, {(void*)&str_genre}, "set the genre", "string" },
3699 { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3700 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3701 "add timings for benchmarking" },
3702 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3703 "dump each input packet" },
3704 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3705 "when dumping packets, also dump the payload" },
3706 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3707 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3708 { "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)", "" },
3709 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set the logging verbosity level", "number" },
3710 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3711 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3712 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3713 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3714 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3715 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3716 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3717 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3718 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3719 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3722 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3723 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3724 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3725 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3726 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3727 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3728 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3729 { "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" },
3730 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3731 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3732 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3733 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3734 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3735 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3736 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3737 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3738 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3739 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3740 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3741 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3742 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3743 { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantizer scale (VBR)", "q" },
3744 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3745 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3746 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
3747 { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3748 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3749 "use same video quality as source (implies VBR)" },
3750 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3751 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3752 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3753 "deinterlace pictures" },
3754 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3755 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3756 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3758 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3760 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3761 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3762 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3763 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3764 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3765 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3766 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3769 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3770 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3771 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3772 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3773 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3774 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3775 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3776 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3777 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3778 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3779 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3781 /* subtitle options */
3782 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3783 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3784 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3785 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3788 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3789 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3790 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3793 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3794 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3796 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3797 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3798 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3800 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3801 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3802 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3804 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3808 int main(int argc, char **argv)
3813 avcodec_register_all();
3814 avdevice_register_all();
3817 for(i=0; i<CODEC_TYPE_NB; i++){
3818 avctx_opts[i]= avcodec_alloc_context2(i);
3820 avformat_opts = av_alloc_format_context();
3821 sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3830 parse_options(argc, argv, options, opt_output_file);
3832 /* file converter / grab */
3833 if (nb_output_files <= 0) {
3834 fprintf(stderr, "Must supply at least one output file\n");
3838 if (nb_input_files == 0) {
3839 fprintf(stderr, "Must supply at least one input file\n");
3844 av_encode(output_files, nb_output_files, input_files, nb_input_files,
3845 stream_maps, nb_stream_maps);
3846 ti = getutime() - ti;
3848 printf("bench: utime=%0.3fs\n", ti / 1000000.0);