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
33 #include "framehook.h"
37 #include "os_support.h"
39 #if !defined(HAVE_GETRUSAGE) && defined(HAVE_GETPROCESSTIMES)
43 #if defined(HAVE_TERMIOS_H)
46 #include <sys/ioctl.h>
49 #include <sys/resource.h>
50 #elif defined(HAVE_CONIO_H)
53 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
64 static const char program_name[] = "FFmpeg";
65 static const int program_birth_year = 2000;
67 /* select an input stream for an output stream */
68 typedef struct AVStreamMap {
72 int sync_stream_index;
75 /** select an input file for an output file */
76 typedef struct AVMetaDataMap {
81 extern const OptionDef options[];
85 static AVFormatContext *input_files[MAX_FILES];
86 static int64_t input_files_ts_offset[MAX_FILES];
87 static int nb_input_files = 0;
89 static AVFormatContext *output_files[MAX_FILES];
90 static int nb_output_files = 0;
92 static AVStreamMap stream_maps[MAX_FILES];
93 static int nb_stream_maps;
95 static AVMetaDataMap meta_data_maps[MAX_FILES];
96 static int nb_meta_data_maps;
98 static AVInputFormat *file_iformat;
99 static AVOutputFormat *file_oformat;
100 static int frame_width = 0;
101 static int frame_height = 0;
102 static float frame_aspect_ratio = 0;
103 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
104 static int frame_padtop = 0;
105 static int frame_padbottom = 0;
106 static int frame_padleft = 0;
107 static int frame_padright = 0;
108 static int padcolor[3] = {16,128,128}; /* default to black */
109 static int frame_topBand = 0;
110 static int frame_bottomBand = 0;
111 static int frame_leftBand = 0;
112 static int frame_rightBand = 0;
113 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
114 static AVRational frame_rate = (AVRational) {0,0};
115 static float video_qscale = 0;
116 static int video_qdiff = 3;
117 static uint16_t *intra_matrix = NULL;
118 static uint16_t *inter_matrix = NULL;
119 #if 0 //experimental, (can be removed)
120 static float video_rc_qsquish=1.0;
121 static float video_rc_qmod_amp=0;
122 static int video_rc_qmod_freq=0;
124 static const char *video_rc_override_string=NULL;
125 static int video_disable = 0;
126 static int video_discard = 0;
127 static char *video_codec_name = NULL;
128 static int video_codec_tag = 0;
129 static int same_quality = 0;
130 static int do_deinterlace = 0;
131 static int strict = 0;
132 static int top_field_first = -1;
133 static int me_threshold = 0;
134 static int intra_dc_precision = 8;
135 static int loop_input = 0;
136 static int loop_output = AVFMT_NOOUTPUTLOOP;
137 static int qp_hist = 0;
139 static int intra_only = 0;
140 static int audio_sample_rate = 44100;
141 #define QSCALE_NONE -99999
142 static float audio_qscale = QSCALE_NONE;
143 static int audio_disable = 0;
144 static int audio_channels = 1;
145 static char *audio_codec_name = NULL;
146 static int audio_codec_tag = 0;
147 static char *audio_language = NULL;
149 static int subtitle_disable = 0;
150 static char *subtitle_codec_name = NULL;
151 static char *subtitle_language = NULL;
153 static float mux_preload= 0.5;
154 static float mux_max_delay= 0.7;
156 static int64_t recording_time = 0;
157 static int64_t start_time = 0;
158 static int64_t rec_timestamp = 0;
159 static int64_t input_ts_offset = 0;
160 static int file_overwrite = 0;
161 static char *str_title = NULL;
162 static char *str_author = NULL;
163 static char *str_copyright = NULL;
164 static char *str_comment = NULL;
165 static char *str_genre = NULL;
166 static char *str_album = NULL;
167 static int do_benchmark = 0;
168 static int do_hex_dump = 0;
169 static int do_pkt_dump = 0;
170 static int do_psnr = 0;
171 static int do_pass = 0;
172 static char *pass_logfilename = NULL;
173 static int audio_stream_copy = 0;
174 static int video_stream_copy = 0;
175 static int subtitle_stream_copy = 0;
176 static int video_sync_method= 1;
177 static int audio_sync_method= 0;
178 static float audio_drift_threshold= 0.1;
179 static int copy_ts= 0;
180 static int opt_shortest = 0; //
181 static int video_global_header = 0;
182 static char *vstats_filename;
183 static FILE *vstats_file;
184 static int opt_programid = 0;
186 static int rate_emu = 0;
188 static int video_channel = 0;
189 static char *video_standard;
191 static int audio_volume = 256;
193 static int using_stdin = 0;
194 static int using_vhook = 0;
195 static int verbose = 1;
196 static int thread_count= 1;
197 static int q_pressed = 0;
198 static int64_t video_size = 0;
199 static int64_t audio_size = 0;
200 static int64_t extra_size = 0;
201 static int nb_frames_dup = 0;
202 static int nb_frames_drop = 0;
203 static int input_sync;
204 static uint64_t limit_filesize = 0; //
206 static int pgmyuv_compatibility_hack=0;
207 static float dts_delta_threshold = 10;
209 static unsigned int sws_flags = SWS_BICUBIC;
211 static const char **opt_names;
212 static int opt_name_count;
213 static AVCodecContext *avctx_opts[CODEC_TYPE_NB];
214 static AVFormatContext *avformat_opts;
215 static struct SwsContext *sws_opts;
216 static int64_t timer_start;
218 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
219 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
220 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
221 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
223 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
225 struct AVInputStream;
227 typedef struct AVOutputStream {
228 int file_index; /* file index */
229 int index; /* stream index in the output file */
230 int source_index; /* AVInputStream index */
231 AVStream *st; /* stream in the output file */
232 int encoding_needed; /* true if encoding needed for this stream */
234 /* input pts and corresponding output pts
236 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
237 struct AVInputStream *sync_ist; /* input stream to sync against */
238 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
241 AVFrame pict_tmp; /* temporary image for resampling */
242 struct SwsContext *img_resample_ctx; /* for image resampling */
246 int topBand; /* cropping area sizes */
250 int padtop; /* padding area sizes */
257 ReSampleContext *resample; /* for audio resampling */
258 AVFifoBuffer fifo; /* for compression: one audio fifo per codec */
262 typedef struct AVInputStream {
266 int discard; /* true if stream data should be discarded */
267 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
268 int64_t sample_index; /* current sample */
270 int64_t start; /* time when read started */
271 unsigned long frame; /* current frame */
272 int64_t next_pts; /* synthetic pts for cases where pkt.pts
274 int64_t pts; /* current pts */
275 int is_start; /* is 1 at the start and after a discontinuity */
278 typedef struct AVInputFile {
279 int eof_reached; /* true if eof reached */
280 int ist_index; /* index of first stream in ist_table */
281 int buffer_size; /* current total buffer size */
282 int nb_streams; /* nb streams we are aware of */
285 #ifdef HAVE_TERMIOS_H
287 /* init terminal so that we can grab keys */
288 static struct termios oldtty;
291 static void term_exit(void)
293 #ifdef HAVE_TERMIOS_H
294 tcsetattr (0, TCSANOW, &oldtty);
298 static volatile sig_atomic_t received_sigterm = 0;
301 sigterm_handler(int sig)
303 received_sigterm = sig;
307 static void term_init(void)
309 #ifdef HAVE_TERMIOS_H
315 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
316 |INLCR|IGNCR|ICRNL|IXON);
317 tty.c_oflag |= OPOST;
318 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
319 tty.c_cflag &= ~(CSIZE|PARENB);
324 tcsetattr (0, TCSANOW, &tty);
325 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
328 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
329 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
331 register a function to be called at normal program termination
334 #ifdef CONFIG_BEOS_NETSERVER
335 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
339 /* read a key without blocking */
340 static int read_key(void)
342 #if defined(HAVE_TERMIOS_H)
345 #ifndef CONFIG_BEOS_NETSERVER
353 n = select(1, &rfds, NULL, NULL, &tv);
362 #elif defined(HAVE_CONIO_H)
369 static int decode_interrupt_cb(void)
371 return q_pressed || (q_pressed = read_key() == 'q');
374 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
379 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
382 /* copy stream format */
383 s->nb_streams = ic->nb_streams;
384 for(i=0;i<ic->nb_streams;i++) {
387 // FIXME: a more elegant solution is needed
388 st = av_mallocz(sizeof(AVStream));
389 memcpy(st, ic->streams[i], sizeof(AVStream));
390 st->codec = avcodec_alloc_context();
391 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
395 av_close_input_file(ic);
400 get_sync_ipts(const AVOutputStream *ost)
402 const AVInputStream *ist = ost->sync_ist;
403 return (double)(ist->pts - start_time)/AV_TIME_BASE;
406 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
410 AVPacket new_pkt= *pkt;
411 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
412 &new_pkt.data, &new_pkt.size,
413 pkt->data, pkt->size,
414 pkt->flags & PKT_FLAG_KEY);
417 new_pkt.destruct= av_destruct_packet;
419 fprintf(stderr, "%s failed for stream %d, codec %s",
420 bsfc->filter->name, pkt->stream_index,
421 avctx->codec ? avctx->codec->name : "copy");
429 ret= av_interleaved_write_frame(s, pkt);
431 print_error("av_interleaved_write_frame()", ret);
436 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
438 static void do_audio_out(AVFormatContext *s,
441 unsigned char *buf, int size)
444 static uint8_t *audio_buf = NULL;
445 static uint8_t *audio_out = NULL;
446 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
448 int size_out, frame_bytes, ret;
449 AVCodecContext *enc= ost->st->codec;
450 AVCodecContext *dec= ist->st->codec;
452 /* SC: dynamic allocation of buffers */
454 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
456 audio_out = av_malloc(audio_out_size);
457 if (!audio_buf || !audio_out)
458 return; /* Should signal an error ! */
460 if (enc->channels != dec->channels)
461 ost->audio_resample = 1;
463 if (ost->audio_resample && !ost->resample) {
464 ost->resample = audio_resample_init(enc->channels, dec->channels,
465 enc->sample_rate, dec->sample_rate);
466 if (!ost->resample) {
467 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
468 dec->channels, dec->sample_rate,
469 enc->channels, enc->sample_rate);
474 if(audio_sync_method){
475 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
476 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
477 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
478 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
480 //FIXME resample delay
481 if(fabs(delta) > 50){
482 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
484 byte_delta= FFMAX(byte_delta, -size);
488 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
493 static uint8_t *input_tmp= NULL;
494 input_tmp= av_realloc(input_tmp, byte_delta + size);
496 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
499 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
501 memset(input_tmp, 0, byte_delta);
502 memcpy(input_tmp + byte_delta, buf, size);
506 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
508 }else if(audio_sync_method>1){
509 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
510 assert(ost->audio_resample);
512 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
513 // 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));
514 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
518 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
519 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
521 if (ost->audio_resample) {
523 size_out = audio_resample(ost->resample,
524 (short *)buftmp, (short *)buf,
525 size / (ist->st->codec->channels * 2));
526 size_out = size_out * enc->channels * 2;
532 /* now encode as many frames as possible */
533 if (enc->frame_size > 1) {
534 /* output resampled raw samples */
535 av_fifo_realloc(&ost->fifo, av_fifo_size(&ost->fifo) + size_out + 1);
536 av_fifo_write(&ost->fifo, buftmp, size_out);
538 frame_bytes = enc->frame_size * 2 * enc->channels;
540 while (av_fifo_read(&ost->fifo, audio_buf, frame_bytes) == 0) {
542 av_init_packet(&pkt);
544 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
546 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
549 pkt.stream_index= ost->index;
552 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
553 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
554 pkt.flags |= PKT_FLAG_KEY;
555 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
557 ost->sync_opts += enc->frame_size;
561 av_init_packet(&pkt);
563 ost->sync_opts += size_out / (2 * enc->channels);
565 /* output a pcm frame */
566 /* XXX: change encoding codec API to avoid this ? */
567 switch(enc->codec->id) {
568 case CODEC_ID_PCM_S32LE:
569 case CODEC_ID_PCM_S32BE:
570 case CODEC_ID_PCM_U32LE:
571 case CODEC_ID_PCM_U32BE:
572 size_out = size_out << 1;
574 case CODEC_ID_PCM_S24LE:
575 case CODEC_ID_PCM_S24BE:
576 case CODEC_ID_PCM_U24LE:
577 case CODEC_ID_PCM_U24BE:
578 case CODEC_ID_PCM_S24DAUD:
579 size_out = size_out / 2 * 3;
581 case CODEC_ID_PCM_S16LE:
582 case CODEC_ID_PCM_S16BE:
583 case CODEC_ID_PCM_U16LE:
584 case CODEC_ID_PCM_U16BE:
587 size_out = size_out >> 1;
590 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
591 ret = avcodec_encode_audio(enc, audio_out, size_out,
594 pkt.stream_index= ost->index;
597 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
598 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
599 pkt.flags |= PKT_FLAG_KEY;
600 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
604 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
608 AVPicture picture_tmp;
611 dec = ist->st->codec;
613 /* deinterlace : must be done before any resize */
614 if (do_deinterlace || using_vhook) {
617 /* create temporary picture */
618 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
619 buf = av_malloc(size);
623 picture2 = &picture_tmp;
624 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
627 if(avpicture_deinterlace(picture2, picture,
628 dec->pix_fmt, dec->width, dec->height) < 0) {
629 /* if error, do not deinterlace */
635 av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
642 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,
643 1000000 * ist->pts / AV_TIME_BASE);
645 if (picture != picture2)
646 *picture = *picture2;
650 /* we begin to correct av delay at this threshold */
651 #define AV_DELAY_MAX 0.100
653 static void do_subtitle_out(AVFormatContext *s,
659 static uint8_t *subtitle_out = NULL;
660 int subtitle_out_max_size = 65536;
661 int subtitle_out_size, nb, i;
665 if (pts == AV_NOPTS_VALUE) {
666 fprintf(stderr, "Subtitle packets must have a pts\n");
670 enc = ost->st->codec;
673 subtitle_out = av_malloc(subtitle_out_max_size);
676 /* Note: DVB subtitle need one packet to draw them and one other
677 packet to clear them */
678 /* XXX: signal it in the codec context ? */
679 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
684 for(i = 0; i < nb; i++) {
685 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
686 subtitle_out_max_size, sub);
688 av_init_packet(&pkt);
689 pkt.stream_index = ost->index;
690 pkt.data = subtitle_out;
691 pkt.size = subtitle_out_size;
692 pkt.pts = av_rescale_q(pts, ist->st->time_base, ost->st->time_base);
693 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
694 /* XXX: the pts correction is handled here. Maybe handling
695 it in the codec would be better */
697 pkt.pts += 90 * sub->start_display_time;
699 pkt.pts += 90 * sub->end_display_time;
701 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
705 static int bit_buffer_size= 1024*256;
706 static uint8_t *bit_buffer= NULL;
708 static void do_video_out(AVFormatContext *s,
714 int nb_frames, i, ret;
715 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
716 AVFrame picture_crop_temp, picture_pad_temp;
717 AVCodecContext *enc, *dec;
719 avcodec_get_frame_defaults(&picture_crop_temp);
720 avcodec_get_frame_defaults(&picture_pad_temp);
722 enc = ost->st->codec;
723 dec = ist->st->codec;
725 /* by default, we output a single frame */
730 if(video_sync_method){
732 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
733 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
736 else if (video_sync_method == 2)
737 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
738 else if (vdelta > 1.1)
739 nb_frames = lrintf(vdelta);
740 //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);
744 fprintf(stderr, "*** drop!\n");
745 }else if (nb_frames > 1) {
746 nb_frames_dup += nb_frames;
748 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
751 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
753 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
757 if (ost->video_crop) {
758 if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
759 av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
762 formatted_picture = &picture_crop_temp;
764 formatted_picture = in_picture;
767 final_picture = formatted_picture;
768 padding_src = formatted_picture;
769 resampling_dst = &ost->pict_tmp;
770 if (ost->video_pad) {
771 final_picture = &ost->pict_tmp;
772 if (ost->video_resample) {
773 if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
774 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
777 resampling_dst = &picture_pad_temp;
781 if (ost->video_resample) {
783 final_picture = &ost->pict_tmp;
784 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
785 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
788 if (ost->video_pad) {
789 av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
790 enc->height, enc->width, enc->pix_fmt,
791 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
794 /* duplicates frame if needed */
795 for(i=0;i<nb_frames;i++) {
797 av_init_packet(&pkt);
798 pkt.stream_index= ost->index;
800 if (s->oformat->flags & AVFMT_RAWPICTURE) {
801 /* raw pictures are written as AVPicture structure to
802 avoid any copies. We support temorarily the older
804 AVFrame* old_frame = enc->coded_frame;
805 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
806 pkt.data= (uint8_t *)final_picture;
807 pkt.size= sizeof(AVPicture);
808 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
809 pkt.flags |= PKT_FLAG_KEY;
811 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
812 enc->coded_frame = old_frame;
816 big_picture= *final_picture;
817 /* better than nothing: use input picture interlaced
819 big_picture.interlaced_frame = in_picture->interlaced_frame;
820 if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
821 if(top_field_first == -1)
822 big_picture.top_field_first = in_picture->top_field_first;
824 big_picture.top_field_first = top_field_first;
827 /* handles sameq here. This is not correct because it may
828 not be a global option */
830 big_picture.quality = ist->st->quality;
832 big_picture.quality = ost->st->quality;
834 big_picture.pict_type = 0;
835 // big_picture.pts = AV_NOPTS_VALUE;
836 big_picture.pts= ost->sync_opts;
837 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
838 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
839 ret = avcodec_encode_video(enc,
840 bit_buffer, bit_buffer_size,
843 fprintf(stderr, "Video encoding failed\n");
846 //enc->frame_number = enc->real_pict_num;
848 pkt.data= bit_buffer;
850 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
851 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
852 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
853 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
854 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
856 if(enc->coded_frame && enc->coded_frame->key_frame)
857 pkt.flags |= PKT_FLAG_KEY;
858 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
860 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
861 // enc->frame_number-1, enc->real_pict_num, ret,
863 /* if two pass, output log */
864 if (ost->logfile && enc->stats_out) {
865 fprintf(ost->logfile, "%s", enc->stats_out);
874 static double psnr(double d){
875 return -10.0*log(d)/log(10.0);
878 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
883 double ti1, bitrate, avg_bitrate;
885 /* this is executed just the first time do_video_stats is called */
887 vstats_file = fopen(vstats_filename, "w");
894 enc = ost->st->codec;
895 if (enc->codec_type == CODEC_TYPE_VIDEO) {
896 frame_number = ost->frame_number;
897 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
898 if (enc->flags&CODEC_FLAG_PSNR)
899 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
901 fprintf(vstats_file,"f_size= %6d ", frame_size);
902 /* compute pts value */
903 ti1 = ost->sync_opts * av_q2d(enc->time_base);
907 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
908 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
909 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
910 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
911 fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
915 static void print_report(AVFormatContext **output_files,
916 AVOutputStream **ost_table, int nb_ostreams,
921 AVFormatContext *oc, *os;
924 int frame_number, vid, i;
925 double bitrate, ti1, pts;
926 static int64_t last_time = -1;
927 static int qp_histogram[52];
929 if (!is_last_report) {
931 /* display the report every 0.5 seconds */
932 cur_time = av_gettime();
933 if (last_time == -1) {
934 last_time = cur_time;
937 if ((cur_time - last_time) < 500000)
939 last_time = cur_time;
943 oc = output_files[0];
945 total_size = url_fsize(oc->pb);
946 if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
947 total_size= url_ftell(oc->pb);
952 for(i=0;i<nb_ostreams;i++) {
954 os = output_files[ost->file_index];
955 enc = ost->st->codec;
956 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
957 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
958 enc->coded_frame && !ost->st->stream_copy ?
959 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
961 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
962 float t = (av_gettime()-timer_start) / 1000000.0;
964 frame_number = ost->frame_number;
965 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
966 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
967 enc->coded_frame && !ost->st->stream_copy ?
968 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
970 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
971 if(qp_hist && enc->coded_frame){
973 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
974 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
977 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
979 if (enc->flags&CODEC_FLAG_PSNR){
981 double error, error_sum=0;
982 double scale, scale_sum=0;
983 char type[3]= {'Y','U','V'};
984 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
987 error= enc->error[j];
988 scale= enc->width*enc->height*255.0*255.0*frame_number;
990 error= enc->coded_frame->error[j];
991 scale= enc->width*enc->height*255.0*255.0;
996 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
998 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1002 /* compute min output value */
1003 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1004 if ((pts < ti1) && (pts > 0))
1010 if (verbose || is_last_report) {
1011 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1013 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1014 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1015 (double)total_size / 1024, ti1, bitrate);
1018 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1019 nb_frames_dup, nb_frames_drop);
1022 fprintf(stderr, "%s \r", buf);
1027 if (is_last_report && verbose >= 0){
1028 int64_t raw= audio_size + video_size + extra_size;
1029 fprintf(stderr, "\n");
1030 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1034 100.0*(total_size - raw)/raw
1039 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1040 static int output_packet(AVInputStream *ist, int ist_index,
1041 AVOutputStream **ost_table, int nb_ostreams,
1042 const AVPacket *pkt)
1044 AVFormatContext *os;
1045 AVOutputStream *ost;
1049 int data_size, got_picture;
1051 void *buffer_to_free;
1052 static unsigned int samples_size= 0;
1053 static short *samples= NULL;
1054 AVSubtitle subtitle, *subtitle_to_free;
1057 if(ist->next_pts == AV_NOPTS_VALUE)
1058 ist->next_pts= ist->pts;
1067 if(pkt->dts != AV_NOPTS_VALUE)
1068 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1074 ist->pts= ist->next_pts;
1076 if(len && len != pkt->size && verbose>0)
1077 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1079 /* decode the packet if needed */
1080 data_buf = NULL; /* fail safe */
1082 subtitle_to_free = NULL;
1083 if (ist->decoding_needed) {
1084 switch(ist->st->codec->codec_type) {
1085 case CODEC_TYPE_AUDIO:{
1087 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE));
1088 data_size= samples_size;
1089 /* XXX: could avoid copy if PCM 16 bits with same
1090 endianness as CPU */
1091 ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1097 /* Some bug in mpeg audio decoder gives */
1098 /* data_size < 0, it seems they are overflows */
1099 if (data_size <= 0) {
1100 /* no audio frame */
1103 data_buf = (uint8_t *)samples;
1104 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1105 (ist->st->codec->sample_rate * ist->st->codec->channels);
1107 case CODEC_TYPE_VIDEO:
1108 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1109 /* XXX: allocate picture correctly */
1110 avcodec_get_frame_defaults(&picture);
1112 ret = avcodec_decode_video(ist->st->codec,
1113 &picture, &got_picture, ptr, len);
1114 ist->st->quality= picture.quality;
1118 /* no picture yet */
1119 goto discard_packet;
1121 if (ist->st->codec->time_base.num != 0) {
1122 ist->next_pts += ((int64_t)AV_TIME_BASE *
1123 ist->st->codec->time_base.num) /
1124 ist->st->codec->time_base.den;
1128 case CODEC_TYPE_SUBTITLE:
1129 ret = avcodec_decode_subtitle(ist->st->codec,
1130 &subtitle, &got_subtitle, ptr, len);
1133 if (!got_subtitle) {
1134 goto discard_packet;
1136 subtitle_to_free = &subtitle;
1143 switch(ist->st->codec->codec_type) {
1144 case CODEC_TYPE_AUDIO:
1145 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1146 ist->st->codec->sample_rate;
1148 case CODEC_TYPE_VIDEO:
1149 if (ist->st->codec->time_base.num != 0) {
1150 ist->next_pts += ((int64_t)AV_TIME_BASE *
1151 ist->st->codec->time_base.num) /
1152 ist->st->codec->time_base.den;
1162 buffer_to_free = NULL;
1163 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1164 pre_process_video_frame(ist, (AVPicture *)&picture,
1168 // preprocess audio (volume)
1169 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1170 if (audio_volume != 256) {
1173 for(i=0;i<(data_size / sizeof(short));i++) {
1174 int v = ((*volp) * audio_volume + 128) >> 8;
1175 if (v < -32768) v = -32768;
1176 if (v > 32767) v = 32767;
1182 /* frame rate emulation */
1183 if (ist->st->codec->rate_emu) {
1184 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1185 int64_t now = av_gettime() - ist->start;
1193 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1194 is the one of the next displayed one */
1195 /* XXX: add mpeg4 too ? */
1196 if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1197 if (ist->st->codec->pict_type != B_TYPE) {
1199 tmp = ist->last_ip_pts;
1200 ist->last_ip_pts = ist->frac_pts.val;
1201 ist->frac_pts.val = tmp;
1205 /* if output time reached then transcode raw format,
1206 encode packets and output them */
1207 if (start_time == 0 || ist->pts >= start_time)
1208 for(i=0;i<nb_ostreams;i++) {
1212 if (ost->source_index == ist_index) {
1213 os = output_files[ost->file_index];
1216 printf("%d: got pts=%0.3f %0.3f\n", i,
1217 (double)pkt->pts / AV_TIME_BASE,
1218 ((double)ist->pts / AV_TIME_BASE) -
1219 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1221 /* set the input output pts pairs */
1222 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1224 if (ost->encoding_needed) {
1225 switch(ost->st->codec->codec_type) {
1226 case CODEC_TYPE_AUDIO:
1227 do_audio_out(os, ost, ist, data_buf, data_size);
1229 case CODEC_TYPE_VIDEO:
1230 do_video_out(os, ost, ist, &picture, &frame_size);
1231 video_size += frame_size;
1232 if (vstats_filename && frame_size)
1233 do_video_stats(os, ost, frame_size);
1235 case CODEC_TYPE_SUBTITLE:
1236 do_subtitle_out(os, ost, ist, &subtitle,
1243 AVFrame avframe; //FIXME/XXX remove this
1245 av_init_packet(&opkt);
1247 if (!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY))
1250 /* no reencoding needed : output the packet directly */
1251 /* force the input stream PTS */
1253 avcodec_get_frame_defaults(&avframe);
1254 ost->st->codec->coded_frame= &avframe;
1255 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1257 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1258 audio_size += data_size;
1259 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1260 video_size += data_size;
1264 opkt.stream_index= ost->index;
1265 if(pkt->pts != AV_NOPTS_VALUE)
1266 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1268 opkt.pts= AV_NOPTS_VALUE;
1270 if (pkt->dts == AV_NOPTS_VALUE)
1271 opkt.dts = av_rescale_q(ist->next_pts, AV_TIME_BASE_Q, ost->st->time_base);
1273 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1275 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1276 opkt.flags= pkt->flags;
1278 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1279 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1280 opkt.destruct= av_destruct_packet;
1282 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1283 ost->st->codec->frame_number++;
1284 ost->frame_number++;
1285 av_free_packet(&opkt);
1289 av_free(buffer_to_free);
1290 /* XXX: allocate the subtitles in the codec ? */
1291 if (subtitle_to_free) {
1292 if (subtitle_to_free->rects != NULL) {
1293 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1294 av_free(subtitle_to_free->rects[i].bitmap);
1295 av_free(subtitle_to_free->rects[i].rgba_palette);
1297 av_freep(&subtitle_to_free->rects);
1299 subtitle_to_free->num_rects = 0;
1300 subtitle_to_free = NULL;
1307 for(i=0;i<nb_ostreams;i++) {
1309 if (ost->source_index == ist_index) {
1310 AVCodecContext *enc= ost->st->codec;
1311 os = output_files[ost->file_index];
1313 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1315 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1318 if (ost->encoding_needed) {
1322 av_init_packet(&pkt);
1323 pkt.stream_index= ost->index;
1325 switch(ost->st->codec->codec_type) {
1326 case CODEC_TYPE_AUDIO:
1327 fifo_bytes = av_fifo_size(&ost->fifo);
1329 /* encode any samples remaining in fifo */
1330 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1331 int fs_tmp = enc->frame_size;
1332 enc->frame_size = fifo_bytes / (2 * enc->channels);
1333 if(av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes) == 0) {
1334 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1336 enc->frame_size = fs_tmp;
1339 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1342 pkt.flags |= PKT_FLAG_KEY;
1344 case CODEC_TYPE_VIDEO:
1345 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1347 if(enc->coded_frame && enc->coded_frame->key_frame)
1348 pkt.flags |= PKT_FLAG_KEY;
1349 if (ost->logfile && enc->stats_out) {
1350 fprintf(ost->logfile, "%s", enc->stats_out);
1359 pkt.data= bit_buffer;
1361 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1362 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1363 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1375 static void print_sdp(AVFormatContext **avc, int n)
1379 avf_sdp_create(avc, n, sdp, sizeof(sdp));
1380 printf("SDP:\n%s\n", sdp);
1383 static int stream_index_from_inputs(AVFormatContext **input_files,
1385 AVInputFile *file_table,
1386 AVInputStream **ist_table,
1387 enum CodecType type,
1391 for(z=0; z<nb_input_files; z++) {
1392 AVFormatContext *ic = input_files[z];
1393 for(p=0; p<ic->nb_programs; p++) {
1394 AVProgram *program = ic->programs[p];
1395 if(program->id != programid)
1397 for(q=0; q<program->nb_stream_indexes; q++) {
1398 int sidx = program->stream_index[q];
1399 int ris = file_table[z].ist_index + sidx;
1400 if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1410 * The following code is the main loop of the file converter
1412 static int av_encode(AVFormatContext **output_files,
1413 int nb_output_files,
1414 AVFormatContext **input_files,
1416 AVStreamMap *stream_maps, int nb_stream_maps)
1418 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1419 AVFormatContext *is, *os;
1420 AVCodecContext *codec, *icodec;
1421 AVOutputStream *ost, **ost_table = NULL;
1422 AVInputStream *ist, **ist_table = NULL;
1423 AVInputFile *file_table;
1427 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1431 /* input stream init */
1433 for(i=0;i<nb_input_files;i++) {
1434 is = input_files[i];
1435 file_table[i].ist_index = j;
1436 file_table[i].nb_streams = is->nb_streams;
1437 j += is->nb_streams;
1441 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1445 for(i=0;i<nb_istreams;i++) {
1446 ist = av_mallocz(sizeof(AVInputStream));
1452 for(i=0;i<nb_input_files;i++) {
1453 is = input_files[i];
1454 for(k=0;k<is->nb_streams;k++) {
1455 ist = ist_table[j++];
1456 ist->st = is->streams[k];
1457 ist->file_index = i;
1459 ist->discard = 1; /* the stream is discarded by default
1462 if (ist->st->codec->rate_emu) {
1463 ist->start = av_gettime();
1469 /* output stream init */
1471 for(i=0;i<nb_output_files;i++) {
1472 os = output_files[i];
1473 if (!os->nb_streams) {
1474 fprintf(stderr, "Output file does not contain any stream\n");
1477 nb_ostreams += os->nb_streams;
1479 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1480 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1484 /* Sanity check the mapping args -- do the input files & streams exist? */
1485 for(i=0;i<nb_stream_maps;i++) {
1486 int fi = stream_maps[i].file_index;
1487 int si = stream_maps[i].stream_index;
1489 if (fi < 0 || fi > nb_input_files - 1 ||
1490 si < 0 || si > file_table[fi].nb_streams - 1) {
1491 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1494 fi = stream_maps[i].sync_file_index;
1495 si = stream_maps[i].sync_stream_index;
1496 if (fi < 0 || fi > nb_input_files - 1 ||
1497 si < 0 || si > file_table[fi].nb_streams - 1) {
1498 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1503 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1506 for(i=0;i<nb_ostreams;i++) {
1507 ost = av_mallocz(sizeof(AVOutputStream));
1514 for(k=0;k<nb_output_files;k++) {
1515 os = output_files[k];
1516 for(i=0;i<os->nb_streams;i++) {
1518 ost = ost_table[n++];
1519 ost->file_index = k;
1521 ost->st = os->streams[i];
1522 if (nb_stream_maps > 0) {
1523 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1524 stream_maps[n-1].stream_index;
1526 /* Sanity check that the stream types match */
1527 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1528 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1529 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1530 ost->file_index, ost->index);
1537 j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1539 ost->source_index = j;
1543 /* get corresponding input stream index : we select the first one with the right type */
1545 for(j=0;j<nb_istreams;j++) {
1548 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1549 ost->source_index = j;
1557 if(! opt_programid) {
1558 /* try again and reuse existing stream */
1559 for(j=0;j<nb_istreams;j++) {
1561 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1562 ost->source_index = j;
1568 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1569 ost->file_index, ost->index);
1574 ist = ist_table[ost->source_index];
1576 ost->sync_ist = (nb_stream_maps > 0) ?
1577 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1578 stream_maps[n-1].sync_stream_index] : ist;
1582 /* for each output stream, we compute the right encoding parameters */
1583 for(i=0;i<nb_ostreams;i++) {
1585 os = output_files[ost->file_index];
1586 ist = ist_table[ost->source_index];
1588 codec = ost->st->codec;
1589 icodec = ist->st->codec;
1591 if (!ost->st->language[0])
1592 av_strlcpy(ost->st->language, ist->st->language,
1593 sizeof(ost->st->language));
1595 ost->st->disposition = ist->st->disposition;
1597 if (ost->st->stream_copy) {
1598 /* if stream_copy is selected, no need to decode or encode */
1599 codec->codec_id = icodec->codec_id;
1600 codec->codec_type = icodec->codec_type;
1602 if(!codec->codec_tag){
1603 if( !os->oformat->codec_tag
1604 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1605 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1606 codec->codec_tag = icodec->codec_tag;
1609 codec->bit_rate = icodec->bit_rate;
1610 codec->extradata= icodec->extradata;
1611 codec->extradata_size= icodec->extradata_size;
1612 if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1613 codec->time_base = icodec->time_base;
1615 codec->time_base = ist->st->time_base;
1616 switch(codec->codec_type) {
1617 case CODEC_TYPE_AUDIO:
1618 codec->sample_rate = icodec->sample_rate;
1619 codec->channels = icodec->channels;
1620 codec->frame_size = icodec->frame_size;
1621 codec->block_align= icodec->block_align;
1622 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1623 codec->block_align= 0;
1625 case CODEC_TYPE_VIDEO:
1627 fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1630 codec->pix_fmt = icodec->pix_fmt;
1631 codec->width = icodec->width;
1632 codec->height = icodec->height;
1633 codec->has_b_frames = icodec->has_b_frames;
1635 case CODEC_TYPE_SUBTITLE:
1641 switch(codec->codec_type) {
1642 case CODEC_TYPE_AUDIO:
1643 if (av_fifo_init(&ost->fifo, 1024))
1645 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1646 icodec->request_channels = codec->channels;
1647 ist->decoding_needed = 1;
1648 ost->encoding_needed = 1;
1650 case CODEC_TYPE_VIDEO:
1651 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1652 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1653 ost->video_resample = ((codec->width != icodec->width -
1654 (frame_leftBand + frame_rightBand) +
1655 (frame_padleft + frame_padright)) ||
1656 (codec->height != icodec->height -
1657 (frame_topBand + frame_bottomBand) +
1658 (frame_padtop + frame_padbottom)) ||
1659 (codec->pix_fmt != icodec->pix_fmt));
1660 if (ost->video_crop) {
1661 ost->topBand = frame_topBand;
1662 ost->leftBand = frame_leftBand;
1664 if (ost->video_pad) {
1665 ost->padtop = frame_padtop;
1666 ost->padleft = frame_padleft;
1667 ost->padbottom = frame_padbottom;
1668 ost->padright = frame_padright;
1669 if (!ost->video_resample) {
1670 avcodec_get_frame_defaults(&ost->pict_tmp);
1671 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1672 codec->width, codec->height ) )
1676 if (ost->video_resample) {
1677 avcodec_get_frame_defaults(&ost->pict_tmp);
1678 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1679 codec->width, codec->height ) ) {
1680 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1683 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1684 ost->img_resample_ctx = sws_getContext(
1685 icodec->width - (frame_leftBand + frame_rightBand),
1686 icodec->height - (frame_topBand + frame_bottomBand),
1688 codec->width - (frame_padleft + frame_padright),
1689 codec->height - (frame_padtop + frame_padbottom),
1691 sws_flags, NULL, NULL, NULL);
1692 if (ost->img_resample_ctx == NULL) {
1693 fprintf(stderr, "Cannot get resampling context\n");
1696 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1698 ost->encoding_needed = 1;
1699 ist->decoding_needed = 1;
1701 case CODEC_TYPE_SUBTITLE:
1702 ost->encoding_needed = 1;
1703 ist->decoding_needed = 1;
1710 if (ost->encoding_needed &&
1711 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1712 char logfilename[1024];
1717 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1719 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1720 if (codec->flags & CODEC_FLAG_PASS1) {
1721 f = fopen(logfilename, "w");
1723 perror(logfilename);
1728 /* read the log file */
1729 f = fopen(logfilename, "r");
1731 perror(logfilename);
1734 fseek(f, 0, SEEK_END);
1736 fseek(f, 0, SEEK_SET);
1737 logbuffer = av_malloc(size + 1);
1739 fprintf(stderr, "Could not allocate log buffer\n");
1742 size = fread(logbuffer, 1, size, f);
1744 logbuffer[size] = '\0';
1745 codec->stats_in = logbuffer;
1749 if(codec->codec_type == CODEC_TYPE_VIDEO){
1750 int size= codec->width * codec->height;
1751 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1756 bit_buffer = av_malloc(bit_buffer_size);
1760 /* dump the file output parameters - cannot be done before in case
1762 for(i=0;i<nb_output_files;i++) {
1763 dump_format(output_files[i], i, output_files[i]->filename, 1);
1766 /* dump the stream mapping */
1768 fprintf(stderr, "Stream mapping:\n");
1769 for(i=0;i<nb_ostreams;i++) {
1771 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1772 ist_table[ost->source_index]->file_index,
1773 ist_table[ost->source_index]->index,
1776 if (ost->sync_ist != ist_table[ost->source_index])
1777 fprintf(stderr, " [sync #%d.%d]",
1778 ost->sync_ist->file_index,
1779 ost->sync_ist->index);
1780 fprintf(stderr, "\n");
1784 /* open each encoder */
1785 for(i=0;i<nb_ostreams;i++) {
1787 if (ost->encoding_needed) {
1789 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1791 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1792 ost->file_index, ost->index);
1795 if (avcodec_open(ost->st->codec, codec) < 0) {
1796 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1797 ost->file_index, ost->index);
1800 extra_size += ost->st->codec->extradata_size;
1804 /* open each decoder */
1805 for(i=0;i<nb_istreams;i++) {
1807 if (ist->decoding_needed) {
1809 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1811 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1812 ist->st->codec->codec_id, ist->file_index, ist->index);
1815 if (avcodec_open(ist->st->codec, codec) < 0) {
1816 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1817 ist->file_index, ist->index);
1820 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1821 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1826 for(i=0;i<nb_istreams;i++) {
1828 is = input_files[ist->file_index];
1830 ist->next_pts = AV_NOPTS_VALUE;
1834 /* set meta data information from input file if required */
1835 for (i=0;i<nb_meta_data_maps;i++) {
1836 AVFormatContext *out_file;
1837 AVFormatContext *in_file;
1839 int out_file_index = meta_data_maps[i].out_file;
1840 int in_file_index = meta_data_maps[i].in_file;
1841 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1842 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1843 ret = AVERROR(EINVAL);
1846 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1847 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1848 ret = AVERROR(EINVAL);
1852 out_file = output_files[out_file_index];
1853 in_file = input_files[in_file_index];
1855 strcpy(out_file->title, in_file->title);
1856 strcpy(out_file->author, in_file->author);
1857 strcpy(out_file->copyright, in_file->copyright);
1858 strcpy(out_file->comment, in_file->comment);
1859 strcpy(out_file->album, in_file->album);
1860 out_file->year = in_file->year;
1861 out_file->track = in_file->track;
1862 strcpy(out_file->genre, in_file->genre);
1865 /* open files and write file headers */
1866 for(i=0;i<nb_output_files;i++) {
1867 os = output_files[i];
1868 if (av_write_header(os) < 0) {
1869 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1870 ret = AVERROR(EINVAL);
1873 if (strcmp(output_files[i]->oformat->name, "rtp")) {
1878 print_sdp(output_files, nb_output_files);
1881 if ( !using_stdin && verbose >= 0) {
1882 fprintf(stderr, "Press [q] to stop encoding\n");
1883 url_set_interrupt_cb(decode_interrupt_cb);
1888 timer_start = av_gettime();
1890 for(; received_sigterm == 0;) {
1891 int file_index, ist_index;
1899 /* if 'q' pressed, exits */
1903 /* read_key() returns 0 on EOF */
1909 /* select the stream that we must read now by looking at the
1910 smallest output pts */
1912 for(i=0;i<nb_ostreams;i++) {
1915 os = output_files[ost->file_index];
1916 ist = ist_table[ost->source_index];
1917 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1918 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1920 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1921 ipts = (double)ist->pts;
1922 if (!file_table[ist->file_index].eof_reached){
1923 if(ipts < ipts_min) {
1925 if(input_sync ) file_index = ist->file_index;
1927 if(opts < opts_min) {
1929 if(!input_sync) file_index = ist->file_index;
1932 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1937 /* if none, if is finished */
1938 if (file_index < 0) {
1942 /* finish if recording time exhausted */
1943 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1946 /* finish if limit size exhausted */
1947 if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
1950 /* read a frame from it and output it in the fifo */
1951 is = input_files[file_index];
1952 if (av_read_frame(is, &pkt) < 0) {
1953 file_table[file_index].eof_reached = 1;
1961 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
1963 /* the following test is needed in case new streams appear
1964 dynamically in stream : we ignore them */
1965 if (pkt.stream_index >= file_table[file_index].nb_streams)
1966 goto discard_packet;
1967 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1968 ist = ist_table[ist_index];
1970 goto discard_packet;
1972 if (pkt.dts != AV_NOPTS_VALUE)
1973 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
1974 if (pkt.pts != AV_NOPTS_VALUE)
1975 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
1977 // 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);
1978 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1979 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
1980 int64_t delta= pkt_dts - ist->next_pts;
1981 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
1982 input_files_ts_offset[ist->file_index]-= delta;
1984 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1985 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
1986 if(pkt.pts != AV_NOPTS_VALUE)
1987 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
1991 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1992 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1995 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1996 ist->file_index, ist->index);
1998 av_free_packet(&pkt);
2003 av_free_packet(&pkt);
2005 /* dump report by using the output first video and audio streams */
2006 print_report(output_files, ost_table, nb_ostreams, 0);
2009 /* at the end of stream, we must flush the decoder buffers */
2010 for(i=0;i<nb_istreams;i++) {
2012 if (ist->decoding_needed) {
2013 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2019 /* write the trailer if needed and close file */
2020 for(i=0;i<nb_output_files;i++) {
2021 os = output_files[i];
2022 av_write_trailer(os);
2025 /* dump report by using the first video and audio streams */
2026 print_report(output_files, ost_table, nb_ostreams, 1);
2028 /* close each encoder */
2029 for(i=0;i<nb_ostreams;i++) {
2031 if (ost->encoding_needed) {
2032 av_freep(&ost->st->codec->stats_in);
2033 avcodec_close(ost->st->codec);
2037 /* close each decoder */
2038 for(i=0;i<nb_istreams;i++) {
2040 if (ist->decoding_needed) {
2041 avcodec_close(ist->st->codec);
2049 av_freep(&bit_buffer);
2050 av_free(file_table);
2053 for(i=0;i<nb_istreams;i++) {
2060 for(i=0;i<nb_ostreams;i++) {
2064 fclose(ost->logfile);
2065 ost->logfile = NULL;
2067 av_fifo_free(&ost->fifo); /* works even if fifo is not
2068 initialized but set to zero */
2069 av_free(ost->pict_tmp.data[0]);
2070 if (ost->video_resample)
2071 sws_freeContext(ost->img_resample_ctx);
2073 audio_resample_close(ost->resample);
2081 ret = AVERROR(ENOMEM);
2086 int file_read(const char *filename)
2089 unsigned char buffer[1024];
2092 if (url_open(&h, filename, O_RDONLY) < 0) {
2093 printf("could not open '%s'\n", filename);
2097 len = url_read(h, buffer, sizeof(buffer));
2100 for(i=0;i<len;i++) putchar(buffer[i]);
2107 static void opt_format(const char *arg)
2109 /* compatibility stuff for pgmyuv */
2110 if (!strcmp(arg, "pgmyuv")) {
2111 pgmyuv_compatibility_hack=1;
2112 // opt_image_format(arg);
2114 fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2117 file_iformat = av_find_input_format(arg);
2118 file_oformat = guess_format(arg, NULL, NULL);
2119 if (!file_iformat && !file_oformat) {
2120 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2125 extern int ffm_nopts;
2127 static int opt_default(const char *opt, const char *arg){
2129 const AVOption *o= NULL;
2130 int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
2132 for(type=0; type<CODEC_TYPE_NB; type++){
2133 const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
2135 o = av_set_string(avctx_opts[type], opt, arg);
2138 o = av_set_string(avformat_opts, opt, arg);
2140 o = av_set_string(sws_opts, opt, arg);
2143 o = av_set_string(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg);
2144 else if(opt[0] == 'v')
2145 o = av_set_string(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg);
2146 else if(opt[0] == 's')
2147 o = av_set_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg);
2152 // 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));
2154 //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
2155 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
2156 opt_names[opt_name_count++]= o->name;
2158 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
2159 /* disable generate of real time pts in ffm (need to be supressed anyway) */
2160 if(avctx_opts[0]->flags & CODEC_FLAG_BITEXACT)
2164 if(avctx_opts[0]->debug)
2165 av_log_set_level(AV_LOG_DEBUG);
2169 static void opt_video_rc_override_string(const char *arg)
2171 video_rc_override_string = arg;
2174 static void opt_me_threshold(const char *arg)
2176 me_threshold = atoi(arg);
2179 static void opt_verbose(const char *arg)
2181 verbose = atoi(arg);
2182 av_log_set_level(verbose);
2185 static void opt_frame_rate(const char *arg)
2187 if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2188 fprintf(stderr, "Incorrect frame rate\n");
2193 static int opt_bitrate(const char *opt, const char *arg)
2195 int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2197 opt_default(opt, arg);
2199 if (av_get_int(avctx_opts[codec_type], "b", NULL) < 1000)
2200 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2205 static void opt_frame_crop_top(const char *arg)
2207 frame_topBand = atoi(arg);
2208 if (frame_topBand < 0) {
2209 fprintf(stderr, "Incorrect top crop size\n");
2212 if ((frame_topBand % 2) != 0) {
2213 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2216 if ((frame_topBand) >= frame_height){
2217 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2220 frame_height -= frame_topBand;
2223 static void opt_frame_crop_bottom(const char *arg)
2225 frame_bottomBand = atoi(arg);
2226 if (frame_bottomBand < 0) {
2227 fprintf(stderr, "Incorrect bottom crop size\n");
2230 if ((frame_bottomBand % 2) != 0) {
2231 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2234 if ((frame_bottomBand) >= frame_height){
2235 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2238 frame_height -= frame_bottomBand;
2241 static void opt_frame_crop_left(const char *arg)
2243 frame_leftBand = atoi(arg);
2244 if (frame_leftBand < 0) {
2245 fprintf(stderr, "Incorrect left crop size\n");
2248 if ((frame_leftBand % 2) != 0) {
2249 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2252 if ((frame_leftBand) >= frame_width){
2253 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2256 frame_width -= frame_leftBand;
2259 static void opt_frame_crop_right(const char *arg)
2261 frame_rightBand = atoi(arg);
2262 if (frame_rightBand < 0) {
2263 fprintf(stderr, "Incorrect right crop size\n");
2266 if ((frame_rightBand % 2) != 0) {
2267 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2270 if ((frame_rightBand) >= frame_width){
2271 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2274 frame_width -= frame_rightBand;
2277 static void opt_frame_size(const char *arg)
2279 if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2280 fprintf(stderr, "Incorrect frame size\n");
2283 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2284 fprintf(stderr, "Frame size must be a multiple of 2\n");
2290 #define SCALEBITS 10
2291 #define ONE_HALF (1 << (SCALEBITS - 1))
2292 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2294 #define RGB_TO_Y(r, g, b) \
2295 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2296 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2298 #define RGB_TO_U(r1, g1, b1, shift)\
2299 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2300 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2302 #define RGB_TO_V(r1, g1, b1, shift)\
2303 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2304 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2306 static void opt_pad_color(const char *arg) {
2307 /* Input is expected to be six hex digits similar to
2308 how colors are expressed in html tags (but without the #) */
2309 int rgb = strtol(arg, NULL, 16);
2313 g = ((rgb >> 8) & 255);
2316 padcolor[0] = RGB_TO_Y(r,g,b);
2317 padcolor[1] = RGB_TO_U(r,g,b,0);
2318 padcolor[2] = RGB_TO_V(r,g,b,0);
2321 static void opt_frame_pad_top(const char *arg)
2323 frame_padtop = atoi(arg);
2324 if (frame_padtop < 0) {
2325 fprintf(stderr, "Incorrect top pad size\n");
2328 if ((frame_padtop % 2) != 0) {
2329 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2334 static void opt_frame_pad_bottom(const char *arg)
2336 frame_padbottom = atoi(arg);
2337 if (frame_padbottom < 0) {
2338 fprintf(stderr, "Incorrect bottom pad size\n");
2341 if ((frame_padbottom % 2) != 0) {
2342 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2348 static void opt_frame_pad_left(const char *arg)
2350 frame_padleft = atoi(arg);
2351 if (frame_padleft < 0) {
2352 fprintf(stderr, "Incorrect left pad size\n");
2355 if ((frame_padleft % 2) != 0) {
2356 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2362 static void opt_frame_pad_right(const char *arg)
2364 frame_padright = atoi(arg);
2365 if (frame_padright < 0) {
2366 fprintf(stderr, "Incorrect right pad size\n");
2369 if ((frame_padright % 2) != 0) {
2370 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2375 void list_pix_fmts(void)
2378 char pix_fmt_str[128];
2379 for (i=-1; i < PIX_FMT_NB; i++) {
2380 avcodec_pix_fmt_string (pix_fmt_str, sizeof(pix_fmt_str), i);
2381 fprintf(stdout, "%s\n", pix_fmt_str);
2385 static void opt_frame_pix_fmt(const char *arg)
2387 if (strcmp(arg, "list"))
2388 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2395 static void opt_frame_aspect_ratio(const char *arg)
2402 p = strchr(arg, ':');
2404 x = strtol(arg, &end, 10);
2406 y = strtol(end+1, &end, 10);
2408 ar = (double)x / (double)y;
2410 ar = strtod(arg, NULL);
2413 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2416 frame_aspect_ratio = ar;
2419 static void opt_qscale(const char *arg)
2421 video_qscale = atof(arg);
2422 if (video_qscale <= 0 ||
2423 video_qscale > 255) {
2424 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2429 static void opt_qdiff(const char *arg)
2431 video_qdiff = atoi(arg);
2432 if (video_qdiff < 0 ||
2434 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2439 static void opt_strict(const char *arg)
2444 static void opt_top_field_first(const char *arg)
2446 top_field_first= atoi(arg);
2449 static void opt_thread_count(const char *arg)
2451 thread_count= atoi(arg);
2452 #if !defined(HAVE_THREADS)
2454 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2458 static void opt_audio_rate(const char *arg)
2460 audio_sample_rate = atoi(arg);
2463 static void opt_audio_channels(const char *arg)
2465 audio_channels = atoi(arg);
2468 static void opt_video_channel(const char *arg)
2470 video_channel = strtol(arg, NULL, 0);
2473 static void opt_video_standard(const char *arg)
2475 video_standard = av_strdup(arg);
2478 static void opt_codec(int *pstream_copy, char **pcodec_name,
2479 int codec_type, const char *arg)
2481 av_freep(pcodec_name);
2482 if (!strcmp(arg, "copy")) {
2485 *pcodec_name = av_strdup(arg);
2489 static void opt_audio_codec(const char *arg)
2491 opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2494 static void opt_audio_tag(const char *arg)
2497 audio_codec_tag= strtol(arg, &tail, 0);
2500 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2503 static void opt_video_tag(const char *arg)
2506 video_codec_tag= strtol(arg, &tail, 0);
2509 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2513 static void add_frame_hooker(const char *arg)
2518 char *args = av_strdup(arg);
2522 argv[0] = strtok(args, " ");
2523 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2526 i = frame_hook_add(argc, argv);
2529 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2535 static void opt_video_codec(const char *arg)
2537 opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2540 static void opt_subtitle_codec(const char *arg)
2542 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2545 static void opt_map(const char *arg)
2550 m = &stream_maps[nb_stream_maps++];
2552 m->file_index = strtol(arg, &p, 0);
2556 m->stream_index = strtol(p, &p, 0);
2559 m->sync_file_index = strtol(p, &p, 0);
2562 m->sync_stream_index = strtol(p, &p, 0);
2564 m->sync_file_index = m->file_index;
2565 m->sync_stream_index = m->stream_index;
2569 static void opt_map_meta_data(const char *arg)
2574 m = &meta_data_maps[nb_meta_data_maps++];
2576 m->out_file = strtol(arg, &p, 0);
2580 m->in_file = strtol(p, &p, 0);
2583 static int64_t parse_time_or_die(const char *timestr, int is_duration)
2585 int64_t us = parse_date(timestr, is_duration);
2586 if (us == INT64_MIN) {
2587 fprintf(stderr, "Invalid %s specification: %s\n",
2588 is_duration ? "duration" : "date", timestr);
2594 static void opt_recording_time(const char *arg)
2596 recording_time = parse_time_or_die(arg, 1);
2599 static void opt_start_time(const char *arg)
2601 start_time = parse_time_or_die(arg, 1);
2604 static void opt_rec_timestamp(const char *arg)
2606 rec_timestamp = parse_time_or_die(arg, 0) / 1000000;
2609 static void opt_input_ts_offset(const char *arg)
2611 input_ts_offset = parse_time_or_die(arg, 1);
2614 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2616 const char *codec_string = encoder ? "encoder" : "decoder";
2620 return CODEC_ID_NONE;
2622 avcodec_find_encoder_by_name(name) :
2623 avcodec_find_decoder_by_name(name);
2625 av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2628 if(codec->type != type) {
2629 av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2635 static void opt_input_file(const char *filename)
2637 AVFormatContext *ic;
2638 AVFormatParameters params, *ap = ¶ms;
2639 int err, i, ret, rfps, rfps_base;
2642 if (!strcmp(filename, "-"))
2645 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2646 !strcmp( filename, "/dev/stdin" );
2648 /* get default parameters from command line */
2649 ic = av_alloc_format_context();
2651 memset(ap, 0, sizeof(*ap));
2652 ap->prealloced_context = 1;
2653 ap->sample_rate = audio_sample_rate;
2654 ap->channels = audio_channels;
2655 ap->time_base.den = frame_rate.num;
2656 ap->time_base.num = frame_rate.den;
2657 ap->width = frame_width + frame_padleft + frame_padright;
2658 ap->height = frame_height + frame_padtop + frame_padbottom;
2659 ap->pix_fmt = frame_pix_fmt;
2660 ap->channel = video_channel;
2661 ap->standard = video_standard;
2662 ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2663 ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2664 if(pgmyuv_compatibility_hack)
2665 ap->video_codec_id= CODEC_ID_PGMYUV;
2667 for(i=0; i<opt_name_count; i++){
2669 const AVOption *opt;
2670 const char *str= av_get_string(avformat_opts, opt_names[i], &opt, buf, sizeof(buf));
2671 if(str && (opt->flags & AV_OPT_FLAG_DECODING_PARAM))
2672 av_set_string(ic, opt_names[i], str);
2675 ic->video_codec_id = find_codec_or_die(video_codec_name , CODEC_TYPE_VIDEO , 0);
2676 ic->audio_codec_id = find_codec_or_die(audio_codec_name , CODEC_TYPE_AUDIO , 0);
2677 ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2679 /* open the input file with generic libav function */
2680 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2682 print_error(filename, err);
2687 for(i=0; i<ic->nb_programs; i++)
2688 if(ic->programs[i]->id != opt_programid)
2689 ic->programs[i]->discard = AVDISCARD_ALL;
2692 ic->loop_input = loop_input;
2694 /* If not enough info to get the stream parameters, we decode the
2695 first frames to get it. (used in mpeg case for example) */
2696 ret = av_find_stream_info(ic);
2697 if (ret < 0 && verbose >= 0) {
2698 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2702 timestamp = start_time;
2703 /* add the stream start time */
2704 if (ic->start_time != AV_NOPTS_VALUE)
2705 timestamp += ic->start_time;
2707 /* if seeking requested, we execute it */
2708 if (start_time != 0) {
2709 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2711 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2712 filename, (double)timestamp / AV_TIME_BASE);
2714 /* reset seek info */
2718 /* update the current parameters so that they match the one of the input stream */
2719 for(i=0;i<ic->nb_streams;i++) {
2721 AVCodecContext *enc = ic->streams[i]->codec;
2723 avcodec_thread_init(enc, thread_count);
2724 enc->thread_count= thread_count;
2725 switch(enc->codec_type) {
2726 case CODEC_TYPE_AUDIO:
2727 for(j=0; j<opt_name_count; j++){
2729 const AVOption *opt;
2730 const char *str= av_get_string(avctx_opts[CODEC_TYPE_AUDIO], opt_names[j], &opt, buf, sizeof(buf));
2731 if(str && (opt->flags & AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags & AV_OPT_FLAG_DECODING_PARAM))
2732 av_set_string(enc, opt_names[j], str);
2734 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2735 audio_channels = enc->channels;
2736 audio_sample_rate = enc->sample_rate;
2738 ic->streams[i]->discard= AVDISCARD_ALL;
2740 case CODEC_TYPE_VIDEO:
2741 for(j=0; j<opt_name_count; j++){
2743 const AVOption *opt;
2744 const char *str= av_get_string(avctx_opts[CODEC_TYPE_VIDEO], opt_names[j], &opt, buf, sizeof(buf));
2745 if(str && (opt->flags & AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags & AV_OPT_FLAG_DECODING_PARAM))
2746 av_set_string(enc, opt_names[j], str);
2748 frame_height = enc->height;
2749 frame_width = enc->width;
2750 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2751 frame_pix_fmt = enc->pix_fmt;
2752 rfps = ic->streams[i]->r_frame_rate.num;
2753 rfps_base = ic->streams[i]->r_frame_rate.den;
2754 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2756 enc->debug |= FF_DEBUG_MV;
2758 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2761 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2762 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2764 (float)rfps / rfps_base, rfps, rfps_base);
2766 /* update the current frame rate to match the stream frame rate */
2767 frame_rate.num = rfps;
2768 frame_rate.den = rfps_base;
2770 enc->rate_emu = rate_emu;
2772 ic->streams[i]->discard= AVDISCARD_ALL;
2773 else if(video_discard)
2774 ic->streams[i]->discard= video_discard;
2776 case CODEC_TYPE_DATA:
2778 case CODEC_TYPE_SUBTITLE:
2779 if(subtitle_disable)
2780 ic->streams[i]->discard = AVDISCARD_ALL;
2782 case CODEC_TYPE_ATTACHMENT:
2783 case CODEC_TYPE_UNKNOWN:
2790 input_files[nb_input_files] = ic;
2791 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2792 /* dump the file content */
2794 dump_format(ic, nb_input_files, filename, 0);
2797 file_iformat = NULL;
2798 file_oformat = NULL;
2803 av_freep(&video_codec_name);
2804 av_freep(&audio_codec_name);
2805 av_freep(&subtitle_codec_name);
2808 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2809 int *has_subtitle_ptr)
2811 int has_video, has_audio, has_subtitle, i, j;
2812 AVFormatContext *ic;
2817 for(j=0;j<nb_input_files;j++) {
2818 ic = input_files[j];
2819 for(i=0;i<ic->nb_streams;i++) {
2820 AVCodecContext *enc = ic->streams[i]->codec;
2821 switch(enc->codec_type) {
2822 case CODEC_TYPE_AUDIO:
2825 case CODEC_TYPE_VIDEO:
2828 case CODEC_TYPE_SUBTITLE:
2831 case CODEC_TYPE_DATA:
2832 case CODEC_TYPE_ATTACHMENT:
2833 case CODEC_TYPE_UNKNOWN:
2840 *has_video_ptr = has_video;
2841 *has_audio_ptr = has_audio;
2842 *has_subtitle_ptr = has_subtitle;
2845 static void new_video_stream(AVFormatContext *oc)
2848 AVCodecContext *video_enc;
2851 st = av_new_stream(oc, oc->nb_streams);
2853 fprintf(stderr, "Could not alloc stream\n");
2856 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2857 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2858 video_bitstream_filters= NULL;
2861 avcodec_thread_init(st->codec, thread_count);
2863 video_enc = st->codec;
2866 video_enc->codec_tag= video_codec_tag;
2868 if( (video_global_header&1)
2869 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2870 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2871 avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2873 if(video_global_header&2){
2874 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2875 avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2878 if (video_stream_copy) {
2879 st->stream_copy = 1;
2880 video_enc->codec_type = CODEC_TYPE_VIDEO;
2885 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
2887 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2888 if (video_codec_name)
2889 codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
2891 video_enc->codec_id = codec_id;
2892 codec = avcodec_find_encoder(codec_id);
2894 for(i=0; i<opt_name_count; i++){
2896 const AVOption *opt;
2897 const char *str= av_get_string(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt, buf, sizeof(buf));
2898 if(str && (opt->flags & AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
2899 av_set_string(video_enc, opt_names[i], str);
2902 video_enc->time_base.den = fps.num;
2903 video_enc->time_base.num = fps.den;
2904 if(codec && codec->supported_framerates){
2905 const AVRational *p= codec->supported_framerates;
2906 const AVRational *best=NULL;
2907 AVRational best_error= (AVRational){INT_MAX, 1};
2908 for(; p->den!=0; p++){
2909 AVRational error= av_sub_q(fps, *p);
2910 if(error.num <0) error.num *= -1;
2911 if(av_cmp_q(error, best_error) < 0){
2916 video_enc->time_base.den= best->num;
2917 video_enc->time_base.num= best->den;
2920 video_enc->width = frame_width + frame_padright + frame_padleft;
2921 video_enc->height = frame_height + frame_padtop + frame_padbottom;
2922 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2923 video_enc->pix_fmt = frame_pix_fmt;
2925 if(codec && codec->pix_fmts){
2926 const enum PixelFormat *p= codec->pix_fmts;
2928 if(*p == video_enc->pix_fmt)
2932 video_enc->pix_fmt = codec->pix_fmts[0];
2936 video_enc->gop_size = 0;
2937 if (video_qscale || same_quality) {
2938 video_enc->flags |= CODEC_FLAG_QSCALE;
2939 video_enc->global_quality=
2940 st->quality = FF_QP2LAMBDA * video_qscale;
2944 video_enc->intra_matrix = intra_matrix;
2946 video_enc->inter_matrix = inter_matrix;
2948 video_enc->max_qdiff = video_qdiff;
2949 video_enc->thread_count = thread_count;
2950 p= video_rc_override_string;
2953 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2955 fprintf(stderr, "error parsing rc_override\n");
2958 video_enc->rc_override=
2959 av_realloc(video_enc->rc_override,
2960 sizeof(RcOverride)*(i+1));
2961 video_enc->rc_override[i].start_frame= start;
2962 video_enc->rc_override[i].end_frame = end;
2964 video_enc->rc_override[i].qscale= q;
2965 video_enc->rc_override[i].quality_factor= 1.0;
2968 video_enc->rc_override[i].qscale= 0;
2969 video_enc->rc_override[i].quality_factor= -q/100.0;
2974 video_enc->rc_override_count=i;
2975 if (!video_enc->rc_initial_buffer_occupancy)
2976 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2977 video_enc->me_threshold= me_threshold;
2978 video_enc->intra_dc_precision= intra_dc_precision - 8;
2979 video_enc->strict_std_compliance = strict;
2982 video_enc->flags|= CODEC_FLAG_PSNR;
2987 video_enc->flags |= CODEC_FLAG_PASS1;
2989 video_enc->flags |= CODEC_FLAG_PASS2;
2994 /* reset some key parameters */
2996 av_freep(&video_codec_name);
2997 video_stream_copy = 0;
3000 static void new_audio_stream(AVFormatContext *oc)
3003 AVCodecContext *audio_enc;
3006 st = av_new_stream(oc, oc->nb_streams);
3008 fprintf(stderr, "Could not alloc stream\n");
3011 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3013 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3014 audio_bitstream_filters= NULL;
3017 avcodec_thread_init(st->codec, thread_count);
3019 audio_enc = st->codec;
3020 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3021 audio_enc->strict_std_compliance = strict;
3024 audio_enc->codec_tag= audio_codec_tag;
3026 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3027 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3028 avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3030 if (audio_stream_copy) {
3031 st->stream_copy = 1;
3032 audio_enc->channels = audio_channels;
3034 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3036 for(i=0; i<opt_name_count; i++){
3038 const AVOption *opt;
3039 const char *str= av_get_string(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt, buf, sizeof(buf));
3040 if(str && (opt->flags & AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3041 av_set_string(audio_enc, opt_names[i], str);
3044 if (audio_codec_name)
3045 codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3046 audio_enc->codec_id = codec_id;
3048 if (audio_qscale > QSCALE_NONE) {
3049 audio_enc->flags |= CODEC_FLAG_QSCALE;
3050 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3052 audio_enc->thread_count = thread_count;
3053 audio_enc->channels = audio_channels;
3055 audio_enc->sample_rate = audio_sample_rate;
3056 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3057 if (audio_language) {
3058 av_strlcpy(st->language, audio_language, sizeof(st->language));
3059 av_free(audio_language);
3060 audio_language = NULL;
3063 /* reset some key parameters */
3065 av_freep(&audio_codec_name);
3066 audio_stream_copy = 0;
3069 static void new_subtitle_stream(AVFormatContext *oc)
3072 AVCodecContext *subtitle_enc;
3075 st = av_new_stream(oc, oc->nb_streams);
3077 fprintf(stderr, "Could not alloc stream\n");
3080 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3082 bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3083 subtitle_bitstream_filters= NULL;
3085 subtitle_enc = st->codec;
3086 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3087 if (subtitle_stream_copy) {
3088 st->stream_copy = 1;
3090 for(i=0; i<opt_name_count; i++){
3092 const AVOption *opt;
3093 const char *str= av_get_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt_names[i], &opt, buf, sizeof(buf));
3094 if(str && (opt->flags & AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3095 av_set_string(subtitle_enc, opt_names[i], str);
3097 subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3100 if (subtitle_language) {
3101 av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3102 av_free(subtitle_language);
3103 subtitle_language = NULL;
3106 subtitle_disable = 0;
3107 av_freep(&subtitle_codec_name);
3108 subtitle_stream_copy = 0;
3111 static void opt_new_audio_stream(void)
3113 AVFormatContext *oc;
3114 if (nb_output_files <= 0) {
3115 fprintf(stderr, "At least one output file must be specified\n");
3118 oc = output_files[nb_output_files - 1];
3119 new_audio_stream(oc);
3122 static void opt_new_video_stream(void)
3124 AVFormatContext *oc;
3125 if (nb_output_files <= 0) {
3126 fprintf(stderr, "At least one output file must be specified\n");
3129 oc = output_files[nb_output_files - 1];
3130 new_video_stream(oc);
3133 static void opt_new_subtitle_stream(void)
3135 AVFormatContext *oc;
3136 if (nb_output_files <= 0) {
3137 fprintf(stderr, "At least one output file must be specified\n");
3140 oc = output_files[nb_output_files - 1];
3141 new_subtitle_stream(oc);
3144 static void opt_output_file(const char *filename)
3146 AVFormatContext *oc;
3147 int use_video, use_audio, use_subtitle;
3148 int input_has_video, input_has_audio, input_has_subtitle, i;
3149 AVFormatParameters params, *ap = ¶ms;
3151 if (!strcmp(filename, "-"))
3154 oc = av_alloc_format_context();
3156 if (!file_oformat) {
3157 file_oformat = guess_format(NULL, filename, NULL);
3158 if (!file_oformat) {
3159 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3165 oc->oformat = file_oformat;
3166 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3168 if (!strcmp(file_oformat->name, "ffm") &&
3169 av_strstart(filename, "http:", NULL)) {
3170 /* special case for files sent to ffserver: we get the stream
3171 parameters from ffserver */
3172 if (read_ffserver_streams(oc, filename) < 0) {
3173 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3177 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3178 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3179 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3181 /* disable if no corresponding type found and at least one
3183 if (nb_input_files > 0) {
3184 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3185 &input_has_subtitle);
3186 if (!input_has_video)
3188 if (!input_has_audio)
3190 if (!input_has_subtitle)
3194 /* manual disable */
3195 if (audio_disable) {
3198 if (video_disable) {
3201 if (subtitle_disable) {
3206 new_video_stream(oc);
3210 new_audio_stream(oc);
3214 new_subtitle_stream(oc);
3217 oc->timestamp = rec_timestamp;
3220 av_strlcpy(oc->title, str_title, sizeof(oc->title));
3222 av_strlcpy(oc->author, str_author, sizeof(oc->author));
3224 av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3226 av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3228 av_strlcpy(oc->album, str_album, sizeof(oc->album));
3230 av_strlcpy(oc->genre, str_genre, sizeof(oc->genre));
3233 output_files[nb_output_files++] = oc;
3235 /* check filename in case of an image number is expected */
3236 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3237 if (!av_filename_number_test(oc->filename)) {
3238 print_error(oc->filename, AVERROR_NUMEXPECTED);
3243 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3244 /* test if it already exists to avoid loosing precious files */
3245 if (!file_overwrite &&
3246 (strchr(filename, ':') == NULL ||
3247 filename[1] == ':' ||
3248 av_strstart(filename, "file:", NULL))) {
3249 if (url_exist(filename)) {
3252 if ( !using_stdin ) {
3253 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3256 if (toupper(c) != 'Y') {
3257 fprintf(stderr, "Not overwriting - exiting\n");
3262 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3269 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3270 fprintf(stderr, "Could not open '%s'\n", filename);
3275 memset(ap, 0, sizeof(*ap));
3276 if (av_set_parameters(oc, ap) < 0) {
3277 fprintf(stderr, "%s: Invalid encoding parameters\n",
3282 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3283 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3284 oc->loop_output = loop_output;
3286 for(i=0; i<opt_name_count; i++){
3288 const AVOption *opt;
3289 const char *str= av_get_string(avformat_opts, opt_names[i], &opt, buf, sizeof(buf));
3290 if(str && (opt->flags & AV_OPT_FLAG_ENCODING_PARAM))
3291 av_set_string(oc, opt_names[i], str);
3294 /* reset some options */
3295 file_oformat = NULL;
3296 file_iformat = NULL;
3299 /* same option as mencoder */
3300 static void opt_pass(const char *pass_str)
3303 pass = atoi(pass_str);
3304 if (pass != 1 && pass != 2) {
3305 fprintf(stderr, "pass number can be only 1 or 2\n");
3311 static int64_t getutime(void)
3313 #ifdef HAVE_GETRUSAGE
3314 struct rusage rusage;
3316 getrusage(RUSAGE_SELF, &rusage);
3317 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3318 #elif defined(HAVE_GETPROCESSTIMES)
3320 FILETIME c, e, k, u;
3321 proc = GetCurrentProcess();
3322 GetProcessTimes(proc, &c, &e, &k, &u);
3323 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3325 return av_gettime();
3329 static void opt_show_formats(void)
3331 AVInputFormat *ifmt=NULL;
3332 AVOutputFormat *ofmt=NULL;
3333 URLProtocol *up=NULL;
3334 AVCodec *p=NULL, *p2;
3335 AVBitStreamFilter *bsf=NULL;
3336 const char *last_name;
3338 printf("File formats:\n");
3343 const char *name=NULL;
3344 const char *long_name=NULL;
3346 while((ofmt= av_oformat_next(ofmt))) {
3347 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3348 strcmp(ofmt->name, last_name)>0){
3350 long_name= ofmt->long_name;
3354 while((ifmt= av_iformat_next(ifmt))) {
3355 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3356 strcmp(ifmt->name, last_name)>0){
3358 long_name= ifmt->long_name;
3361 if(name && strcmp(ifmt->name, name)==0)
3373 long_name ? long_name:" ");
3377 printf("Codecs:\n");
3383 const char *type_str;
3386 while((p= av_codec_next(p))) {
3387 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3388 strcmp(p->name, last_name)>0){
3390 decode= encode= cap=0;
3392 if(p2 && strcmp(p->name, p2->name)==0){
3393 if(p->decode) decode=1;
3394 if(p->encode) encode=1;
3395 cap |= p->capabilities;
3400 last_name= p2->name;
3403 case CODEC_TYPE_VIDEO:
3406 case CODEC_TYPE_AUDIO:
3409 case CODEC_TYPE_SUBTITLE:
3418 decode ? "D": (/*p2->decoder ? "d":*/" "),
3421 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3422 cap & CODEC_CAP_DR1 ? "D":" ",
3423 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3425 /* if(p2->decoder && decode==0)
3426 printf(" use %s for decoding", p2->decoder->name);*/
3431 printf("Bitstream filters:\n");
3432 while((bsf = av_bitstream_filter_next(bsf)))
3433 printf(" %s", bsf->name);
3436 printf("Supported file protocols:\n");
3437 while((up = av_protocol_next(up)))
3438 printf(" %s:", up->name);
3441 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3444 "Note, the names of encoders and decoders do not always match, so there are\n"
3445 "several cases where the above table shows encoder only or decoder only entries\n"
3446 "even though both encoding and decoding are supported. For example, the h263\n"
3447 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
3452 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3455 const char *p = str;
3462 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3469 static void opt_inter_matrix(const char *arg)
3471 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3472 parse_matrix_coeffs(inter_matrix, arg);
3475 static void opt_intra_matrix(const char *arg)
3477 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3478 parse_matrix_coeffs(intra_matrix, arg);
3482 * Trivial log callback.
3483 * Only suitable for show_help and similar since it lacks prefix handling.
3485 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3487 vfprintf(stdout, fmt, vl);
3490 static void show_help(void)
3492 av_log_set_callback(log_callback_help);
3493 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3494 "Hyper fast Audio and Video encoder\n");
3496 show_help_options(options, "Main options:\n",
3497 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3498 show_help_options(options, "\nVideo options:\n",
3499 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3501 show_help_options(options, "\nAdvanced Video options:\n",
3502 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3503 OPT_VIDEO | OPT_EXPERT);
3504 show_help_options(options, "\nAudio options:\n",
3505 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3507 show_help_options(options, "\nAdvanced Audio options:\n",
3508 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3509 OPT_AUDIO | OPT_EXPERT);
3510 show_help_options(options, "\nSubtitle options:\n",
3511 OPT_SUBTITLE | OPT_GRAB,
3513 show_help_options(options, "\nAudio/Video grab options:\n",
3516 show_help_options(options, "\nAdvanced options:\n",
3517 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3519 av_opt_show(avctx_opts[0], NULL);
3520 av_opt_show(avformat_opts, NULL);
3521 av_opt_show(sws_opts, NULL);
3524 static void opt_show_help(void)
3530 static void opt_target(const char *arg)
3533 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3535 if(!strncmp(arg, "pal-", 4)) {
3538 } else if(!strncmp(arg, "ntsc-", 5)) {
3541 } else if(!strncmp(arg, "film-", 5)) {
3546 /* Calculate FR via float to avoid int overflow */
3547 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3550 } else if((fr == 29970) || (fr == 23976)) {
3553 /* Try to determine PAL/NTSC by peeking in the input files */
3554 if(nb_input_files) {
3556 for(j = 0; j < nb_input_files; j++) {
3557 for(i = 0; i < input_files[j]->nb_streams; i++) {
3558 AVCodecContext *c = input_files[j]->streams[i]->codec;
3559 if(c->codec_type != CODEC_TYPE_VIDEO)
3561 fr = c->time_base.den * 1000 / c->time_base.num;
3565 } else if((fr == 29970) || (fr == 23976)) {
3575 if(verbose && norm >= 0)
3576 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3580 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3581 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3582 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3586 if(!strcmp(arg, "vcd")) {
3588 opt_video_codec("mpeg1video");
3589 opt_audio_codec("mp2");
3592 opt_frame_size(norm ? "352x240" : "352x288");
3593 opt_frame_rate(frame_rates[norm]);
3594 opt_default("gop", norm ? "18" : "15");
3596 opt_default("b", "1150000");
3597 opt_default("maxrate", "1150000");
3598 opt_default("minrate", "1150000");
3599 opt_default("bufsize", "327680"); // 40*1024*8;
3601 opt_default("ab", "224000");
3602 audio_sample_rate = 44100;
3605 opt_default("packetsize", "2324");
3606 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3608 /* We have to offset the PTS, so that it is consistent with the SCR.
3609 SCR starts at 36000, but the first two packs contain only padding
3610 and the first pack from the other stream, respectively, may also have
3611 been written before.
3612 So the real data starts at SCR 36000+3*1200. */
3613 mux_preload= (36000+3*1200) / 90000.0; //0.44
3614 } else if(!strcmp(arg, "svcd")) {
3616 opt_video_codec("mpeg2video");
3617 opt_audio_codec("mp2");
3620 opt_frame_size(norm ? "480x480" : "480x576");
3621 opt_frame_rate(frame_rates[norm]);
3622 opt_default("gop", norm ? "18" : "15");
3624 opt_default("b", "2040000");
3625 opt_default("maxrate", "2516000");
3626 opt_default("minrate", "0"); //1145000;
3627 opt_default("bufsize", "1835008"); //224*1024*8;
3628 opt_default("flags", "+SCAN_OFFSET");
3631 opt_default("ab", "224000");
3632 audio_sample_rate = 44100;
3634 opt_default("packetsize", "2324");
3636 } else if(!strcmp(arg, "dvd")) {
3638 opt_video_codec("mpeg2video");
3639 opt_audio_codec("ac3");
3642 opt_frame_size(norm ? "720x480" : "720x576");
3643 opt_frame_rate(frame_rates[norm]);
3644 opt_default("gop", norm ? "18" : "15");
3646 opt_default("b", "6000000");
3647 opt_default("maxrate", "9000000");
3648 opt_default("minrate", "0"); //1500000;
3649 opt_default("bufsize", "1835008"); //224*1024*8;
3651 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3652 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3654 opt_default("ab", "448000");
3655 audio_sample_rate = 48000;
3657 } else if(!strncmp(arg, "dv", 2)) {
3661 opt_frame_size(norm ? "720x480" : "720x576");
3662 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3663 (norm ? "yuv411p" : "yuv420p"));
3664 opt_frame_rate(frame_rates[norm]);
3666 audio_sample_rate = 48000;
3670 fprintf(stderr, "Unknown target: %s\n", arg);
3675 static void opt_vstats_file (const char *arg)
3677 av_free (vstats_filename);
3678 vstats_filename=av_strdup (arg);
3681 static void opt_vstats (void)
3684 time_t today2 = time(NULL);
3685 struct tm *today = localtime(&today2);
3687 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3689 opt_vstats_file(filename);
3692 static int opt_bsf(const char *opt, const char *arg)
3694 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3695 AVBitStreamFilterContext **bsfp;
3698 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3702 bsfp= *opt == 'v' ? &video_bitstream_filters :
3703 *opt == 'a' ? &audio_bitstream_filters :
3704 &subtitle_bitstream_filters;
3706 bsfp= &(*bsfp)->next;
3713 static void opt_show_license(void)
3719 static void opt_show_version(void)
3721 show_version(program_name);