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 "libavcodec/audioconvert.h"
36 #include "libavutil/fifo.h"
37 #include "libavutil/avstring.h"
38 #include "libavformat/os_support.h"
40 #ifdef HAVE_SYS_RESOURCE_H
41 #include <sys/types.h>
42 #include <sys/resource.h>
43 #elif defined(HAVE_GETPROCESSTIMES)
47 #if defined(HAVE_TERMIOS_H)
50 #include <sys/ioctl.h>
53 #elif defined(HAVE_CONIO_H)
56 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
66 const char program_name[] = "FFmpeg";
67 const int program_birth_year = 2000;
69 /* select an input stream for an output stream */
70 typedef struct AVStreamMap {
74 int sync_stream_index;
77 /** select an input file for an output file */
78 typedef struct AVMetaDataMap {
83 static const OptionDef options[];
87 static AVFormatContext *input_files[MAX_FILES];
88 static int64_t input_files_ts_offset[MAX_FILES];
89 static double input_files_ts_scale[MAX_FILES][MAX_STREAMS];
90 static int nb_input_files = 0;
92 static AVFormatContext *output_files[MAX_FILES];
93 static int nb_output_files = 0;
95 static AVStreamMap stream_maps[MAX_FILES];
96 static int nb_stream_maps;
98 static AVMetaDataMap meta_data_maps[MAX_FILES];
99 static int nb_meta_data_maps;
101 static AVInputFormat *file_iformat;
102 static AVOutputFormat *file_oformat;
103 static int frame_width = 0;
104 static int frame_height = 0;
105 static float frame_aspect_ratio = 0;
106 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
107 static enum SampleFormat audio_sample_fmt = SAMPLE_FMT_NONE;
108 static int frame_padtop = 0;
109 static int frame_padbottom = 0;
110 static int frame_padleft = 0;
111 static int frame_padright = 0;
112 static int padcolor[3] = {16,128,128}; /* default to black */
113 static int frame_topBand = 0;
114 static int frame_bottomBand = 0;
115 static int frame_leftBand = 0;
116 static int frame_rightBand = 0;
117 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
118 static AVRational frame_rate;
119 static float video_qscale = 0;
120 static uint16_t *intra_matrix = NULL;
121 static uint16_t *inter_matrix = NULL;
122 #if 0 //experimental, (can be removed)
123 static float video_rc_qsquish=1.0;
124 static float video_rc_qmod_amp=0;
125 static int video_rc_qmod_freq=0;
127 static const char *video_rc_override_string=NULL;
128 static int video_disable = 0;
129 static int video_discard = 0;
130 static char *video_codec_name = NULL;
131 static int video_codec_tag = 0;
132 static int same_quality = 0;
133 static int do_deinterlace = 0;
134 static int top_field_first = -1;
135 static int me_threshold = 0;
136 static int intra_dc_precision = 8;
137 static int loop_input = 0;
138 static int loop_output = AVFMT_NOOUTPUTLOOP;
139 static int qp_hist = 0;
141 static int intra_only = 0;
142 static int audio_sample_rate = 44100;
143 #define QSCALE_NONE -99999
144 static float audio_qscale = QSCALE_NONE;
145 static int audio_disable = 0;
146 static int audio_channels = 1;
147 static char *audio_codec_name = NULL;
148 static int audio_codec_tag = 0;
149 static char *audio_language = NULL;
151 static int subtitle_disable = 0;
152 static char *subtitle_codec_name = NULL;
153 static char *subtitle_language = NULL;
155 static float mux_preload= 0.5;
156 static float mux_max_delay= 0.7;
158 static int64_t recording_time = INT64_MAX;
159 static int64_t start_time = 0;
160 static int64_t rec_timestamp = 0;
161 static int64_t input_ts_offset = 0;
162 static int file_overwrite = 0;
163 static char *str_title = NULL;
164 static char *str_author = NULL;
165 static char *str_copyright = NULL;
166 static char *str_comment = NULL;
167 static char *str_genre = NULL;
168 static char *str_album = NULL;
169 static int do_benchmark = 0;
170 static int do_hex_dump = 0;
171 static int do_pkt_dump = 0;
172 static int do_psnr = 0;
173 static int do_pass = 0;
174 static char *pass_logfilename = NULL;
175 static int audio_stream_copy = 0;
176 static int video_stream_copy = 0;
177 static int subtitle_stream_copy = 0;
178 static int video_sync_method= -1;
179 static int audio_sync_method= 0;
180 static float audio_drift_threshold= 0.1;
181 static int copy_ts= 0;
182 static int opt_shortest = 0; //
183 static int video_global_header = 0;
184 static char *vstats_filename;
185 static FILE *vstats_file;
186 static int opt_programid = 0;
188 static int rate_emu = 0;
190 static int video_channel = 0;
191 static char *video_standard;
193 static int audio_volume = 256;
195 static int using_stdin = 0;
196 static int using_vhook = 0;
197 static int verbose = 1;
198 static int thread_count= 1;
199 static int q_pressed = 0;
200 static int64_t video_size = 0;
201 static int64_t audio_size = 0;
202 static int64_t extra_size = 0;
203 static int nb_frames_dup = 0;
204 static int nb_frames_drop = 0;
205 static int input_sync;
206 static uint64_t limit_filesize = 0; //
208 static int pgmyuv_compatibility_hack=0;
209 static float dts_delta_threshold = 10;
211 static unsigned int sws_flags = SWS_BICUBIC;
213 static const char **opt_names;
214 static int opt_name_count;
215 static AVCodecContext *avctx_opts[CODEC_TYPE_NB];
216 static AVFormatContext *avformat_opts;
217 static struct SwsContext *sws_opts;
218 static int64_t timer_start;
220 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
221 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
222 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
223 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
225 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
227 struct AVInputStream;
229 typedef struct AVOutputStream {
230 int file_index; /* file index */
231 int index; /* stream index in the output file */
232 int source_index; /* AVInputStream index */
233 AVStream *st; /* stream in the output file */
234 int encoding_needed; /* true if encoding needed for this stream */
236 /* input pts and corresponding output pts
238 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
239 struct AVInputStream *sync_ist; /* input stream to sync against */
240 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
243 AVFrame pict_tmp; /* temporary image for resampling */
244 struct SwsContext *img_resample_ctx; /* for image resampling */
248 int topBand; /* cropping area sizes */
252 int padtop; /* padding area sizes */
259 ReSampleContext *resample; /* for audio resampling */
260 AVFifoBuffer fifo; /* for compression: one audio fifo per codec */
264 typedef struct AVInputStream {
268 int discard; /* true if stream data should be discarded */
269 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
270 int64_t sample_index; /* current sample */
272 int64_t start; /* time when read started */
273 unsigned long frame; /* current frame */
274 int64_t next_pts; /* synthetic pts for cases where pkt.pts
276 int64_t pts; /* current pts */
277 int is_start; /* is 1 at the start and after a discontinuity */
280 typedef struct AVInputFile {
281 int eof_reached; /* true if eof reached */
282 int ist_index; /* index of first stream in ist_table */
283 int buffer_size; /* current total buffer size */
284 int nb_streams; /* nb streams we are aware of */
287 #ifdef HAVE_TERMIOS_H
289 /* init terminal so that we can grab keys */
290 static struct termios oldtty;
293 static void term_exit(void)
295 #ifdef HAVE_TERMIOS_H
296 tcsetattr (0, TCSANOW, &oldtty);
300 static volatile sig_atomic_t received_sigterm = 0;
303 sigterm_handler(int sig)
305 received_sigterm = sig;
309 static void term_init(void)
311 #ifdef HAVE_TERMIOS_H
317 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
318 |INLCR|IGNCR|ICRNL|IXON);
319 tty.c_oflag |= OPOST;
320 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
321 tty.c_cflag &= ~(CSIZE|PARENB);
326 tcsetattr (0, TCSANOW, &tty);
327 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
330 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
331 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
333 register a function to be called at normal program termination
336 #ifdef CONFIG_BEOS_NETSERVER
337 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
341 /* read a key without blocking */
342 static int read_key(void)
344 #if defined(HAVE_TERMIOS_H)
347 #ifndef CONFIG_BEOS_NETSERVER
355 n = select(1, &rfds, NULL, NULL, &tv);
364 #elif defined(HAVE_CONIO_H)
371 static int decode_interrupt_cb(void)
373 return q_pressed || (q_pressed = read_key() == 'q');
376 static int av_exit(int ret)
381 for(i=0;i<nb_output_files;i++) {
382 /* maybe av_close_output_file ??? */
383 AVFormatContext *s = output_files[i];
385 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
387 for(j=0;j<s->nb_streams;j++) {
388 av_free(s->streams[j]->codec);
389 av_free(s->streams[j]);
393 for(i=0;i<nb_input_files;i++)
394 av_close_input_file(input_files[i]);
396 av_free(intra_matrix);
397 av_free(inter_matrix);
401 av_free(vstats_filename);
405 av_free(video_codec_name);
406 av_free(audio_codec_name);
407 av_free(subtitle_codec_name);
409 av_free(video_standard);
411 #ifdef CONFIG_POWERPC_PERF
412 extern void powerpc_display_perf_report(void);
413 powerpc_display_perf_report();
414 #endif /* CONFIG_POWERPC_PERF */
416 if (received_sigterm) {
418 "Received signal %d: terminating.\n",
419 (int) received_sigterm);
423 exit(ret); /* not all OS-es handle main() return value */
427 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
433 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
436 /* copy stream format */
437 s->nb_streams = ic->nb_streams;
438 for(i=0;i<ic->nb_streams;i++) {
441 // FIXME: a more elegant solution is needed
442 st = av_mallocz(sizeof(AVStream));
443 memcpy(st, ic->streams[i], sizeof(AVStream));
444 st->codec = avcodec_alloc_context();
445 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
448 if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
450 else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
453 if(!st->codec->thread_count)
454 st->codec->thread_count = 1;
455 if(st->codec->thread_count>1)
456 avcodec_thread_init(st->codec, st->codec->thread_count);
458 if(st->codec->flags & CODEC_FLAG_BITEXACT)
463 s->timestamp = av_gettime();
465 av_close_input_file(ic);
470 get_sync_ipts(const AVOutputStream *ost)
472 const AVInputStream *ist = ost->sync_ist;
473 return (double)(ist->pts - start_time)/AV_TIME_BASE;
476 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
480 AVPacket new_pkt= *pkt;
481 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
482 &new_pkt.data, &new_pkt.size,
483 pkt->data, pkt->size,
484 pkt->flags & PKT_FLAG_KEY);
487 new_pkt.destruct= av_destruct_packet;
489 fprintf(stderr, "%s failed for stream %d, codec %s",
490 bsfc->filter->name, pkt->stream_index,
491 avctx->codec ? avctx->codec->name : "copy");
499 ret= av_interleaved_write_frame(s, pkt);
501 print_error("av_interleaved_write_frame()", ret);
506 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
508 static void do_audio_out(AVFormatContext *s,
511 unsigned char *buf, int size)
514 static uint8_t *audio_buf = NULL;
515 static uint8_t *audio_out = NULL;
516 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
518 int size_out, frame_bytes, ret;
519 AVCodecContext *enc= ost->st->codec;
520 AVCodecContext *dec= ist->st->codec;
522 /* SC: dynamic allocation of buffers */
524 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
526 audio_out = av_malloc(audio_out_size);
527 if (!audio_buf || !audio_out)
528 return; /* Should signal an error ! */
530 if (enc->channels != dec->channels)
531 ost->audio_resample = 1;
533 if (ost->audio_resample && !ost->resample) {
534 ost->resample = audio_resample_init(enc->channels, dec->channels,
535 enc->sample_rate, dec->sample_rate);
536 if (!ost->resample) {
537 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
538 dec->channels, dec->sample_rate,
539 enc->channels, enc->sample_rate);
544 if(audio_sync_method){
545 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
546 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
547 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
548 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
550 //FIXME resample delay
551 if(fabs(delta) > 50){
552 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
554 byte_delta= FFMAX(byte_delta, -size);
558 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
563 static uint8_t *input_tmp= NULL;
564 input_tmp= av_realloc(input_tmp, byte_delta + size);
566 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
569 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
571 memset(input_tmp, 0, byte_delta);
572 memcpy(input_tmp + byte_delta, buf, size);
576 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
578 }else if(audio_sync_method>1){
579 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
580 assert(ost->audio_resample);
582 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
583 // 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));
584 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
588 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
589 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
591 if (ost->audio_resample) {
593 size_out = audio_resample(ost->resample,
594 (short *)buftmp, (short *)buf,
595 size / (ist->st->codec->channels * 2));
596 size_out = size_out * enc->channels * 2;
602 /* now encode as many frames as possible */
603 if (enc->frame_size > 1) {
604 /* output resampled raw samples */
605 av_fifo_realloc(&ost->fifo, av_fifo_size(&ost->fifo) + size_out);
606 av_fifo_generic_write(&ost->fifo, buftmp, size_out, NULL);
608 frame_bytes = enc->frame_size * 2 * enc->channels;
610 while (av_fifo_size(&ost->fifo) >= frame_bytes) {
612 av_init_packet(&pkt);
614 av_fifo_read(&ost->fifo, audio_buf, frame_bytes);
616 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
618 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
621 pkt.stream_index= ost->index;
624 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
625 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
626 pkt.flags |= PKT_FLAG_KEY;
627 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
629 ost->sync_opts += enc->frame_size;
633 av_init_packet(&pkt);
635 ost->sync_opts += size_out / (2 * enc->channels);
637 /* output a pcm frame */
638 /* XXX: change encoding codec API to avoid this ? */
639 switch(enc->codec->id) {
640 case CODEC_ID_PCM_S32LE:
641 case CODEC_ID_PCM_S32BE:
642 case CODEC_ID_PCM_U32LE:
643 case CODEC_ID_PCM_U32BE:
644 case CODEC_ID_PCM_F32BE:
645 size_out = size_out << 1;
647 case CODEC_ID_PCM_S24LE:
648 case CODEC_ID_PCM_S24BE:
649 case CODEC_ID_PCM_U24LE:
650 case CODEC_ID_PCM_U24BE:
651 case CODEC_ID_PCM_S24DAUD:
652 size_out = size_out / 2 * 3;
654 case CODEC_ID_PCM_S16LE:
655 case CODEC_ID_PCM_S16BE:
656 case CODEC_ID_PCM_U16LE:
657 case CODEC_ID_PCM_U16BE:
660 size_out = size_out >> 1;
663 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
664 ret = avcodec_encode_audio(enc, audio_out, size_out,
667 pkt.stream_index= ost->index;
670 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
671 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
672 pkt.flags |= PKT_FLAG_KEY;
673 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
677 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
681 AVPicture picture_tmp;
684 dec = ist->st->codec;
686 /* deinterlace : must be done before any resize */
687 if (do_deinterlace || using_vhook) {
690 /* create temporary picture */
691 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
692 buf = av_malloc(size);
696 picture2 = &picture_tmp;
697 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
700 if(avpicture_deinterlace(picture2, picture,
701 dec->pix_fmt, dec->width, dec->height) < 0) {
702 /* if error, do not deinterlace */
708 av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
715 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,
716 1000000 * ist->pts / AV_TIME_BASE);
718 if (picture != picture2)
719 *picture = *picture2;
723 /* we begin to correct av delay at this threshold */
724 #define AV_DELAY_MAX 0.100
726 static void do_subtitle_out(AVFormatContext *s,
732 static uint8_t *subtitle_out = NULL;
733 int subtitle_out_max_size = 65536;
734 int subtitle_out_size, nb, i;
738 if (pts == AV_NOPTS_VALUE) {
739 fprintf(stderr, "Subtitle packets must have a pts\n");
743 enc = ost->st->codec;
746 subtitle_out = av_malloc(subtitle_out_max_size);
749 /* Note: DVB subtitle need one packet to draw them and one other
750 packet to clear them */
751 /* XXX: signal it in the codec context ? */
752 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
757 for(i = 0; i < nb; i++) {
758 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
759 subtitle_out_max_size, sub);
761 av_init_packet(&pkt);
762 pkt.stream_index = ost->index;
763 pkt.data = subtitle_out;
764 pkt.size = subtitle_out_size;
765 pkt.pts = av_rescale_q(pts, ist->st->time_base, ost->st->time_base);
766 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
767 /* XXX: the pts correction is handled here. Maybe handling
768 it in the codec would be better */
770 pkt.pts += 90 * sub->start_display_time;
772 pkt.pts += 90 * sub->end_display_time;
774 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
778 static int bit_buffer_size= 1024*256;
779 static uint8_t *bit_buffer= NULL;
781 static void do_video_out(AVFormatContext *s,
787 int nb_frames, i, ret;
788 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
789 AVFrame picture_crop_temp, picture_pad_temp;
790 AVCodecContext *enc, *dec;
792 avcodec_get_frame_defaults(&picture_crop_temp);
793 avcodec_get_frame_defaults(&picture_pad_temp);
795 enc = ost->st->codec;
796 dec = ist->st->codec;
798 /* by default, we output a single frame */
803 if(video_sync_method>0 || (video_sync_method && av_q2d(enc->time_base) > 0.001)){
805 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
806 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
809 else if (video_sync_method == 2)
810 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
811 else if (vdelta > 1.1)
812 nb_frames = lrintf(vdelta);
813 //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);
817 fprintf(stderr, "*** drop!\n");
818 }else if (nb_frames > 1) {
819 nb_frames_dup += nb_frames;
821 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
824 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
826 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
830 if (ost->video_crop) {
831 if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
832 av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
835 formatted_picture = &picture_crop_temp;
837 formatted_picture = in_picture;
840 final_picture = formatted_picture;
841 padding_src = formatted_picture;
842 resampling_dst = &ost->pict_tmp;
843 if (ost->video_pad) {
844 final_picture = &ost->pict_tmp;
845 if (ost->video_resample) {
846 if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
847 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
850 resampling_dst = &picture_pad_temp;
854 if (ost->video_resample) {
856 final_picture = &ost->pict_tmp;
857 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
858 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
861 if (ost->video_pad) {
862 av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
863 enc->height, enc->width, enc->pix_fmt,
864 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
867 /* duplicates frame if needed */
868 for(i=0;i<nb_frames;i++) {
870 av_init_packet(&pkt);
871 pkt.stream_index= ost->index;
873 if (s->oformat->flags & AVFMT_RAWPICTURE) {
874 /* raw pictures are written as AVPicture structure to
875 avoid any copies. We support temorarily the older
877 AVFrame* old_frame = enc->coded_frame;
878 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
879 pkt.data= (uint8_t *)final_picture;
880 pkt.size= sizeof(AVPicture);
881 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
882 pkt.flags |= PKT_FLAG_KEY;
884 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
885 enc->coded_frame = old_frame;
889 big_picture= *final_picture;
890 /* better than nothing: use input picture interlaced
892 big_picture.interlaced_frame = in_picture->interlaced_frame;
893 if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
894 if(top_field_first == -1)
895 big_picture.top_field_first = in_picture->top_field_first;
897 big_picture.top_field_first = top_field_first;
900 /* handles sameq here. This is not correct because it may
901 not be a global option */
903 big_picture.quality = ist->st->quality;
905 big_picture.quality = ost->st->quality;
907 big_picture.pict_type = 0;
908 // big_picture.pts = AV_NOPTS_VALUE;
909 big_picture.pts= ost->sync_opts;
910 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
911 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
912 ret = avcodec_encode_video(enc,
913 bit_buffer, bit_buffer_size,
916 fprintf(stderr, "Video encoding failed\n");
919 //enc->frame_number = enc->real_pict_num;
921 pkt.data= bit_buffer;
923 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
924 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
925 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
926 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
927 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
929 if(enc->coded_frame->key_frame)
930 pkt.flags |= PKT_FLAG_KEY;
931 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
934 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
935 // enc->frame_number-1, enc->real_pict_num, ret,
937 /* if two pass, output log */
938 if (ost->logfile && enc->stats_out) {
939 fprintf(ost->logfile, "%s", enc->stats_out);
948 static double psnr(double d){
949 return -10.0*log(d)/log(10.0);
952 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
957 double ti1, bitrate, avg_bitrate;
959 /* this is executed just the first time do_video_stats is called */
961 vstats_file = fopen(vstats_filename, "w");
968 enc = ost->st->codec;
969 if (enc->codec_type == CODEC_TYPE_VIDEO) {
970 frame_number = ost->frame_number;
971 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
972 if (enc->flags&CODEC_FLAG_PSNR)
973 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
975 fprintf(vstats_file,"f_size= %6d ", frame_size);
976 /* compute pts value */
977 ti1 = ost->sync_opts * av_q2d(enc->time_base);
981 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
982 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
983 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
984 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
985 fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
989 static void print_report(AVFormatContext **output_files,
990 AVOutputStream **ost_table, int nb_ostreams,
995 AVFormatContext *oc, *os;
998 int frame_number, vid, i;
999 double bitrate, ti1, pts;
1000 static int64_t last_time = -1;
1001 static int qp_histogram[52];
1003 if (!is_last_report) {
1005 /* display the report every 0.5 seconds */
1006 cur_time = av_gettime();
1007 if (last_time == -1) {
1008 last_time = cur_time;
1011 if ((cur_time - last_time) < 500000)
1013 last_time = cur_time;
1017 oc = output_files[0];
1019 total_size = url_fsize(oc->pb);
1020 if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1021 total_size= url_ftell(oc->pb);
1026 for(i=0;i<nb_ostreams;i++) {
1028 os = output_files[ost->file_index];
1029 enc = ost->st->codec;
1030 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1031 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1032 !ost->st->stream_copy ?
1033 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1035 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1036 float t = (av_gettime()-timer_start) / 1000000.0;
1038 frame_number = ost->frame_number;
1039 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1040 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1041 !ost->st->stream_copy ?
1042 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1044 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1047 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1048 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
1051 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1053 if (enc->flags&CODEC_FLAG_PSNR){
1055 double error, error_sum=0;
1056 double scale, scale_sum=0;
1057 char type[3]= {'Y','U','V'};
1058 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1061 error= enc->error[j];
1062 scale= enc->width*enc->height*255.0*255.0*frame_number;
1064 error= enc->coded_frame->error[j];
1065 scale= enc->width*enc->height*255.0*255.0;
1070 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1072 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1076 /* compute min output value */
1077 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1078 if ((pts < ti1) && (pts > 0))
1084 if (verbose || is_last_report) {
1085 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1087 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1088 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1089 (double)total_size / 1024, ti1, bitrate);
1092 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1093 nb_frames_dup, nb_frames_drop);
1096 fprintf(stderr, "%s \r", buf);
1101 if (is_last_report && verbose >= 0){
1102 int64_t raw= audio_size + video_size + extra_size;
1103 fprintf(stderr, "\n");
1104 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1108 100.0*(total_size - raw)/raw
1113 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1114 static int output_packet(AVInputStream *ist, int ist_index,
1115 AVOutputStream **ost_table, int nb_ostreams,
1116 const AVPacket *pkt)
1118 AVFormatContext *os;
1119 AVOutputStream *ost;
1123 int data_size, got_picture;
1125 void *buffer_to_free;
1126 static unsigned int samples_size= 0;
1127 static short *samples= NULL;
1128 AVSubtitle subtitle, *subtitle_to_free;
1131 if(ist->next_pts == AV_NOPTS_VALUE)
1132 ist->next_pts= ist->pts;
1141 if(pkt->dts != AV_NOPTS_VALUE)
1142 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1147 //while we have more to decode or while the decoder did output something on EOF
1148 while (len > 0 || (!pkt && ist->next_pts != ist->pts)) {
1150 ist->pts= ist->next_pts;
1152 if(len && len != pkt->size && verbose>0)
1153 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1155 /* decode the packet if needed */
1156 data_buf = NULL; /* fail safe */
1158 subtitle_to_free = NULL;
1159 if (ist->decoding_needed) {
1160 switch(ist->st->codec->codec_type) {
1161 case CODEC_TYPE_AUDIO:{
1163 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE));
1164 data_size= samples_size;
1165 /* XXX: could avoid copy if PCM 16 bits with same
1166 endianness as CPU */
1167 ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1173 /* Some bug in mpeg audio decoder gives */
1174 /* data_size < 0, it seems they are overflows */
1175 if (data_size <= 0) {
1176 /* no audio frame */
1179 data_buf = (uint8_t *)samples;
1180 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1181 (ist->st->codec->sample_rate * ist->st->codec->channels);
1183 case CODEC_TYPE_VIDEO:
1184 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1185 /* XXX: allocate picture correctly */
1186 avcodec_get_frame_defaults(&picture);
1188 ret = avcodec_decode_video(ist->st->codec,
1189 &picture, &got_picture, ptr, len);
1190 ist->st->quality= picture.quality;
1194 /* no picture yet */
1195 goto discard_packet;
1197 if (ist->st->codec->time_base.num != 0) {
1198 ist->next_pts += ((int64_t)AV_TIME_BASE *
1199 ist->st->codec->time_base.num) /
1200 ist->st->codec->time_base.den;
1204 case CODEC_TYPE_SUBTITLE:
1205 ret = avcodec_decode_subtitle(ist->st->codec,
1206 &subtitle, &got_subtitle, ptr, len);
1209 if (!got_subtitle) {
1210 goto discard_packet;
1212 subtitle_to_free = &subtitle;
1219 switch(ist->st->codec->codec_type) {
1220 case CODEC_TYPE_AUDIO:
1221 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1222 ist->st->codec->sample_rate;
1224 case CODEC_TYPE_VIDEO:
1225 if (ist->st->codec->time_base.num != 0) {
1226 ist->next_pts += ((int64_t)AV_TIME_BASE *
1227 ist->st->codec->time_base.num) /
1228 ist->st->codec->time_base.den;
1238 buffer_to_free = NULL;
1239 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1240 pre_process_video_frame(ist, (AVPicture *)&picture,
1244 // preprocess audio (volume)
1245 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1246 if (audio_volume != 256) {
1249 for(i=0;i<(data_size / sizeof(short));i++) {
1250 int v = ((*volp) * audio_volume + 128) >> 8;
1251 if (v < -32768) v = -32768;
1252 if (v > 32767) v = 32767;
1258 /* frame rate emulation */
1259 if (ist->st->codec->rate_emu) {
1260 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1261 int64_t now = av_gettime() - ist->start;
1269 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1270 is the one of the next displayed one */
1271 /* XXX: add mpeg4 too ? */
1272 if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1273 if (ist->st->codec->pict_type != B_TYPE) {
1275 tmp = ist->last_ip_pts;
1276 ist->last_ip_pts = ist->frac_pts.val;
1277 ist->frac_pts.val = tmp;
1281 /* if output time reached then transcode raw format,
1282 encode packets and output them */
1283 if (start_time == 0 || ist->pts >= start_time)
1284 for(i=0;i<nb_ostreams;i++) {
1288 if (ost->source_index == ist_index) {
1289 os = output_files[ost->file_index];
1292 printf("%d: got pts=%0.3f %0.3f\n", i,
1293 (double)pkt->pts / AV_TIME_BASE,
1294 ((double)ist->pts / AV_TIME_BASE) -
1295 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1297 /* set the input output pts pairs */
1298 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1300 if (ost->encoding_needed) {
1301 switch(ost->st->codec->codec_type) {
1302 case CODEC_TYPE_AUDIO:
1303 do_audio_out(os, ost, ist, data_buf, data_size);
1305 case CODEC_TYPE_VIDEO:
1306 do_video_out(os, ost, ist, &picture, &frame_size);
1307 if (vstats_filename && frame_size)
1308 do_video_stats(os, ost, frame_size);
1310 case CODEC_TYPE_SUBTITLE:
1311 do_subtitle_out(os, ost, ist, &subtitle,
1318 AVFrame avframe; //FIXME/XXX remove this
1320 av_init_packet(&opkt);
1322 if (!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY))
1325 /* no reencoding needed : output the packet directly */
1326 /* force the input stream PTS */
1328 avcodec_get_frame_defaults(&avframe);
1329 ost->st->codec->coded_frame= &avframe;
1330 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1332 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1333 audio_size += data_size;
1334 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1335 video_size += data_size;
1339 opkt.stream_index= ost->index;
1340 if(pkt->pts != AV_NOPTS_VALUE)
1341 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1343 opkt.pts= AV_NOPTS_VALUE;
1345 if (pkt->dts == AV_NOPTS_VALUE)
1346 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1348 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1350 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1351 opkt.flags= pkt->flags;
1353 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1354 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1355 opkt.destruct= av_destruct_packet;
1357 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1358 ost->st->codec->frame_number++;
1359 ost->frame_number++;
1360 av_free_packet(&opkt);
1364 av_free(buffer_to_free);
1365 /* XXX: allocate the subtitles in the codec ? */
1366 if (subtitle_to_free) {
1367 if (subtitle_to_free->rects != NULL) {
1368 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1369 av_free(subtitle_to_free->rects[i].bitmap);
1370 av_free(subtitle_to_free->rects[i].rgba_palette);
1372 av_freep(&subtitle_to_free->rects);
1374 subtitle_to_free->num_rects = 0;
1375 subtitle_to_free = NULL;
1382 for(i=0;i<nb_ostreams;i++) {
1384 if (ost->source_index == ist_index) {
1385 AVCodecContext *enc= ost->st->codec;
1386 os = output_files[ost->file_index];
1388 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1390 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1393 if (ost->encoding_needed) {
1397 av_init_packet(&pkt);
1398 pkt.stream_index= ost->index;
1400 switch(ost->st->codec->codec_type) {
1401 case CODEC_TYPE_AUDIO:
1402 fifo_bytes = av_fifo_size(&ost->fifo);
1404 /* encode any samples remaining in fifo */
1405 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1406 int fs_tmp = enc->frame_size;
1407 enc->frame_size = fifo_bytes / (2 * enc->channels);
1408 av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes);
1409 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1410 enc->frame_size = fs_tmp;
1413 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1416 pkt.flags |= PKT_FLAG_KEY;
1418 case CODEC_TYPE_VIDEO:
1419 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1421 if(enc->coded_frame && enc->coded_frame->key_frame)
1422 pkt.flags |= PKT_FLAG_KEY;
1423 if (ost->logfile && enc->stats_out) {
1424 fprintf(ost->logfile, "%s", enc->stats_out);
1433 pkt.data= bit_buffer;
1435 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1436 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1437 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1449 static void print_sdp(AVFormatContext **avc, int n)
1453 avf_sdp_create(avc, n, sdp, sizeof(sdp));
1454 printf("SDP:\n%s\n", sdp);
1457 static int stream_index_from_inputs(AVFormatContext **input_files,
1459 AVInputFile *file_table,
1460 AVInputStream **ist_table,
1461 enum CodecType type,
1465 for(z=0; z<nb_input_files; z++) {
1466 AVFormatContext *ic = input_files[z];
1467 for(p=0; p<ic->nb_programs; p++) {
1468 AVProgram *program = ic->programs[p];
1469 if(program->id != programid)
1471 for(q=0; q<program->nb_stream_indexes; q++) {
1472 int sidx = program->stream_index[q];
1473 int ris = file_table[z].ist_index + sidx;
1474 if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1484 * The following code is the main loop of the file converter
1486 static int av_encode(AVFormatContext **output_files,
1487 int nb_output_files,
1488 AVFormatContext **input_files,
1490 AVStreamMap *stream_maps, int nb_stream_maps)
1492 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1493 AVFormatContext *is, *os;
1494 AVCodecContext *codec, *icodec;
1495 AVOutputStream *ost, **ost_table = NULL;
1496 AVInputStream *ist, **ist_table = NULL;
1497 AVInputFile *file_table;
1501 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1505 /* input stream init */
1507 for(i=0;i<nb_input_files;i++) {
1508 is = input_files[i];
1509 file_table[i].ist_index = j;
1510 file_table[i].nb_streams = is->nb_streams;
1511 j += is->nb_streams;
1515 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1519 for(i=0;i<nb_istreams;i++) {
1520 ist = av_mallocz(sizeof(AVInputStream));
1526 for(i=0;i<nb_input_files;i++) {
1527 is = input_files[i];
1528 for(k=0;k<is->nb_streams;k++) {
1529 ist = ist_table[j++];
1530 ist->st = is->streams[k];
1531 ist->file_index = i;
1533 ist->discard = 1; /* the stream is discarded by default
1536 if (ist->st->codec->rate_emu) {
1537 ist->start = av_gettime();
1543 /* output stream init */
1545 for(i=0;i<nb_output_files;i++) {
1546 os = output_files[i];
1547 if (!os->nb_streams) {
1548 fprintf(stderr, "Output file does not contain any stream\n");
1551 nb_ostreams += os->nb_streams;
1553 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1554 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1558 /* Sanity check the mapping args -- do the input files & streams exist? */
1559 for(i=0;i<nb_stream_maps;i++) {
1560 int fi = stream_maps[i].file_index;
1561 int si = stream_maps[i].stream_index;
1563 if (fi < 0 || fi > nb_input_files - 1 ||
1564 si < 0 || si > file_table[fi].nb_streams - 1) {
1565 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1568 fi = stream_maps[i].sync_file_index;
1569 si = stream_maps[i].sync_stream_index;
1570 if (fi < 0 || fi > nb_input_files - 1 ||
1571 si < 0 || si > file_table[fi].nb_streams - 1) {
1572 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1577 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1580 for(i=0;i<nb_ostreams;i++) {
1581 ost = av_mallocz(sizeof(AVOutputStream));
1588 for(k=0;k<nb_output_files;k++) {
1589 os = output_files[k];
1590 for(i=0;i<os->nb_streams;i++) {
1592 ost = ost_table[n++];
1593 ost->file_index = k;
1595 ost->st = os->streams[i];
1596 if (nb_stream_maps > 0) {
1597 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1598 stream_maps[n-1].stream_index;
1600 /* Sanity check that the stream types match */
1601 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1602 int i= ost->file_index;
1603 dump_format(output_files[i], i, output_files[i]->filename, 1);
1604 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1605 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1606 ost->file_index, ost->index);
1613 j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1615 ost->source_index = j;
1619 /* get corresponding input stream index : we select the first one with the right type */
1621 for(j=0;j<nb_istreams;j++) {
1624 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1625 ost->source_index = j;
1633 if(! opt_programid) {
1634 /* try again and reuse existing stream */
1635 for(j=0;j<nb_istreams;j++) {
1637 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1638 ost->source_index = j;
1644 int i= ost->file_index;
1645 dump_format(output_files[i], i, output_files[i]->filename, 1);
1646 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1647 ost->file_index, ost->index);
1652 ist = ist_table[ost->source_index];
1654 ost->sync_ist = (nb_stream_maps > 0) ?
1655 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1656 stream_maps[n-1].sync_stream_index] : ist;
1660 /* for each output stream, we compute the right encoding parameters */
1661 for(i=0;i<nb_ostreams;i++) {
1663 os = output_files[ost->file_index];
1664 ist = ist_table[ost->source_index];
1666 codec = ost->st->codec;
1667 icodec = ist->st->codec;
1669 if (!ost->st->language[0])
1670 av_strlcpy(ost->st->language, ist->st->language,
1671 sizeof(ost->st->language));
1673 ost->st->disposition = ist->st->disposition;
1675 if (ost->st->stream_copy) {
1676 /* if stream_copy is selected, no need to decode or encode */
1677 codec->codec_id = icodec->codec_id;
1678 codec->codec_type = icodec->codec_type;
1680 if(!codec->codec_tag){
1681 if( !os->oformat->codec_tag
1682 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1683 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1684 codec->codec_tag = icodec->codec_tag;
1687 codec->bit_rate = icodec->bit_rate;
1688 codec->extradata= icodec->extradata;
1689 codec->extradata_size= icodec->extradata_size;
1690 if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1691 codec->time_base = icodec->time_base;
1693 codec->time_base = ist->st->time_base;
1694 switch(codec->codec_type) {
1695 case CODEC_TYPE_AUDIO:
1696 if(audio_volume != 256) {
1697 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1700 codec->sample_rate = icodec->sample_rate;
1701 codec->channels = icodec->channels;
1702 codec->frame_size = icodec->frame_size;
1703 codec->block_align= icodec->block_align;
1704 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1705 codec->block_align= 0;
1706 if(codec->codec_id == CODEC_ID_AC3)
1707 codec->block_align= 0;
1709 case CODEC_TYPE_VIDEO:
1711 fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1714 codec->pix_fmt = icodec->pix_fmt;
1715 codec->width = icodec->width;
1716 codec->height = icodec->height;
1717 codec->has_b_frames = icodec->has_b_frames;
1719 case CODEC_TYPE_SUBTITLE:
1725 switch(codec->codec_type) {
1726 case CODEC_TYPE_AUDIO:
1727 if (av_fifo_init(&ost->fifo, 1024))
1729 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1730 icodec->request_channels = codec->channels;
1731 ist->decoding_needed = 1;
1732 ost->encoding_needed = 1;
1734 case CODEC_TYPE_VIDEO:
1735 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1736 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1737 ost->video_resample = ((codec->width != icodec->width -
1738 (frame_leftBand + frame_rightBand) +
1739 (frame_padleft + frame_padright)) ||
1740 (codec->height != icodec->height -
1741 (frame_topBand + frame_bottomBand) +
1742 (frame_padtop + frame_padbottom)) ||
1743 (codec->pix_fmt != icodec->pix_fmt));
1744 if (ost->video_crop) {
1745 ost->topBand = frame_topBand;
1746 ost->leftBand = frame_leftBand;
1748 if (ost->video_pad) {
1749 ost->padtop = frame_padtop;
1750 ost->padleft = frame_padleft;
1751 ost->padbottom = frame_padbottom;
1752 ost->padright = frame_padright;
1753 if (!ost->video_resample) {
1754 avcodec_get_frame_defaults(&ost->pict_tmp);
1755 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1756 codec->width, codec->height))
1760 if (ost->video_resample) {
1761 avcodec_get_frame_defaults(&ost->pict_tmp);
1762 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1763 codec->width, codec->height)) {
1764 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1767 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1768 ost->img_resample_ctx = sws_getContext(
1769 icodec->width - (frame_leftBand + frame_rightBand),
1770 icodec->height - (frame_topBand + frame_bottomBand),
1772 codec->width - (frame_padleft + frame_padright),
1773 codec->height - (frame_padtop + frame_padbottom),
1775 sws_flags, NULL, NULL, NULL);
1776 if (ost->img_resample_ctx == NULL) {
1777 fprintf(stderr, "Cannot get resampling context\n");
1780 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1782 ost->encoding_needed = 1;
1783 ist->decoding_needed = 1;
1785 case CODEC_TYPE_SUBTITLE:
1786 ost->encoding_needed = 1;
1787 ist->decoding_needed = 1;
1794 if (ost->encoding_needed &&
1795 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1796 char logfilename[1024];
1801 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1803 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1804 if (codec->flags & CODEC_FLAG_PASS1) {
1805 f = fopen(logfilename, "w");
1807 perror(logfilename);
1812 /* read the log file */
1813 f = fopen(logfilename, "r");
1815 perror(logfilename);
1818 fseek(f, 0, SEEK_END);
1820 fseek(f, 0, SEEK_SET);
1821 logbuffer = av_malloc(size + 1);
1823 fprintf(stderr, "Could not allocate log buffer\n");
1826 size = fread(logbuffer, 1, size, f);
1828 logbuffer[size] = '\0';
1829 codec->stats_in = logbuffer;
1833 if(codec->codec_type == CODEC_TYPE_VIDEO){
1834 int size= codec->width * codec->height;
1835 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1840 bit_buffer = av_malloc(bit_buffer_size);
1844 /* dump the file output parameters - cannot be done before in case
1846 for(i=0;i<nb_output_files;i++) {
1847 dump_format(output_files[i], i, output_files[i]->filename, 1);
1850 /* dump the stream mapping */
1852 fprintf(stderr, "Stream mapping:\n");
1853 for(i=0;i<nb_ostreams;i++) {
1855 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1856 ist_table[ost->source_index]->file_index,
1857 ist_table[ost->source_index]->index,
1860 if (ost->sync_ist != ist_table[ost->source_index])
1861 fprintf(stderr, " [sync #%d.%d]",
1862 ost->sync_ist->file_index,
1863 ost->sync_ist->index);
1864 fprintf(stderr, "\n");
1868 /* open each encoder */
1869 for(i=0;i<nb_ostreams;i++) {
1871 if (ost->encoding_needed) {
1873 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1875 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1876 ost->file_index, ost->index);
1879 if (avcodec_open(ost->st->codec, codec) < 0) {
1880 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1881 ost->file_index, ost->index);
1884 extra_size += ost->st->codec->extradata_size;
1888 /* open each decoder */
1889 for(i=0;i<nb_istreams;i++) {
1891 if (ist->decoding_needed) {
1893 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1895 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1896 ist->st->codec->codec_id, ist->file_index, ist->index);
1899 if (avcodec_open(ist->st->codec, codec) < 0) {
1900 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1901 ist->file_index, ist->index);
1904 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1905 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1910 for(i=0;i<nb_istreams;i++) {
1912 is = input_files[ist->file_index];
1914 ist->next_pts = AV_NOPTS_VALUE;
1918 /* set meta data information from input file if required */
1919 for (i=0;i<nb_meta_data_maps;i++) {
1920 AVFormatContext *out_file;
1921 AVFormatContext *in_file;
1923 int out_file_index = meta_data_maps[i].out_file;
1924 int in_file_index = meta_data_maps[i].in_file;
1925 if (out_file_index < 0 || out_file_index >= nb_output_files) {
1926 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1927 ret = AVERROR(EINVAL);
1930 if (in_file_index < 0 || in_file_index >= nb_input_files) {
1931 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1932 ret = AVERROR(EINVAL);
1936 out_file = output_files[out_file_index];
1937 in_file = input_files[in_file_index];
1939 strcpy(out_file->title, in_file->title);
1940 strcpy(out_file->author, in_file->author);
1941 strcpy(out_file->copyright, in_file->copyright);
1942 strcpy(out_file->comment, in_file->comment);
1943 strcpy(out_file->album, in_file->album);
1944 out_file->year = in_file->year;
1945 out_file->track = in_file->track;
1946 strcpy(out_file->genre, in_file->genre);
1949 /* open files and write file headers */
1950 for(i=0;i<nb_output_files;i++) {
1951 os = output_files[i];
1952 if (av_write_header(os) < 0) {
1953 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1954 ret = AVERROR(EINVAL);
1957 if (strcmp(output_files[i]->oformat->name, "rtp")) {
1962 print_sdp(output_files, nb_output_files);
1965 if (!using_stdin && verbose >= 0) {
1966 fprintf(stderr, "Press [q] to stop encoding\n");
1967 url_set_interrupt_cb(decode_interrupt_cb);
1972 timer_start = av_gettime();
1974 for(; received_sigterm == 0;) {
1975 int file_index, ist_index;
1983 /* if 'q' pressed, exits */
1987 /* read_key() returns 0 on EOF */
1993 /* select the stream that we must read now by looking at the
1994 smallest output pts */
1996 for(i=0;i<nb_ostreams;i++) {
1999 os = output_files[ost->file_index];
2000 ist = ist_table[ost->source_index];
2001 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2002 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2004 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2005 ipts = (double)ist->pts;
2006 if (!file_table[ist->file_index].eof_reached){
2007 if(ipts < ipts_min) {
2009 if(input_sync ) file_index = ist->file_index;
2011 if(opts < opts_min) {
2013 if(!input_sync) file_index = ist->file_index;
2016 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2021 /* if none, if is finished */
2022 if (file_index < 0) {
2026 /* finish if recording time exhausted */
2027 if (opts_min >= (recording_time / 1000000.0))
2030 /* finish if limit size exhausted */
2031 if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2034 /* read a frame from it and output it in the fifo */
2035 is = input_files[file_index];
2036 if (av_read_frame(is, &pkt) < 0) {
2037 file_table[file_index].eof_reached = 1;
2045 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2047 /* the following test is needed in case new streams appear
2048 dynamically in stream : we ignore them */
2049 if (pkt.stream_index >= file_table[file_index].nb_streams)
2050 goto discard_packet;
2051 ist_index = file_table[file_index].ist_index + pkt.stream_index;
2052 ist = ist_table[ist_index];
2054 goto discard_packet;
2056 if (pkt.dts != AV_NOPTS_VALUE)
2057 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2058 if (pkt.pts != AV_NOPTS_VALUE)
2059 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2061 if(input_files_ts_scale[file_index][pkt.stream_index]){
2062 if(pkt.pts != AV_NOPTS_VALUE)
2063 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2064 if(pkt.dts != AV_NOPTS_VALUE)
2065 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2068 // 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);
2069 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
2070 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2071 int64_t delta= pkt_dts - ist->next_pts;
2072 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2073 input_files_ts_offset[ist->file_index]-= delta;
2075 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2076 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2077 if(pkt.pts != AV_NOPTS_VALUE)
2078 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2082 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2083 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2086 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2087 ist->file_index, ist->index);
2089 av_free_packet(&pkt);
2094 av_free_packet(&pkt);
2096 /* dump report by using the output first video and audio streams */
2097 print_report(output_files, ost_table, nb_ostreams, 0);
2100 /* at the end of stream, we must flush the decoder buffers */
2101 for(i=0;i<nb_istreams;i++) {
2103 if (ist->decoding_needed) {
2104 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2110 /* write the trailer if needed and close file */
2111 for(i=0;i<nb_output_files;i++) {
2112 os = output_files[i];
2113 av_write_trailer(os);
2116 /* dump report by using the first video and audio streams */
2117 print_report(output_files, ost_table, nb_ostreams, 1);
2119 /* close each encoder */
2120 for(i=0;i<nb_ostreams;i++) {
2122 if (ost->encoding_needed) {
2123 av_freep(&ost->st->codec->stats_in);
2124 avcodec_close(ost->st->codec);
2128 /* close each decoder */
2129 for(i=0;i<nb_istreams;i++) {
2131 if (ist->decoding_needed) {
2132 avcodec_close(ist->st->codec);
2140 av_freep(&bit_buffer);
2141 av_free(file_table);
2144 for(i=0;i<nb_istreams;i++) {
2151 for(i=0;i<nb_ostreams;i++) {
2155 fclose(ost->logfile);
2156 ost->logfile = NULL;
2158 av_fifo_free(&ost->fifo); /* works even if fifo is not
2159 initialized but set to zero */
2160 av_free(ost->pict_tmp.data[0]);
2161 if (ost->video_resample)
2162 sws_freeContext(ost->img_resample_ctx);
2164 audio_resample_close(ost->resample);
2172 ret = AVERROR(ENOMEM);
2177 int file_read(const char *filename)
2180 unsigned char buffer[1024];
2183 if (url_open(&h, filename, O_RDONLY) < 0) {
2184 printf("could not open '%s'\n", filename);
2188 len = url_read(h, buffer, sizeof(buffer));
2191 for(i=0;i<len;i++) putchar(buffer[i]);
2198 static void opt_format(const char *arg)
2200 /* compatibility stuff for pgmyuv */
2201 if (!strcmp(arg, "pgmyuv")) {
2202 pgmyuv_compatibility_hack=1;
2203 // opt_image_format(arg);
2205 fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2208 file_iformat = av_find_input_format(arg);
2209 file_oformat = guess_format(arg, NULL, NULL);
2210 if (!file_iformat && !file_oformat) {
2211 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2216 static int opt_default(const char *opt, const char *arg){
2218 const AVOption *o= NULL;
2219 int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
2221 for(type=0; type<CODEC_TYPE_NB; type++){
2222 const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
2224 o = av_set_string2(avctx_opts[type], opt, arg, 1);
2227 o = av_set_string2(avformat_opts, opt, arg, 1);
2229 o = av_set_string2(sws_opts, opt, arg, 1);
2232 o = av_set_string2(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg, 1);
2233 else if(opt[0] == 'v')
2234 o = av_set_string2(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg, 1);
2235 else if(opt[0] == 's')
2236 o = av_set_string2(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg, 1);
2241 // 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));
2243 //FIXME we should always use avctx_opts, ... for storing options so there will not be any need to keep track of what i set over this
2244 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
2245 opt_names[opt_name_count++]= o->name;
2247 if(avctx_opts[0]->debug || avformat_opts->debug)
2248 av_log_set_level(AV_LOG_DEBUG);
2252 static void opt_video_rc_override_string(const char *arg)
2254 video_rc_override_string = arg;
2257 static int opt_me_threshold(const char *opt, const char *arg)
2259 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2263 static int opt_verbose(const char *opt, const char *arg)
2265 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2266 av_log_set_level(verbose);
2270 static void opt_frame_rate(const char *arg)
2272 if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2273 fprintf(stderr, "Incorrect frame rate\n");
2278 static int opt_bitrate(const char *opt, const char *arg)
2280 int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2282 opt_default(opt, arg);
2284 if (av_get_int(avctx_opts[codec_type], "b", NULL) < 1000)
2285 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2290 static void opt_frame_crop_top(const char *arg)
2292 frame_topBand = atoi(arg);
2293 if (frame_topBand < 0) {
2294 fprintf(stderr, "Incorrect top crop size\n");
2297 if ((frame_topBand % 2) != 0) {
2298 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2301 if ((frame_topBand) >= frame_height){
2302 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2305 frame_height -= frame_topBand;
2308 static void opt_frame_crop_bottom(const char *arg)
2310 frame_bottomBand = atoi(arg);
2311 if (frame_bottomBand < 0) {
2312 fprintf(stderr, "Incorrect bottom crop size\n");
2315 if ((frame_bottomBand % 2) != 0) {
2316 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2319 if ((frame_bottomBand) >= frame_height){
2320 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2323 frame_height -= frame_bottomBand;
2326 static void opt_frame_crop_left(const char *arg)
2328 frame_leftBand = atoi(arg);
2329 if (frame_leftBand < 0) {
2330 fprintf(stderr, "Incorrect left crop size\n");
2333 if ((frame_leftBand % 2) != 0) {
2334 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2337 if ((frame_leftBand) >= frame_width){
2338 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2341 frame_width -= frame_leftBand;
2344 static void opt_frame_crop_right(const char *arg)
2346 frame_rightBand = atoi(arg);
2347 if (frame_rightBand < 0) {
2348 fprintf(stderr, "Incorrect right crop size\n");
2351 if ((frame_rightBand % 2) != 0) {
2352 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2355 if ((frame_rightBand) >= frame_width){
2356 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2359 frame_width -= frame_rightBand;
2362 static void opt_frame_size(const char *arg)
2364 if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2365 fprintf(stderr, "Incorrect frame size\n");
2368 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2369 fprintf(stderr, "Frame size must be a multiple of 2\n");
2375 #define SCALEBITS 10
2376 #define ONE_HALF (1 << (SCALEBITS - 1))
2377 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2379 #define RGB_TO_Y(r, g, b) \
2380 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2381 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2383 #define RGB_TO_U(r1, g1, b1, shift)\
2384 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2385 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2387 #define RGB_TO_V(r1, g1, b1, shift)\
2388 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2389 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2391 static void opt_pad_color(const char *arg) {
2392 /* Input is expected to be six hex digits similar to
2393 how colors are expressed in html tags (but without the #) */
2394 int rgb = strtol(arg, NULL, 16);
2398 g = ((rgb >> 8) & 255);
2401 padcolor[0] = RGB_TO_Y(r,g,b);
2402 padcolor[1] = RGB_TO_U(r,g,b,0);
2403 padcolor[2] = RGB_TO_V(r,g,b,0);
2406 static void opt_frame_pad_top(const char *arg)
2408 frame_padtop = atoi(arg);
2409 if (frame_padtop < 0) {
2410 fprintf(stderr, "Incorrect top pad size\n");
2413 if ((frame_padtop % 2) != 0) {
2414 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2419 static void opt_frame_pad_bottom(const char *arg)
2421 frame_padbottom = atoi(arg);
2422 if (frame_padbottom < 0) {
2423 fprintf(stderr, "Incorrect bottom pad size\n");
2426 if ((frame_padbottom % 2) != 0) {
2427 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2433 static void opt_frame_pad_left(const char *arg)
2435 frame_padleft = atoi(arg);
2436 if (frame_padleft < 0) {
2437 fprintf(stderr, "Incorrect left pad size\n");
2440 if ((frame_padleft % 2) != 0) {
2441 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2447 static void opt_frame_pad_right(const char *arg)
2449 frame_padright = atoi(arg);
2450 if (frame_padright < 0) {
2451 fprintf(stderr, "Incorrect right pad size\n");
2454 if ((frame_padright % 2) != 0) {
2455 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2460 static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2464 for (i=-1; i < nb_fmts; i++) {
2465 get_fmt_string (fmt_str, sizeof(fmt_str), i);
2466 fprintf(stdout, "%s\n", fmt_str);
2470 static void opt_frame_pix_fmt(const char *arg)
2472 if (strcmp(arg, "list"))
2473 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2475 list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2480 static void opt_frame_aspect_ratio(const char *arg)
2487 p = strchr(arg, ':');
2489 x = strtol(arg, &end, 10);
2491 y = strtol(end+1, &end, 10);
2493 ar = (double)x / (double)y;
2495 ar = strtod(arg, NULL);
2498 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2501 frame_aspect_ratio = ar;
2504 static void opt_qscale(const char *arg)
2506 video_qscale = atof(arg);
2507 if (video_qscale <= 0 ||
2508 video_qscale > 255) {
2509 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2514 static void opt_top_field_first(const char *arg)
2516 top_field_first= atoi(arg);
2519 static int opt_thread_count(const char *opt, const char *arg)
2521 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2522 #if !defined(HAVE_THREADS)
2524 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2529 static void opt_audio_sample_fmt(const char *arg)
2531 if (strcmp(arg, "list"))
2532 audio_sample_fmt = avcodec_get_sample_fmt(arg);
2534 list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2539 static int opt_audio_rate(const char *opt, const char *arg)
2541 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2545 static int opt_audio_channels(const char *opt, const char *arg)
2547 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2551 static void opt_video_channel(const char *arg)
2553 video_channel = strtol(arg, NULL, 0);
2556 static void opt_video_standard(const char *arg)
2558 video_standard = av_strdup(arg);
2561 static void opt_codec(int *pstream_copy, char **pcodec_name,
2562 int codec_type, const char *arg)
2564 av_freep(pcodec_name);
2565 if (!strcmp(arg, "copy")) {
2568 *pcodec_name = av_strdup(arg);
2572 static void opt_audio_codec(const char *arg)
2574 opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2577 static void opt_audio_tag(const char *arg)
2580 audio_codec_tag= strtol(arg, &tail, 0);
2583 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2586 static void opt_video_tag(const char *arg)
2589 video_codec_tag= strtol(arg, &tail, 0);
2592 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2596 static void add_frame_hooker(const char *arg)
2601 char *args = av_strdup(arg);
2605 argv[0] = strtok(args, " ");
2606 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2609 i = frame_hook_add(argc, argv);
2612 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2618 static void opt_video_codec(const char *arg)
2620 opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2623 static void opt_subtitle_codec(const char *arg)
2625 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2628 static void opt_map(const char *arg)
2633 m = &stream_maps[nb_stream_maps++];
2635 m->file_index = strtol(arg, &p, 0);
2639 m->stream_index = strtol(p, &p, 0);
2642 m->sync_file_index = strtol(p, &p, 0);
2645 m->sync_stream_index = strtol(p, &p, 0);
2647 m->sync_file_index = m->file_index;
2648 m->sync_stream_index = m->stream_index;
2652 static void opt_map_meta_data(const char *arg)
2657 m = &meta_data_maps[nb_meta_data_maps++];
2659 m->out_file = strtol(arg, &p, 0);
2663 m->in_file = strtol(p, &p, 0);
2666 static void opt_input_ts_scale(const char *arg)
2668 unsigned int stream;
2672 stream = strtol(arg, &p, 0);
2675 scale= strtod(p, &p);
2677 if(stream >= MAX_STREAMS)
2680 input_files_ts_scale[nb_input_files][stream]= scale;
2683 static int opt_recording_time(const char *opt, const char *arg)
2685 recording_time = parse_time_or_die(opt, arg, 1);
2689 static int opt_start_time(const char *opt, const char *arg)
2691 start_time = parse_time_or_die(opt, arg, 1);
2695 static int opt_rec_timestamp(const char *opt, const char *arg)
2697 rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2701 static int opt_input_ts_offset(const char *opt, const char *arg)
2703 input_ts_offset = parse_time_or_die(opt, arg, 1);
2707 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2709 const char *codec_string = encoder ? "encoder" : "decoder";
2713 return CODEC_ID_NONE;
2715 avcodec_find_encoder_by_name(name) :
2716 avcodec_find_decoder_by_name(name);
2718 av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2721 if(codec->type != type) {
2722 av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2728 static void set_context_opts(void *ctx, void *opts_ctx, int flags)
2731 for(i=0; i<opt_name_count; i++){
2733 const AVOption *opt;
2734 const char *str= av_get_string(opts_ctx, opt_names[i], &opt, buf, sizeof(buf));
2735 /* if an option with name opt_names[i] is present in opts_ctx then str is non-NULL */
2736 if(str && ((opt->flags & flags) == flags))
2737 av_set_string2(ctx, opt_names[i], str, 1);
2741 static void opt_input_file(const char *filename)
2743 AVFormatContext *ic;
2744 AVFormatParameters params, *ap = ¶ms;
2745 int err, i, ret, rfps, rfps_base;
2748 if (!strcmp(filename, "-"))
2751 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2752 !strcmp(filename, "/dev/stdin");
2754 /* get default parameters from command line */
2755 ic = av_alloc_format_context();
2757 memset(ap, 0, sizeof(*ap));
2758 ap->prealloced_context = 1;
2759 ap->sample_rate = audio_sample_rate;
2760 ap->channels = audio_channels;
2761 ap->time_base.den = frame_rate.num;
2762 ap->time_base.num = frame_rate.den;
2763 ap->width = frame_width + frame_padleft + frame_padright;
2764 ap->height = frame_height + frame_padtop + frame_padbottom;
2765 ap->pix_fmt = frame_pix_fmt;
2766 ap->channel = video_channel;
2767 ap->standard = video_standard;
2768 ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2769 ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2770 if(pgmyuv_compatibility_hack)
2771 ap->video_codec_id= CODEC_ID_PGMYUV;
2773 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2775 ic->video_codec_id = find_codec_or_die(video_codec_name , CODEC_TYPE_VIDEO , 0);
2776 ic->audio_codec_id = find_codec_or_die(audio_codec_name , CODEC_TYPE_AUDIO , 0);
2777 ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2779 /* open the input file with generic libav function */
2780 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2782 print_error(filename, err);
2787 for(i=0; i<ic->nb_programs; i++)
2788 if(ic->programs[i]->id != opt_programid)
2789 ic->programs[i]->discard = AVDISCARD_ALL;
2792 ic->loop_input = loop_input;
2794 /* If not enough info to get the stream parameters, we decode the
2795 first frames to get it. (used in mpeg case for example) */
2796 ret = av_find_stream_info(ic);
2797 if (ret < 0 && verbose >= 0) {
2798 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2802 timestamp = start_time;
2803 /* add the stream start time */
2804 if (ic->start_time != AV_NOPTS_VALUE)
2805 timestamp += ic->start_time;
2807 /* if seeking requested, we execute it */
2808 if (start_time != 0) {
2809 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2811 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2812 filename, (double)timestamp / AV_TIME_BASE);
2814 /* reset seek info */
2818 /* update the current parameters so that they match the one of the input stream */
2819 for(i=0;i<ic->nb_streams;i++) {
2820 AVCodecContext *enc = ic->streams[i]->codec;
2822 avcodec_thread_init(enc, thread_count);
2823 enc->thread_count= thread_count;
2824 switch(enc->codec_type) {
2825 case CODEC_TYPE_AUDIO:
2826 set_context_opts(enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2827 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2828 audio_channels = enc->channels;
2829 audio_sample_rate = enc->sample_rate;
2831 ic->streams[i]->discard= AVDISCARD_ALL;
2833 case CODEC_TYPE_VIDEO:
2834 set_context_opts(enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2835 frame_height = enc->height;
2836 frame_width = enc->width;
2837 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2838 frame_pix_fmt = enc->pix_fmt;
2839 rfps = ic->streams[i]->r_frame_rate.num;
2840 rfps_base = ic->streams[i]->r_frame_rate.den;
2841 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2843 enc->debug |= FF_DEBUG_MV;
2845 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2848 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2849 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2851 (float)rfps / rfps_base, rfps, rfps_base);
2853 /* update the current frame rate to match the stream frame rate */
2854 frame_rate.num = rfps;
2855 frame_rate.den = rfps_base;
2857 enc->rate_emu = rate_emu;
2859 ic->streams[i]->discard= AVDISCARD_ALL;
2860 else if(video_discard)
2861 ic->streams[i]->discard= video_discard;
2863 case CODEC_TYPE_DATA:
2865 case CODEC_TYPE_SUBTITLE:
2866 if(subtitle_disable)
2867 ic->streams[i]->discard = AVDISCARD_ALL;
2869 case CODEC_TYPE_ATTACHMENT:
2870 case CODEC_TYPE_UNKNOWN:
2877 input_files[nb_input_files] = ic;
2878 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2879 /* dump the file content */
2881 dump_format(ic, nb_input_files, filename, 0);
2884 file_iformat = NULL;
2885 file_oformat = NULL;
2890 av_freep(&video_codec_name);
2891 av_freep(&audio_codec_name);
2892 av_freep(&subtitle_codec_name);
2895 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2896 int *has_subtitle_ptr)
2898 int has_video, has_audio, has_subtitle, i, j;
2899 AVFormatContext *ic;
2904 for(j=0;j<nb_input_files;j++) {
2905 ic = input_files[j];
2906 for(i=0;i<ic->nb_streams;i++) {
2907 AVCodecContext *enc = ic->streams[i]->codec;
2908 switch(enc->codec_type) {
2909 case CODEC_TYPE_AUDIO:
2912 case CODEC_TYPE_VIDEO:
2915 case CODEC_TYPE_SUBTITLE:
2918 case CODEC_TYPE_DATA:
2919 case CODEC_TYPE_ATTACHMENT:
2920 case CODEC_TYPE_UNKNOWN:
2927 *has_video_ptr = has_video;
2928 *has_audio_ptr = has_audio;
2929 *has_subtitle_ptr = has_subtitle;
2932 static void new_video_stream(AVFormatContext *oc)
2935 AVCodecContext *video_enc;
2938 st = av_new_stream(oc, oc->nb_streams);
2940 fprintf(stderr, "Could not alloc stream\n");
2943 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2944 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2945 video_bitstream_filters= NULL;
2948 avcodec_thread_init(st->codec, thread_count);
2950 video_enc = st->codec;
2953 video_enc->codec_tag= video_codec_tag;
2955 if( (video_global_header&1)
2956 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2957 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2958 avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2960 if(video_global_header&2){
2961 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2962 avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2965 if (video_stream_copy) {
2966 st->stream_copy = 1;
2967 video_enc->codec_type = CODEC_TYPE_VIDEO;
2972 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
2974 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2975 if (video_codec_name)
2976 codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
2978 video_enc->codec_id = codec_id;
2979 codec = avcodec_find_encoder(codec_id);
2981 set_context_opts(video_enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
2983 video_enc->time_base.den = fps.num;
2984 video_enc->time_base.num = fps.den;
2985 if(codec && codec->supported_framerates){
2986 const AVRational *p= codec->supported_framerates;
2987 const AVRational *best=NULL;
2988 AVRational best_error= (AVRational){INT_MAX, 1};
2989 for(; p->den!=0; p++){
2990 AVRational error= av_sub_q(fps, *p);
2991 if(error.num <0) error.num *= -1;
2992 if(av_cmp_q(error, best_error) < 0){
2997 video_enc->time_base.den= best->num;
2998 video_enc->time_base.num= best->den;
3001 video_enc->width = frame_width + frame_padright + frame_padleft;
3002 video_enc->height = frame_height + frame_padtop + frame_padbottom;
3003 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3004 video_enc->pix_fmt = frame_pix_fmt;
3006 if(codec && codec->pix_fmts){
3007 const enum PixelFormat *p= codec->pix_fmts;
3009 if(*p == video_enc->pix_fmt)
3013 video_enc->pix_fmt = codec->pix_fmts[0];
3017 video_enc->gop_size = 0;
3018 if (video_qscale || same_quality) {
3019 video_enc->flags |= CODEC_FLAG_QSCALE;
3020 video_enc->global_quality=
3021 st->quality = FF_QP2LAMBDA * video_qscale;
3025 video_enc->intra_matrix = intra_matrix;
3027 video_enc->inter_matrix = inter_matrix;
3029 video_enc->thread_count = thread_count;
3030 p= video_rc_override_string;
3033 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3035 fprintf(stderr, "error parsing rc_override\n");
3038 video_enc->rc_override=
3039 av_realloc(video_enc->rc_override,
3040 sizeof(RcOverride)*(i+1));
3041 video_enc->rc_override[i].start_frame= start;
3042 video_enc->rc_override[i].end_frame = end;
3044 video_enc->rc_override[i].qscale= q;
3045 video_enc->rc_override[i].quality_factor= 1.0;
3048 video_enc->rc_override[i].qscale= 0;
3049 video_enc->rc_override[i].quality_factor= -q/100.0;
3054 video_enc->rc_override_count=i;
3055 if (!video_enc->rc_initial_buffer_occupancy)
3056 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3057 video_enc->me_threshold= me_threshold;
3058 video_enc->intra_dc_precision= intra_dc_precision - 8;
3061 video_enc->flags|= CODEC_FLAG_PSNR;
3066 video_enc->flags |= CODEC_FLAG_PASS1;
3068 video_enc->flags |= CODEC_FLAG_PASS2;
3073 /* reset some key parameters */
3075 av_freep(&video_codec_name);
3076 video_stream_copy = 0;
3079 static void new_audio_stream(AVFormatContext *oc)
3082 AVCodecContext *audio_enc;
3085 st = av_new_stream(oc, oc->nb_streams);
3087 fprintf(stderr, "Could not alloc stream\n");
3090 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3092 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3093 audio_bitstream_filters= NULL;
3096 avcodec_thread_init(st->codec, thread_count);
3098 audio_enc = st->codec;
3099 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3102 audio_enc->codec_tag= audio_codec_tag;
3104 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3105 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3106 avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3108 if (audio_stream_copy) {
3109 st->stream_copy = 1;
3110 audio_enc->channels = audio_channels;
3112 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3114 set_context_opts(audio_enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3116 if (audio_codec_name)
3117 codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3118 audio_enc->codec_id = codec_id;
3120 if (audio_qscale > QSCALE_NONE) {
3121 audio_enc->flags |= CODEC_FLAG_QSCALE;
3122 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3124 audio_enc->thread_count = thread_count;
3125 audio_enc->channels = audio_channels;
3127 audio_enc->sample_rate = audio_sample_rate;
3128 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3129 if (audio_language) {
3130 av_strlcpy(st->language, audio_language, sizeof(st->language));
3131 av_free(audio_language);
3132 audio_language = NULL;
3135 /* reset some key parameters */
3137 av_freep(&audio_codec_name);
3138 audio_stream_copy = 0;
3141 static void new_subtitle_stream(AVFormatContext *oc)
3144 AVCodecContext *subtitle_enc;
3146 st = av_new_stream(oc, oc->nb_streams);
3148 fprintf(stderr, "Could not alloc stream\n");
3151 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3153 bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3154 subtitle_bitstream_filters= NULL;
3156 subtitle_enc = st->codec;
3157 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3158 if (subtitle_stream_copy) {
3159 st->stream_copy = 1;
3161 set_context_opts(avctx_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3162 subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3165 if (subtitle_language) {
3166 av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3167 av_free(subtitle_language);
3168 subtitle_language = NULL;
3171 subtitle_disable = 0;
3172 av_freep(&subtitle_codec_name);
3173 subtitle_stream_copy = 0;
3176 static void opt_new_audio_stream(void)
3178 AVFormatContext *oc;
3179 if (nb_output_files <= 0) {
3180 fprintf(stderr, "At least one output file must be specified\n");
3183 oc = output_files[nb_output_files - 1];
3184 new_audio_stream(oc);
3187 static void opt_new_video_stream(void)
3189 AVFormatContext *oc;
3190 if (nb_output_files <= 0) {
3191 fprintf(stderr, "At least one output file must be specified\n");
3194 oc = output_files[nb_output_files - 1];
3195 new_video_stream(oc);
3198 static void opt_new_subtitle_stream(void)
3200 AVFormatContext *oc;
3201 if (nb_output_files <= 0) {
3202 fprintf(stderr, "At least one output file must be specified\n");
3205 oc = output_files[nb_output_files - 1];
3206 new_subtitle_stream(oc);
3209 static void opt_output_file(const char *filename)
3211 AVFormatContext *oc;
3212 int use_video, use_audio, use_subtitle;
3213 int input_has_video, input_has_audio, input_has_subtitle;
3214 AVFormatParameters params, *ap = ¶ms;
3216 if (!strcmp(filename, "-"))
3219 oc = av_alloc_format_context();
3221 if (!file_oformat) {
3222 file_oformat = guess_format(NULL, filename, NULL);
3223 if (!file_oformat) {
3224 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3230 oc->oformat = file_oformat;
3231 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3233 if (!strcmp(file_oformat->name, "ffm") &&
3234 av_strstart(filename, "http:", NULL)) {
3235 /* special case for files sent to ffserver: we get the stream
3236 parameters from ffserver */
3237 int err = read_ffserver_streams(oc, filename);
3239 print_error(filename, err);
3243 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3244 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3245 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3247 /* disable if no corresponding type found and at least one
3249 if (nb_input_files > 0) {
3250 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3251 &input_has_subtitle);
3252 if (!input_has_video)
3254 if (!input_has_audio)
3256 if (!input_has_subtitle)
3260 /* manual disable */
3261 if (audio_disable) {
3264 if (video_disable) {
3267 if (subtitle_disable) {
3272 new_video_stream(oc);
3276 new_audio_stream(oc);
3280 new_subtitle_stream(oc);
3283 oc->timestamp = rec_timestamp;
3286 av_strlcpy(oc->title, str_title, sizeof(oc->title));
3288 av_strlcpy(oc->author, str_author, sizeof(oc->author));
3290 av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3292 av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3294 av_strlcpy(oc->album, str_album, sizeof(oc->album));
3296 av_strlcpy(oc->genre, str_genre, sizeof(oc->genre));
3299 output_files[nb_output_files++] = oc;
3301 /* check filename in case of an image number is expected */
3302 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3303 if (!av_filename_number_test(oc->filename)) {
3304 print_error(oc->filename, AVERROR_NUMEXPECTED);
3309 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3310 /* test if it already exists to avoid loosing precious files */
3311 if (!file_overwrite &&
3312 (strchr(filename, ':') == NULL ||
3313 filename[1] == ':' ||
3314 av_strstart(filename, "file:", NULL))) {
3315 if (url_exist(filename)) {
3319 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3322 if (toupper(c) != 'Y') {
3323 fprintf(stderr, "Not overwriting - exiting\n");
3328 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3335 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3336 fprintf(stderr, "Could not open '%s'\n", filename);
3341 memset(ap, 0, sizeof(*ap));
3342 if (av_set_parameters(oc, ap) < 0) {
3343 fprintf(stderr, "%s: Invalid encoding parameters\n",
3348 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3349 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3350 oc->loop_output = loop_output;
3352 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3354 /* reset some options */
3355 file_oformat = NULL;
3356 file_iformat = NULL;
3359 /* same option as mencoder */
3360 static void opt_pass(const char *pass_str)
3363 pass = atoi(pass_str);
3364 if (pass != 1 && pass != 2) {
3365 fprintf(stderr, "pass number can be only 1 or 2\n");
3371 static int64_t getutime(void)
3373 #ifdef HAVE_GETRUSAGE
3374 struct rusage rusage;
3376 getrusage(RUSAGE_SELF, &rusage);
3377 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3378 #elif defined(HAVE_GETPROCESSTIMES)
3380 FILETIME c, e, k, u;
3381 proc = GetCurrentProcess();
3382 GetProcessTimes(proc, &c, &e, &k, &u);
3383 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3385 return av_gettime();
3389 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3392 const char *p = str;
3399 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3406 static void opt_inter_matrix(const char *arg)
3408 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3409 parse_matrix_coeffs(inter_matrix, arg);
3412 static void opt_intra_matrix(const char *arg)
3414 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3415 parse_matrix_coeffs(intra_matrix, arg);
3419 * Trivial log callback.
3420 * Only suitable for show_help and similar since it lacks prefix handling.
3422 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3424 vfprintf(stdout, fmt, vl);
3427 static void show_help(void)
3429 av_log_set_callback(log_callback_help);
3430 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3431 "Hyper fast Audio and Video encoder\n");
3433 show_help_options(options, "Main options:\n",
3434 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3435 show_help_options(options, "\nAdvanced options:\n",
3436 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3438 show_help_options(options, "\nVideo options:\n",
3439 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3441 show_help_options(options, "\nAdvanced Video options:\n",
3442 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3443 OPT_VIDEO | OPT_EXPERT);
3444 show_help_options(options, "\nAudio options:\n",
3445 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3447 show_help_options(options, "\nAdvanced Audio options:\n",
3448 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3449 OPT_AUDIO | OPT_EXPERT);
3450 show_help_options(options, "\nSubtitle options:\n",
3451 OPT_SUBTITLE | OPT_GRAB,
3453 show_help_options(options, "\nAudio/Video grab options:\n",
3457 av_opt_show(avctx_opts[0], NULL);
3459 av_opt_show(avformat_opts, NULL);
3461 av_opt_show(sws_opts, NULL);
3464 static void opt_target(const char *arg)
3467 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3469 if(!strncmp(arg, "pal-", 4)) {
3472 } else if(!strncmp(arg, "ntsc-", 5)) {
3475 } else if(!strncmp(arg, "film-", 5)) {
3480 /* Calculate FR via float to avoid int overflow */
3481 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3484 } else if((fr == 29970) || (fr == 23976)) {
3487 /* Try to determine PAL/NTSC by peeking in the input files */
3488 if(nb_input_files) {
3490 for(j = 0; j < nb_input_files; j++) {
3491 for(i = 0; i < input_files[j]->nb_streams; i++) {
3492 AVCodecContext *c = input_files[j]->streams[i]->codec;
3493 if(c->codec_type != CODEC_TYPE_VIDEO)
3495 fr = c->time_base.den * 1000 / c->time_base.num;
3499 } else if((fr == 29970) || (fr == 23976)) {
3509 if(verbose && norm >= 0)
3510 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3514 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3515 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3516 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3520 if(!strcmp(arg, "vcd")) {
3522 opt_video_codec("mpeg1video");
3523 opt_audio_codec("mp2");
3526 opt_frame_size(norm ? "352x240" : "352x288");
3527 opt_frame_rate(frame_rates[norm]);
3528 opt_default("gop", norm ? "18" : "15");
3530 opt_default("b", "1150000");
3531 opt_default("maxrate", "1150000");
3532 opt_default("minrate", "1150000");
3533 opt_default("bufsize", "327680"); // 40*1024*8;
3535 opt_default("ab", "224000");
3536 audio_sample_rate = 44100;
3539 opt_default("packetsize", "2324");
3540 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3542 /* We have to offset the PTS, so that it is consistent with the SCR.
3543 SCR starts at 36000, but the first two packs contain only padding
3544 and the first pack from the other stream, respectively, may also have
3545 been written before.
3546 So the real data starts at SCR 36000+3*1200. */
3547 mux_preload= (36000+3*1200) / 90000.0; //0.44
3548 } else if(!strcmp(arg, "svcd")) {
3550 opt_video_codec("mpeg2video");
3551 opt_audio_codec("mp2");
3554 opt_frame_size(norm ? "480x480" : "480x576");
3555 opt_frame_rate(frame_rates[norm]);
3556 opt_default("gop", norm ? "18" : "15");
3558 opt_default("b", "2040000");
3559 opt_default("maxrate", "2516000");
3560 opt_default("minrate", "0"); //1145000;
3561 opt_default("bufsize", "1835008"); //224*1024*8;
3562 opt_default("flags", "+SCAN_OFFSET");
3565 opt_default("ab", "224000");
3566 audio_sample_rate = 44100;
3568 opt_default("packetsize", "2324");
3570 } else if(!strcmp(arg, "dvd")) {
3572 opt_video_codec("mpeg2video");
3573 opt_audio_codec("ac3");
3576 opt_frame_size(norm ? "720x480" : "720x576");
3577 opt_frame_rate(frame_rates[norm]);
3578 opt_default("gop", norm ? "18" : "15");
3580 opt_default("b", "6000000");
3581 opt_default("maxrate", "9000000");
3582 opt_default("minrate", "0"); //1500000;
3583 opt_default("bufsize", "1835008"); //224*1024*8;
3585 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3586 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3588 opt_default("ab", "448000");
3589 audio_sample_rate = 48000;
3591 } else if(!strncmp(arg, "dv", 2)) {
3595 opt_frame_size(norm ? "720x480" : "720x576");
3596 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3597 (norm ? "yuv411p" : "yuv420p"));
3598 opt_frame_rate(frame_rates[norm]);
3600 audio_sample_rate = 48000;
3604 fprintf(stderr, "Unknown target: %s\n", arg);
3609 static void opt_vstats_file (const char *arg)
3611 av_free (vstats_filename);
3612 vstats_filename=av_strdup (arg);
3615 static void opt_vstats (void)
3618 time_t today2 = time(NULL);
3619 struct tm *today = localtime(&today2);
3621 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3623 opt_vstats_file(filename);
3626 static int opt_bsf(const char *opt, const char *arg)
3628 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3629 AVBitStreamFilterContext **bsfp;
3632 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3636 bsfp= *opt == 'v' ? &video_bitstream_filters :
3637 *opt == 'a' ? &audio_bitstream_filters :
3638 &subtitle_bitstream_filters;
3640 bsfp= &(*bsfp)->next;
3647 static int opt_preset(const char *opt, const char *arg)
3650 char tmp[1000], tmp2[1000];
3652 const char *base[3]= { getenv("HOME"),
3657 for(i=!base[0]; i<3 && !f; i++){
3658 snprintf(tmp, sizeof(tmp), "%s/%sffmpeg/%s.ffpreset", base[i], i ? "" : ".", arg);
3661 char *codec_name= *opt == 'v' ? video_codec_name :
3662 *opt == 'a' ? audio_codec_name :
3663 subtitle_codec_name;
3664 snprintf(tmp, sizeof(tmp), "%s/%sffmpeg/%s-%s.ffpreset", base[i], i ? "" : ".", codec_name, arg);
3670 fprintf(stderr, "Preset file not found\n");
3675 int e= fscanf(f, "%999[^=]=%999[^\n]\n", tmp, tmp2);
3677 fprintf(stderr, "Preset file invalid\n");
3680 if(!strcmp(tmp, "acodec")){
3681 opt_audio_codec(tmp2);
3682 }else if(!strcmp(tmp, "vcodec")){
3683 opt_video_codec(tmp2);
3684 }else if(!strcmp(tmp, "scodec")){
3685 opt_subtitle_codec(tmp2);
3687 opt_default(tmp, tmp2);
3695 static const OptionDef options[] = {
3697 { "L", OPT_EXIT, {(void*)show_license}, "show license" },
3698 { "h", OPT_EXIT, {(void*)show_help}, "show help" },
3699 { "version", OPT_EXIT, {(void*)show_version}, "show version" },
3700 { "formats", OPT_EXIT, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3701 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3702 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3703 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3704 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3705 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3706 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3707 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3708 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3709 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3710 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
3711 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3712 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3713 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3714 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3715 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3716 { "genre", HAS_ARG | OPT_STRING, {(void*)&str_genre}, "set the genre", "string" },
3717 { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3718 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3719 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3720 "add timings for benchmarking" },
3721 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3722 "dump each input packet" },
3723 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3724 "when dumping packets, also dump the payload" },
3725 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3726 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3727 { "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)", "" },
3728 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set the logging verbosity level", "number" },
3729 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3730 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3731 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3732 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3733 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3734 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3735 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3736 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3737 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3738 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3741 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3742 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3743 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3744 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3745 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3746 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3747 { "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" },
3748 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3749 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3750 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3751 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3752 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3753 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3754 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3755 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3756 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3757 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3758 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3759 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3760 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3761 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3762 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3763 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
3764 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3765 "use same video quality as source (implies VBR)" },
3766 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3767 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3768 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3769 "deinterlace pictures" },
3770 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3771 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3772 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3774 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3776 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3777 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3778 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3779 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3780 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3781 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3782 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3785 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3786 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3787 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3788 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3789 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3790 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3791 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3792 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3793 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3794 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3795 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3797 /* subtitle options */
3798 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3799 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3800 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3801 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3804 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3805 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3806 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3809 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3810 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3812 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3813 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3814 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3816 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3817 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3818 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "", "preset" },
3820 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3824 int main(int argc, char **argv)
3829 avcodec_register_all();
3830 avdevice_register_all();
3833 if(isatty(STDIN_FILENO))
3834 url_set_interrupt_cb(decode_interrupt_cb);
3836 for(i=0; i<CODEC_TYPE_NB; i++){
3837 avctx_opts[i]= avcodec_alloc_context2(i);
3839 avformat_opts = av_alloc_format_context();
3840 sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3849 parse_options(argc, argv, options, opt_output_file);
3851 /* file converter / grab */
3852 if (nb_output_files <= 0) {
3853 fprintf(stderr, "Must supply at least one output file\n");
3857 if (nb_input_files == 0) {
3858 fprintf(stderr, "Must supply at least one input file\n");
3863 av_encode(output_files, nb_output_files, input_files, nb_input_files,
3864 stream_maps, nb_stream_maps);
3865 ti = getutime() - ti;
3867 printf("bench: utime=%0.3fs\n", ti / 1000000.0);