3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 /* needed for usleep() */
23 #define _XOPEN_SOURCE 600
25 #include <ffmpeg-config.h>
34 #include "libavformat/avformat.h"
35 #include "libavdevice/avdevice.h"
36 #include "libswscale/swscale.h"
37 #include "libavcodec/opt.h"
38 #include "libavcodec/audioconvert.h"
39 #include "libavutil/fifo.h"
40 #include "libavutil/avstring.h"
41 #include "libavformat/os_support.h"
42 #include "recorder_config.h"
44 #if HAVE_SYS_RESOURCE_H
45 #include <sys/types.h>
46 #include <sys/resource.h>
47 #elif HAVE_GETPROCESSTIMES
52 #include <sys/select.h>
57 #include <sys/ioctl.h>
63 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
66 #ifdef CONFIG_FFMPEG_WITH_FRSH
77 const char program_name[] = "FFmpeg";
78 const int program_birth_year = 2000;
80 /* select an input stream for an output stream */
81 typedef struct AVStreamMap {
85 int sync_stream_index;
88 /** select an input file for an output file */
89 typedef struct AVMetaDataMap {
94 static const OptionDef options[];
100 static AVFormatContext *input_files[MAX_FILES];
101 static int64_t input_files_ts_offset[MAX_FILES];
102 static double input_files_ts_scale[MAX_FILES][MAX_STREAMS];
103 static AVCodec *input_codecs[MAX_FILES*MAX_STREAMS];
104 static int nb_input_files = 0;
105 static int nb_icodecs;
107 static AVFormatContext *output_files[MAX_FILES];
108 static AVCodec *output_codecs[MAX_FILES*MAX_STREAMS];
109 static int nb_output_files = 0;
110 static int nb_ocodecs;
112 static AVStreamMap stream_maps[MAX_FILES*MAX_STREAMS];
113 static int nb_stream_maps;
115 static AVMetaDataMap meta_data_maps[MAX_FILES];
116 static int nb_meta_data_maps;
118 static AVInputFormat *file_iformat;
119 static AVOutputFormat *file_oformat;
120 static int frame_width = 0;
121 static int frame_height = 0;
122 static float frame_aspect_ratio = 0;
123 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
124 static enum SampleFormat audio_sample_fmt = SAMPLE_FMT_NONE;
125 static int frame_padtop = 0;
126 static int frame_padbottom = 0;
127 static int frame_padleft = 0;
128 static int frame_padright = 0;
129 static int padcolor[3] = {16,128,128}; /* default to black */
130 static int frame_topBand = 0;
131 static int frame_bottomBand = 0;
132 static int frame_leftBand = 0;
133 static int frame_rightBand = 0;
134 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
135 static AVRational frame_rate;
136 static float video_qscale = 0;
137 static uint16_t *intra_matrix = NULL;
138 static uint16_t *inter_matrix = NULL;
139 #if 0 //experimental, (can be removed)
140 static float video_rc_qsquish=1.0;
141 static float video_rc_qmod_amp=0;
142 static int video_rc_qmod_freq=0;
144 static const char *video_rc_override_string=NULL;
145 static int video_disable = 0;
146 static int video_discard = 0;
147 static char *video_codec_name = NULL;
148 static int video_codec_tag = 0;
149 static int same_quality = 0;
150 static int do_deinterlace = 0;
151 static int top_field_first = -1;
152 static int me_threshold = 0;
153 static int intra_dc_precision = 8;
154 static int loop_input = 0;
155 static int loop_output = AVFMT_NOOUTPUTLOOP;
156 static int qp_hist = 0;
158 static int intra_only = 0;
159 static int audio_sample_rate = 44100;
160 static int64_t channel_layout = 0;
161 #define QSCALE_NONE -99999
162 static float audio_qscale = QSCALE_NONE;
163 static int audio_disable = 0;
164 static int audio_channels = 1;
165 static char *audio_codec_name = NULL;
166 static int audio_codec_tag = 0;
167 static char *audio_language = NULL;
169 static int subtitle_disable = 0;
170 static char *subtitle_codec_name = NULL;
171 static char *subtitle_language = NULL;
172 static int subtitle_codec_tag = 0;
174 static float mux_preload= 0.5;
175 static float mux_max_delay= 0.7;
177 static int64_t recording_time = INT64_MAX;
178 static int64_t start_time = 0;
179 static int64_t rec_timestamp = 0;
180 static int64_t input_ts_offset = 0;
181 static int file_overwrite = 0;
182 static int o_direct = 0;
183 static int metadata_count;
184 static AVMetadataTag *metadata;
185 static int do_benchmark = 0;
186 static int do_hex_dump = 0;
187 static int do_pkt_dump = 0;
188 static int do_psnr = 0;
189 static int do_pass = 0;
190 static char *pass_logfilename_prefix = NULL;
191 static int audio_stream_copy = 0;
192 static int video_stream_copy = 0;
193 static int subtitle_stream_copy = 0;
194 static int video_sync_method= -1;
195 static int audio_sync_method= 0;
196 static float audio_drift_threshold= 0.1;
197 static int copy_ts= 0;
198 static int opt_shortest = 0;
199 static int video_global_header = 0;
200 static char *vstats_filename;
201 static FILE *vstats_file;
202 static int opt_programid = 0;
203 static int copy_initial_nonkeyframes = 0;
205 static int rate_emu = 0;
207 static int video_channel = 0;
208 static char *video_standard;
210 static int audio_volume = 256;
212 static int exit_on_error = 0;
213 static int using_stdin = 0;
214 static int verbose = 1;
215 static int thread_count= 1;
216 static int q_pressed = 0;
217 static int64_t video_size = 0;
218 static int64_t audio_size = 0;
219 static int64_t extra_size = 0;
220 static int nb_frames_dup = 0;
221 static int nb_frames_drop = 0;
222 static int input_sync;
223 static uint64_t limit_filesize = 0;
224 static int force_fps = 0;
226 static int pgmyuv_compatibility_hack=0;
227 static float dts_delta_threshold = 10;
229 static unsigned int sws_flags = SWS_BICUBIC;
231 static int64_t timer_start;
233 static uint8_t *audio_buf;
234 static uint8_t *audio_out;
235 static uint8_t *audio_out2;
237 static short *samples;
239 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
240 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
241 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
242 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
244 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
246 struct AVInputStream;
248 typedef struct AVOutputStream {
249 int file_index; /* file index */
250 int index; /* stream index in the output file */
251 int source_index; /* AVInputStream index */
252 AVStream *st; /* stream in the output file */
253 int encoding_needed; /* true if encoding needed for this stream */
255 /* input pts and corresponding output pts
257 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
258 struct AVInputStream *sync_ist; /* input stream to sync against */
259 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
262 AVFrame pict_tmp; /* temporary image for resampling */
263 struct SwsContext *img_resample_ctx; /* for image resampling */
267 int topBand; /* cropping area sizes */
271 int padtop; /* padding area sizes */
278 ReSampleContext *resample; /* for audio resampling */
280 AVAudioConvert *reformat_ctx;
281 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
285 typedef struct AVInputStream {
289 int discard; /* true if stream data should be discarded */
290 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
291 int64_t sample_index; /* current sample */
293 int64_t start; /* time when read started */
294 int64_t next_pts; /* synthetic pts for cases where pkt.pts
296 int64_t pts; /* current pts */
297 int is_start; /* is 1 at the start and after a discontinuity */
300 typedef struct AVInputFile {
301 int eof_reached; /* true if eof reached */
302 int ist_index; /* index of first stream in ist_table */
303 int buffer_size; /* current total buffer size */
304 int nb_streams; /* nb streams we are aware of */
309 /* init terminal so that we can grab keys */
310 static struct termios oldtty;
313 static void term_exit(void)
316 tcsetattr (0, TCSANOW, &oldtty);
320 static volatile sig_atomic_t received_sigterm = 0;
323 sigterm_handler(int sig)
325 received_sigterm = sig;
329 static void term_init(void)
337 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
338 |INLCR|IGNCR|ICRNL|IXON);
339 tty.c_oflag |= OPOST;
340 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
341 tty.c_cflag &= ~(CSIZE|PARENB);
346 tcsetattr (0, TCSANOW, &tty);
347 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
350 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
351 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
353 register a function to be called at normal program termination
356 #if CONFIG_BEOS_NETSERVER
357 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
361 /* read a key without blocking */
362 static int read_key(void)
367 #if !CONFIG_BEOS_NETSERVER
375 n = select(1, &rfds, NULL, NULL, &tv);
391 static int decode_interrupt_cb(void)
393 return q_pressed || (q_pressed = read_key() == 'q');
396 static int av_exit(int ret)
401 for(i=0;i<nb_output_files;i++) {
402 /* maybe av_close_output_file ??? */
403 AVFormatContext *s = output_files[i];
405 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
407 for(j=0;j<s->nb_streams;j++) {
408 av_metadata_free(&s->streams[j]->metadata);
409 av_free(s->streams[j]->codec);
410 av_free(s->streams[j]);
412 for(j=0;j<s->nb_programs;j++) {
413 av_metadata_free(&s->programs[j]->metadata);
415 for(j=0;j<s->nb_chapters;j++) {
416 av_metadata_free(&s->chapters[j]->metadata);
418 av_metadata_free(&s->metadata);
421 for(i=0;i<nb_input_files;i++)
422 av_close_input_file(input_files[i]);
424 av_free(intra_matrix);
425 av_free(inter_matrix);
429 av_free(vstats_filename);
433 av_free(video_codec_name);
434 av_free(audio_codec_name);
435 av_free(subtitle_codec_name);
437 av_free(video_standard);
439 #if CONFIG_POWERPC_PERF
440 void powerpc_display_perf_report(void);
441 powerpc_display_perf_report();
442 #endif /* CONFIG_POWERPC_PERF */
444 for (i=0;i<CODEC_TYPE_NB;i++)
445 av_free(avcodec_opts[i]);
446 av_free(avformat_opts);
453 if (received_sigterm) {
455 "Received signal %d: terminating.\n",
456 (int) received_sigterm);
460 exit(ret); /* not all OS-es handle main() return value */
464 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
470 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
473 /* copy stream format */
474 s->nb_streams = ic->nb_streams;
475 for(i=0;i<ic->nb_streams;i++) {
478 // FIXME: a more elegant solution is needed
479 st = av_mallocz(sizeof(AVStream));
480 memcpy(st, ic->streams[i], sizeof(AVStream));
481 st->codec = avcodec_alloc_context();
482 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
485 if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
487 else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
490 if(!st->codec->thread_count)
491 st->codec->thread_count = 1;
492 if(st->codec->thread_count>1)
493 avcodec_thread_init(st->codec, st->codec->thread_count);
495 if(st->codec->flags & CODEC_FLAG_BITEXACT)
500 s->timestamp = av_gettime();
502 av_close_input_file(ic);
507 get_sync_ipts(const AVOutputStream *ost)
509 const AVInputStream *ist = ost->sync_ist;
510 return (double)(ist->pts - start_time)/AV_TIME_BASE;
513 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
517 AVPacket new_pkt= *pkt;
518 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
519 &new_pkt.data, &new_pkt.size,
520 pkt->data, pkt->size,
521 pkt->flags & PKT_FLAG_KEY);
524 new_pkt.destruct= av_destruct_packet;
526 fprintf(stderr, "%s failed for stream %d, codec %s",
527 bsfc->filter->name, pkt->stream_index,
528 avctx->codec ? avctx->codec->name : "copy");
538 ret= av_interleaved_write_frame(s, pkt);
540 print_error("av_interleaved_write_frame()", ret);
545 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
547 static void do_audio_out(AVFormatContext *s,
550 unsigned char *buf, int size)
553 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
555 int size_out, frame_bytes, ret;
556 AVCodecContext *enc= ost->st->codec;
557 AVCodecContext *dec= ist->st->codec;
558 int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
559 int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
561 /* SC: dynamic allocation of buffers */
563 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
565 audio_out = av_malloc(audio_out_size);
566 if (!audio_buf || !audio_out)
567 return; /* Should signal an error ! */
569 if (enc->channels != dec->channels)
570 ost->audio_resample = 1;
572 if (ost->audio_resample && !ost->resample) {
573 if (dec->sample_fmt != SAMPLE_FMT_S16)
574 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
575 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
576 enc->sample_rate, dec->sample_rate,
577 enc->sample_fmt, dec->sample_fmt,
579 if (!ost->resample) {
580 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
581 dec->channels, dec->sample_rate,
582 enc->channels, enc->sample_rate);
587 #define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
588 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
589 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
591 audio_out2 = av_malloc(audio_out_size);
594 if (ost->reformat_ctx)
595 av_audio_convert_free(ost->reformat_ctx);
596 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
597 dec->sample_fmt, 1, NULL, 0);
598 if (!ost->reformat_ctx) {
599 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
600 avcodec_get_sample_fmt_name(dec->sample_fmt),
601 avcodec_get_sample_fmt_name(enc->sample_fmt));
604 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
607 if(audio_sync_method){
608 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
609 - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2);
610 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
611 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
613 //FIXME resample delay
614 if(fabs(delta) > 50){
615 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
617 byte_delta= FFMAX(byte_delta, -size);
621 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
626 static uint8_t *input_tmp= NULL;
627 input_tmp= av_realloc(input_tmp, byte_delta + size);
629 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
632 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
634 memset(input_tmp, 0, byte_delta);
635 memcpy(input_tmp + byte_delta, buf, size);
639 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
641 }else if(audio_sync_method>1){
642 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
643 assert(ost->audio_resample);
645 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
646 // 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));
647 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
651 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
652 - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
654 if (ost->audio_resample) {
656 size_out = audio_resample(ost->resample,
657 (short *)buftmp, (short *)buf,
658 size / (ist->st->codec->channels * isize));
659 size_out = size_out * enc->channels * osize;
665 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
666 const void *ibuf[6]= {buftmp};
667 void *obuf[6]= {audio_out2};
668 int istride[6]= {isize};
669 int ostride[6]= {osize};
670 int len= size_out/istride[0];
671 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
672 printf("av_audio_convert() failed\n");
678 size_out = len*osize;
681 /* now encode as many frames as possible */
682 if (enc->frame_size > 1) {
683 /* output resampled raw samples */
684 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
685 fprintf(stderr, "av_fifo_realloc2() failed\n");
688 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
690 frame_bytes = enc->frame_size * osize * enc->channels;
692 while (av_fifo_size(ost->fifo) >= frame_bytes) {
694 av_init_packet(&pkt);
696 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
698 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
700 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
703 fprintf(stderr, "Audio encoding failed\n");
707 pkt.stream_index= ost->index;
710 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
711 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
712 pkt.flags |= PKT_FLAG_KEY;
713 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
715 ost->sync_opts += enc->frame_size;
719 int coded_bps = av_get_bits_per_sample(enc->codec->id)/8;
720 av_init_packet(&pkt);
722 ost->sync_opts += size_out / (osize * enc->channels);
724 /* output a pcm frame */
725 /* determine the size of the coded buffer */
728 size_out *= coded_bps;
730 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
731 ret = avcodec_encode_audio(enc, audio_out, size_out,
734 fprintf(stderr, "Audio encoding failed\n");
738 pkt.stream_index= ost->index;
741 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
742 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
743 pkt.flags |= PKT_FLAG_KEY;
744 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
748 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
752 AVPicture picture_tmp;
755 dec = ist->st->codec;
757 /* deinterlace : must be done before any resize */
758 if (do_deinterlace) {
761 /* create temporary picture */
762 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
763 buf = av_malloc(size);
767 picture2 = &picture_tmp;
768 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
771 if(avpicture_deinterlace(picture2, picture,
772 dec->pix_fmt, dec->width, dec->height) < 0) {
773 /* if error, do not deinterlace */
774 fprintf(stderr, "Deinterlacing failed\n");
780 av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
786 if (picture != picture2)
787 *picture = *picture2;
791 /* we begin to correct av delay at this threshold */
792 #define AV_DELAY_MAX 0.100
794 static void do_subtitle_out(AVFormatContext *s,
800 static uint8_t *subtitle_out = NULL;
801 int subtitle_out_max_size = 65536;
802 int subtitle_out_size, nb, i;
806 if (pts == AV_NOPTS_VALUE) {
807 fprintf(stderr, "Subtitle packets must have a pts\n");
813 enc = ost->st->codec;
816 subtitle_out = av_malloc(subtitle_out_max_size);
819 /* Note: DVB subtitle need one packet to draw them and one other
820 packet to clear them */
821 /* XXX: signal it in the codec context ? */
822 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
827 for(i = 0; i < nb; i++) {
828 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
829 subtitle_out_max_size, sub);
831 av_init_packet(&pkt);
832 pkt.stream_index = ost->index;
833 pkt.data = subtitle_out;
834 pkt.size = subtitle_out_size;
835 pkt.pts = av_rescale_q(pts, ist->st->time_base, ost->st->time_base);
836 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
837 /* XXX: the pts correction is handled here. Maybe handling
838 it in the codec would be better */
840 pkt.pts += 90 * sub->start_display_time;
842 pkt.pts += 90 * sub->end_display_time;
844 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
848 static int bit_buffer_size= 1024*256;
849 static uint8_t *bit_buffer= NULL;
851 static void do_video_out(AVFormatContext *s,
857 int nb_frames, i, ret;
858 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
859 AVFrame picture_crop_temp, picture_pad_temp;
860 AVCodecContext *enc, *dec;
862 avcodec_get_frame_defaults(&picture_crop_temp);
863 avcodec_get_frame_defaults(&picture_pad_temp);
865 enc = ost->st->codec;
866 dec = ist->st->codec;
868 /* by default, we output a single frame */
873 if(video_sync_method>0 || (video_sync_method && av_q2d(enc->time_base) > 0.001)){
875 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
876 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
879 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
883 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
884 }else if (vdelta > 1.1)
885 nb_frames = lrintf(vdelta);
886 //fprintf(stderr, "vdelta:%f, ost->sync_opts:%"PRId64", ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, get_sync_ipts(ost), nb_frames);
890 fprintf(stderr, "*** drop!\n");
891 }else if (nb_frames > 1) {
892 nb_frames_dup += nb_frames;
894 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
897 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
899 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
903 if (ost->video_crop) {
904 if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
905 fprintf(stderr, "error cropping picture\n");
910 formatted_picture = &picture_crop_temp;
912 formatted_picture = in_picture;
915 final_picture = formatted_picture;
916 padding_src = formatted_picture;
917 resampling_dst = &ost->pict_tmp;
918 if (ost->video_pad) {
919 final_picture = &ost->pict_tmp;
920 if (ost->video_resample) {
921 if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
922 fprintf(stderr, "error padding picture\n");
927 resampling_dst = &picture_pad_temp;
931 if (ost->video_resample) {
933 final_picture = &ost->pict_tmp;
934 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
935 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
938 if (ost->video_pad) {
939 av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
940 enc->height, enc->width, enc->pix_fmt,
941 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
944 /* duplicates frame if needed */
945 for(i=0;i<nb_frames;i++) {
947 av_init_packet(&pkt);
948 pkt.stream_index= ost->index;
950 if (s->oformat->flags & AVFMT_RAWPICTURE) {
951 /* raw pictures are written as AVPicture structure to
952 avoid any copies. We support temorarily the older
954 AVFrame* old_frame = enc->coded_frame;
955 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
956 pkt.data= (uint8_t *)final_picture;
957 pkt.size= sizeof(AVPicture);
958 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
959 pkt.flags |= PKT_FLAG_KEY;
961 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
962 enc->coded_frame = old_frame;
966 big_picture= *final_picture;
967 /* better than nothing: use input picture interlaced
969 big_picture.interlaced_frame = in_picture->interlaced_frame;
970 if(avcodec_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
971 if(top_field_first == -1)
972 big_picture.top_field_first = in_picture->top_field_first;
974 big_picture.top_field_first = top_field_first;
977 /* handles sameq here. This is not correct because it may
978 not be a global option */
980 big_picture.quality = ist->st->quality;
982 big_picture.quality = ost->st->quality;
984 big_picture.pict_type = 0;
985 // big_picture.pts = AV_NOPTS_VALUE;
986 big_picture.pts= ost->sync_opts;
987 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
988 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
989 ret = avcodec_encode_video(enc,
990 bit_buffer, bit_buffer_size,
993 fprintf(stderr, "Video encoding failed\n");
996 //enc->frame_number = enc->real_pict_num;
998 pkt.data= bit_buffer;
1000 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1001 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1002 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1003 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1004 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1006 if(enc->coded_frame->key_frame)
1007 pkt.flags |= PKT_FLAG_KEY;
1008 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1011 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
1012 // enc->frame_number-1, enc->real_pict_num, ret,
1014 /* if two pass, output log */
1015 if (ost->logfile && enc->stats_out) {
1016 fprintf(ost->logfile, "%s", enc->stats_out);
1021 ost->frame_number++;
1025 static double psnr(double d){
1026 return -10.0*log(d)/log(10.0);
1029 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1032 AVCodecContext *enc;
1034 double ti1, bitrate, avg_bitrate;
1036 /* this is executed just the first time do_video_stats is called */
1038 vstats_file = fopen(vstats_filename, "w");
1045 enc = ost->st->codec;
1046 if (enc->codec_type == CODEC_TYPE_VIDEO) {
1047 frame_number = ost->frame_number;
1048 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1049 if (enc->flags&CODEC_FLAG_PSNR)
1050 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1052 fprintf(vstats_file,"f_size= %6d ", frame_size);
1053 /* compute pts value */
1054 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1058 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1059 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1060 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1061 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1062 fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1066 static void print_report(AVFormatContext **output_files,
1067 AVOutputStream **ost_table, int nb_ostreams,
1071 AVOutputStream *ost;
1072 AVFormatContext *oc;
1074 AVCodecContext *enc;
1075 int frame_number, vid, i;
1076 double bitrate, ti1, pts;
1077 static int64_t last_time = -1;
1078 static int qp_histogram[52];
1080 if (!is_last_report) {
1082 /* display the report every 0.5 seconds */
1083 cur_time = av_gettime();
1084 if (last_time == -1) {
1085 last_time = cur_time;
1088 if ((cur_time - last_time) < 500000)
1090 last_time = cur_time;
1094 oc = output_files[0];
1096 total_size = url_fsize(oc->pb);
1097 if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1098 total_size= url_ftell(oc->pb);
1103 for(i=0;i<nb_ostreams;i++) {
1105 enc = ost->st->codec;
1106 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1107 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1108 !ost->st->stream_copy ?
1109 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1111 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1112 float t = (av_gettime()-timer_start) / 1000000.0;
1114 frame_number = ost->frame_number;
1115 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1116 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1117 !ost->st->stream_copy ?
1118 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1120 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1123 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1124 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1127 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1129 if (enc->flags&CODEC_FLAG_PSNR){
1131 double error, error_sum=0;
1132 double scale, scale_sum=0;
1133 char type[3]= {'Y','U','V'};
1134 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1137 error= enc->error[j];
1138 scale= enc->width*enc->height*255.0*255.0*frame_number;
1140 error= enc->coded_frame->error[j];
1141 scale= enc->width*enc->height*255.0*255.0;
1146 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1148 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1152 /* compute min output value */
1153 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1154 if ((pts < ti1) && (pts > 0))
1160 if (verbose || is_last_report) {
1161 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1163 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1164 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1165 (double)total_size / 1024, ti1, bitrate);
1168 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1169 nb_frames_dup, nb_frames_drop);
1172 fprintf(stderr, "%s \r", buf);
1177 if (is_last_report && verbose >= 0){
1178 int64_t raw= audio_size + video_size + extra_size;
1179 fprintf(stderr, "\n");
1180 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1184 100.0*(total_size - raw)/raw
1189 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1190 static int output_packet(AVInputStream *ist, int ist_index,
1191 AVOutputStream **ost_table, int nb_ostreams,
1192 const AVPacket *pkt)
1194 AVFormatContext *os;
1195 AVOutputStream *ost;
1198 int data_size, got_picture;
1200 void *buffer_to_free;
1201 static unsigned int samples_size= 0;
1202 AVSubtitle subtitle, *subtitle_to_free;
1206 if(ist->next_pts == AV_NOPTS_VALUE)
1207 ist->next_pts= ist->pts;
1211 av_init_packet(&avpkt);
1219 if(pkt->dts != AV_NOPTS_VALUE)
1220 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1222 //while we have more to decode or while the decoder did output something on EOF
1223 while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1225 ist->pts= ist->next_pts;
1227 if(avpkt.size && avpkt.size != pkt->size && verbose>0)
1228 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1230 /* decode the packet if needed */
1231 data_buf = NULL; /* fail safe */
1233 subtitle_to_free = NULL;
1234 if (ist->decoding_needed) {
1235 switch(ist->st->codec->codec_type) {
1236 case CODEC_TYPE_AUDIO:{
1237 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1238 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1240 samples= av_malloc(samples_size);
1242 data_size= samples_size;
1243 /* XXX: could avoid copy if PCM 16 bits with same
1244 endianness as CPU */
1245 ret = avcodec_decode_audio3(ist->st->codec, samples, &data_size,
1251 /* Some bug in mpeg audio decoder gives */
1252 /* data_size < 0, it seems they are overflows */
1253 if (data_size <= 0) {
1254 /* no audio frame */
1257 data_buf = (uint8_t *)samples;
1258 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1259 (ist->st->codec->sample_rate * ist->st->codec->channels);
1261 case CODEC_TYPE_VIDEO:
1262 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1263 /* XXX: allocate picture correctly */
1264 avcodec_get_frame_defaults(&picture);
1266 ret = avcodec_decode_video2(ist->st->codec,
1267 &picture, &got_picture, &avpkt);
1268 ist->st->quality= picture.quality;
1272 /* no picture yet */
1273 goto discard_packet;
1275 if (ist->st->codec->time_base.num != 0) {
1276 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1277 ist->next_pts += ((int64_t)AV_TIME_BASE *
1278 ist->st->codec->time_base.num * ticks) /
1279 ist->st->codec->time_base.den;
1283 case CODEC_TYPE_SUBTITLE:
1284 ret = avcodec_decode_subtitle2(ist->st->codec,
1285 &subtitle, &got_subtitle, &avpkt);
1288 if (!got_subtitle) {
1289 goto discard_packet;
1291 subtitle_to_free = &subtitle;
1298 switch(ist->st->codec->codec_type) {
1299 case CODEC_TYPE_AUDIO:
1300 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1301 ist->st->codec->sample_rate;
1303 case CODEC_TYPE_VIDEO:
1304 if (ist->st->codec->time_base.num != 0) {
1305 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1306 ist->next_pts += ((int64_t)AV_TIME_BASE *
1307 ist->st->codec->time_base.num * ticks) /
1308 ist->st->codec->time_base.den;
1312 data_buf = avpkt.data;
1313 data_size = avpkt.size;
1318 buffer_to_free = NULL;
1319 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1320 pre_process_video_frame(ist, (AVPicture *)&picture,
1324 // preprocess audio (volume)
1325 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1326 if (audio_volume != 256) {
1329 for(i=0;i<(data_size / sizeof(short));i++) {
1330 int v = ((*volp) * audio_volume + 128) >> 8;
1331 if (v < -32768) v = -32768;
1332 if (v > 32767) v = 32767;
1338 /* frame rate emulation */
1340 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1341 int64_t now = av_gettime() - ist->start;
1346 /* if output time reached then transcode raw format,
1347 encode packets and output them */
1348 if (start_time == 0 || ist->pts >= start_time)
1349 for(i=0;i<nb_ostreams;i++) {
1353 if (ost->source_index == ist_index) {
1354 os = output_files[ost->file_index];
1357 printf("%d: got pts=%0.3f %0.3f\n", i,
1358 (double)pkt->pts / AV_TIME_BASE,
1359 ((double)ist->pts / AV_TIME_BASE) -
1360 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1362 /* set the input output pts pairs */
1363 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1365 if (ost->encoding_needed) {
1366 switch(ost->st->codec->codec_type) {
1367 case CODEC_TYPE_AUDIO:
1368 do_audio_out(os, ost, ist, data_buf, data_size);
1370 case CODEC_TYPE_VIDEO:
1371 do_video_out(os, ost, ist, &picture, &frame_size);
1372 if (vstats_filename && frame_size)
1373 do_video_stats(os, ost, frame_size);
1375 case CODEC_TYPE_SUBTITLE:
1376 do_subtitle_out(os, ost, ist, &subtitle,
1383 AVFrame avframe; //FIXME/XXX remove this
1385 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1387 av_init_packet(&opkt);
1389 if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1392 /* no reencoding needed : output the packet directly */
1393 /* force the input stream PTS */
1395 avcodec_get_frame_defaults(&avframe);
1396 ost->st->codec->coded_frame= &avframe;
1397 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1399 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1400 audio_size += data_size;
1401 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1402 video_size += data_size;
1406 opkt.stream_index= ost->index;
1407 if(pkt->pts != AV_NOPTS_VALUE)
1408 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1410 opkt.pts= AV_NOPTS_VALUE;
1412 if (pkt->dts == AV_NOPTS_VALUE)
1413 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1415 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1416 opkt.dts -= ost_tb_start_time;
1418 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1419 opkt.flags= pkt->flags;
1421 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1422 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1423 opkt.destruct= av_destruct_packet;
1425 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1426 ost->st->codec->frame_number++;
1427 ost->frame_number++;
1428 av_free_packet(&opkt);
1432 av_free(buffer_to_free);
1433 /* XXX: allocate the subtitles in the codec ? */
1434 if (subtitle_to_free) {
1435 if (subtitle_to_free->rects != NULL) {
1436 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1437 av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1438 av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1439 av_freep(&subtitle_to_free->rects[i]);
1441 av_freep(&subtitle_to_free->rects);
1443 subtitle_to_free->num_rects = 0;
1444 subtitle_to_free = NULL;
1451 for(i=0;i<nb_ostreams;i++) {
1453 if (ost->source_index == ist_index) {
1454 AVCodecContext *enc= ost->st->codec;
1455 os = output_files[ost->file_index];
1457 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1459 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1462 if (ost->encoding_needed) {
1466 av_init_packet(&pkt);
1467 pkt.stream_index= ost->index;
1469 switch(ost->st->codec->codec_type) {
1470 case CODEC_TYPE_AUDIO:
1471 fifo_bytes = av_fifo_size(ost->fifo);
1473 /* encode any samples remaining in fifo */
1474 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1475 int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
1476 int fs_tmp = enc->frame_size;
1477 enc->frame_size = fifo_bytes / (osize * enc->channels);
1478 av_fifo_generic_read(ost->fifo, samples, fifo_bytes, NULL);
1479 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1480 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1481 ost->st->time_base.num, enc->sample_rate);
1482 enc->frame_size = fs_tmp;
1485 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1488 fprintf(stderr, "Audio encoding failed\n");
1492 pkt.flags |= PKT_FLAG_KEY;
1494 case CODEC_TYPE_VIDEO:
1495 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1497 fprintf(stderr, "Video encoding failed\n");
1501 if(enc->coded_frame && enc->coded_frame->key_frame)
1502 pkt.flags |= PKT_FLAG_KEY;
1503 if (ost->logfile && enc->stats_out) {
1504 fprintf(ost->logfile, "%s", enc->stats_out);
1513 pkt.data= bit_buffer;
1515 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1516 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1517 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1529 static void print_sdp(AVFormatContext **avc, int n)
1533 avf_sdp_create(avc, n, sdp, sizeof(sdp));
1534 printf("SDP:\n%s\n", sdp);
1538 static int stream_index_from_inputs(AVFormatContext **input_files,
1540 AVInputFile *file_table,
1541 AVInputStream **ist_table,
1542 enum CodecType type,
1546 for(z=0; z<nb_input_files; z++) {
1547 AVFormatContext *ic = input_files[z];
1548 for(p=0; p<ic->nb_programs; p++) {
1549 AVProgram *program = ic->programs[p];
1550 if(program->id != programid)
1552 for(q=0; q<program->nb_stream_indexes; q++) {
1553 int sidx = program->stream_index[q];
1554 int ris = file_table[z].ist_index + sidx;
1555 if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1565 timespec_subtract (struct timespec *result,
1569 /* Perform the carry for the later subtraction by updating Y. */
1570 if (x->tv_nsec < y->tv_nsec) {
1571 int num_sec = (y->tv_nsec - x->tv_nsec) / 1000000000 + 1;
1572 y->tv_nsec -= 1000000000 * num_sec;
1573 y->tv_sec += num_sec;
1575 if (x->tv_nsec - y->tv_nsec > 1000000000) {
1576 int num_sec = (x->tv_nsec - y->tv_nsec) / 1000000000;
1577 y->tv_nsec += 1000000000 * num_sec;
1578 y->tv_sec -= num_sec;
1581 /* Compute the time remaining to wait.
1582 `tv_nsec' is certainly positive. */
1583 result->tv_sec = x->tv_sec - y->tv_sec;
1584 result->tv_nsec = x->tv_nsec - y->tv_nsec;
1586 /* Return 1 if result is negative. */
1587 return x->tv_sec < y->tv_sec;
1590 #ifdef CONFIG_FFMPEG_WITH_FRSH
1591 frsh_vres_id_t disk_vres;
1592 frsh_contract_t disk_contract;
1598 static struct timespec start = {0,0};
1599 struct timespec end, d;
1600 static int f = 0; /* number of frames */
1602 static double ifi_avg=0, ifi_var=0;
1604 clock_gettime(CLOCK_MONOTONIC, &end);
1605 timespec_subtract(&d, &end, &start);
1607 goto out; /* First run */
1608 ifi = (double)d.tv_sec + 1e-9*d.tv_nsec;
1609 #define SQ(x) ((x)*(x))
1610 ifi_var = ifi_var*(f-1)/f + (double)(f-1)/SQ(f)*SQ(ifi-ifi_avg);
1611 ifi_avg = ifi_avg*(f-1)/f + (double)ifi/f;
1612 printf("%5d: interframe interval = 1/%5.2lf s avg=1/%.2f stddev=1/%3.2f\n",
1613 f, 1/ifi, 1/ifi_avg, 1/sqrt(ifi_var));
1615 #ifdef CONFIG_FFMPEG_WITH_FRSH
1616 if (renegotiate == f)
1617 frsh_contract_renegotiate_sync(&disk_contract, disk_vres);
1624 * The following code is the main loop of the file converter
1626 static int av_encode(AVFormatContext **output_files,
1627 int nb_output_files,
1628 AVFormatContext **input_files,
1630 AVStreamMap *stream_maps, int nb_stream_maps)
1632 int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1633 AVFormatContext *is, *os;
1634 AVCodecContext *codec, *icodec;
1635 AVOutputStream *ost, **ost_table = NULL;
1636 AVInputStream *ist, **ist_table = NULL;
1637 AVInputFile *file_table;
1641 uint8_t no_packet[MAX_FILES]={0};
1642 int no_packet_count=0;
1644 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1648 /* input stream init */
1650 for(i=0;i<nb_input_files;i++) {
1651 is = input_files[i];
1652 file_table[i].ist_index = j;
1653 file_table[i].nb_streams = is->nb_streams;
1654 j += is->nb_streams;
1658 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1662 for(i=0;i<nb_istreams;i++) {
1663 ist = av_mallocz(sizeof(AVInputStream));
1669 for(i=0;i<nb_input_files;i++) {
1670 is = input_files[i];
1671 for(k=0;k<is->nb_streams;k++) {
1672 ist = ist_table[j++];
1673 ist->st = is->streams[k];
1674 ist->file_index = i;
1676 ist->discard = 1; /* the stream is discarded by default
1680 ist->start = av_gettime();
1685 /* output stream init */
1687 for(i=0;i<nb_output_files;i++) {
1688 os = output_files[i];
1689 if (!os->nb_streams) {
1690 dump_format(output_files[i], i, output_files[i]->filename, 1);
1691 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1694 nb_ostreams += os->nb_streams;
1696 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1697 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1701 /* Sanity check the mapping args -- do the input files & streams exist? */
1702 for(i=0;i<nb_stream_maps;i++) {
1703 int fi = stream_maps[i].file_index;
1704 int si = stream_maps[i].stream_index;
1706 if (fi < 0 || fi > nb_input_files - 1 ||
1707 si < 0 || si > file_table[fi].nb_streams - 1) {
1708 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1711 fi = stream_maps[i].sync_file_index;
1712 si = stream_maps[i].sync_stream_index;
1713 if (fi < 0 || fi > nb_input_files - 1 ||
1714 si < 0 || si > file_table[fi].nb_streams - 1) {
1715 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1720 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1723 for(i=0;i<nb_ostreams;i++) {
1724 ost = av_mallocz(sizeof(AVOutputStream));
1731 for(k=0;k<nb_output_files;k++) {
1732 os = output_files[k];
1733 for(i=0;i<os->nb_streams;i++,n++) {
1736 ost->file_index = k;
1738 ost->st = os->streams[i];
1739 if (nb_stream_maps > 0) {
1740 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1741 stream_maps[n].stream_index;
1743 /* Sanity check that the stream types match */
1744 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1745 int i= ost->file_index;
1746 dump_format(output_files[i], i, output_files[i]->filename, 1);
1747 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1748 stream_maps[n].file_index, stream_maps[n].stream_index,
1749 ost->file_index, ost->index);
1756 j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1758 ost->source_index = j;
1762 /* get corresponding input stream index : we select the first one with the right type */
1764 for(j=0;j<nb_istreams;j++) {
1767 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1768 ost->source_index = j;
1776 if(! opt_programid) {
1777 /* try again and reuse existing stream */
1778 for(j=0;j<nb_istreams;j++) {
1780 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1781 ost->source_index = j;
1787 int i= ost->file_index;
1788 dump_format(output_files[i], i, output_files[i]->filename, 1);
1789 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1790 ost->file_index, ost->index);
1795 ist = ist_table[ost->source_index];
1797 ost->sync_ist = (nb_stream_maps > 0) ?
1798 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
1799 stream_maps[n].sync_stream_index] : ist;
1803 /* for each output stream, we compute the right encoding parameters */
1804 for(i=0;i<nb_ostreams;i++) {
1805 AVMetadataTag *lang;
1807 os = output_files[ost->file_index];
1808 ist = ist_table[ost->source_index];
1810 codec = ost->st->codec;
1811 icodec = ist->st->codec;
1813 if ((lang=av_metadata_get(ist->st->metadata, "language", NULL, 0))
1814 && !av_metadata_get(ost->st->metadata, "language", NULL, 0))
1815 av_metadata_set(&ost->st->metadata, "language", lang->value);
1817 ost->st->disposition = ist->st->disposition;
1818 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1819 codec->chroma_sample_location = icodec->chroma_sample_location;
1821 if (ost->st->stream_copy) {
1822 /* if stream_copy is selected, no need to decode or encode */
1823 codec->codec_id = icodec->codec_id;
1824 codec->codec_type = icodec->codec_type;
1826 if(!codec->codec_tag){
1827 if( !os->oformat->codec_tag
1828 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1829 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1830 codec->codec_tag = icodec->codec_tag;
1833 codec->bit_rate = icodec->bit_rate;
1834 codec->extradata= icodec->extradata;
1835 codec->extradata_size= icodec->extradata_size;
1836 if(av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000){
1837 codec->time_base = icodec->time_base;
1838 codec->time_base.num *= icodec->ticks_per_frame;
1840 codec->time_base = ist->st->time_base;
1841 switch(codec->codec_type) {
1842 case CODEC_TYPE_AUDIO:
1843 if(audio_volume != 256) {
1844 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1847 codec->channel_layout = icodec->channel_layout;
1848 codec->sample_rate = icodec->sample_rate;
1849 codec->channels = icodec->channels;
1850 codec->frame_size = icodec->frame_size;
1851 codec->block_align= icodec->block_align;
1852 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1853 codec->block_align= 0;
1854 if(codec->codec_id == CODEC_ID_AC3)
1855 codec->block_align= 0;
1857 case CODEC_TYPE_VIDEO:
1858 codec->pix_fmt = icodec->pix_fmt;
1859 codec->width = icodec->width;
1860 codec->height = icodec->height;
1861 codec->has_b_frames = icodec->has_b_frames;
1863 case CODEC_TYPE_SUBTITLE:
1864 codec->width = icodec->width;
1865 codec->height = icodec->height;
1871 switch(codec->codec_type) {
1872 case CODEC_TYPE_AUDIO:
1873 ost->fifo= av_fifo_alloc(1024);
1876 ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
1877 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1878 icodec->request_channels = codec->channels;
1879 ist->decoding_needed = 1;
1880 ost->encoding_needed = 1;
1882 case CODEC_TYPE_VIDEO:
1883 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1884 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1885 ost->video_resample = ((codec->width != icodec->width -
1886 (frame_leftBand + frame_rightBand) +
1887 (frame_padleft + frame_padright)) ||
1888 (codec->height != icodec->height -
1889 (frame_topBand + frame_bottomBand) +
1890 (frame_padtop + frame_padbottom)) ||
1891 (codec->pix_fmt != icodec->pix_fmt));
1892 if (ost->video_crop) {
1893 ost->topBand = frame_topBand;
1894 ost->leftBand = frame_leftBand;
1896 if (ost->video_pad) {
1897 ost->padtop = frame_padtop;
1898 ost->padleft = frame_padleft;
1899 ost->padbottom = frame_padbottom;
1900 ost->padright = frame_padright;
1901 if (!ost->video_resample) {
1902 avcodec_get_frame_defaults(&ost->pict_tmp);
1903 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1904 codec->width, codec->height))
1908 if (ost->video_resample) {
1909 avcodec_get_frame_defaults(&ost->pict_tmp);
1910 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1911 codec->width, codec->height)) {
1912 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1915 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1916 ost->img_resample_ctx = sws_getContext(
1917 icodec->width - (frame_leftBand + frame_rightBand),
1918 icodec->height - (frame_topBand + frame_bottomBand),
1920 codec->width - (frame_padleft + frame_padright),
1921 codec->height - (frame_padtop + frame_padbottom),
1923 sws_flags, NULL, NULL, NULL);
1924 if (ost->img_resample_ctx == NULL) {
1925 fprintf(stderr, "Cannot get resampling context\n");
1928 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1929 codec->bits_per_raw_sample= 0;
1931 ost->encoding_needed = 1;
1932 ist->decoding_needed = 1;
1934 case CODEC_TYPE_SUBTITLE:
1935 ost->encoding_needed = 1;
1936 ist->decoding_needed = 1;
1943 if (ost->encoding_needed &&
1944 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1945 char logfilename[1024];
1950 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1951 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
1953 if (codec->flags & CODEC_FLAG_PASS1) {
1954 f = fopen(logfilename, "w");
1956 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
1961 /* read the log file */
1962 f = fopen(logfilename, "r");
1964 fprintf(stderr, "Cannot read log file '%s' for pass-2 encoding: %s\n", logfilename, strerror(errno));
1967 fseek(f, 0, SEEK_END);
1969 fseek(f, 0, SEEK_SET);
1970 logbuffer = av_malloc(size + 1);
1972 fprintf(stderr, "Could not allocate log buffer\n");
1975 size = fread(logbuffer, 1, size, f);
1977 logbuffer[size] = '\0';
1978 codec->stats_in = logbuffer;
1982 if(codec->codec_type == CODEC_TYPE_VIDEO){
1983 int size= codec->width * codec->height;
1984 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
1989 bit_buffer = av_malloc(bit_buffer_size);
1991 ret = AVERROR(ENOMEM);
1995 /* open each encoder */
1996 for(i=0;i<nb_ostreams;i++) {
1998 if (ost->encoding_needed) {
1999 AVCodec *codec = output_codecs[i];
2001 codec = avcodec_find_encoder(ost->st->codec->codec_id);
2003 snprintf(error, sizeof(error), "Unsupported codec for output stream #%d.%d",
2004 ost->file_index, ost->index);
2005 ret = AVERROR(EINVAL);
2008 if (avcodec_open(ost->st->codec, codec) < 0) {
2009 snprintf(error, sizeof(error), "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2010 ost->file_index, ost->index);
2011 ret = AVERROR(EINVAL);
2014 extra_size += ost->st->codec->extradata_size;
2018 /* open each decoder */
2019 for(i=0;i<nb_istreams;i++) {
2021 if (ist->decoding_needed) {
2022 AVCodec *codec = input_codecs[i];
2024 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2026 snprintf(error, sizeof(error), "Unsupported codec (id=%d) for input stream #%d.%d",
2027 ist->st->codec->codec_id, ist->file_index, ist->index);
2028 ret = AVERROR(EINVAL);
2031 if (avcodec_open(ist->st->codec, codec) < 0) {
2032 snprintf(error, sizeof(error), "Error while opening codec for input stream #%d.%d",
2033 ist->file_index, ist->index);
2034 ret = AVERROR(EINVAL);
2037 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
2038 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2043 for(i=0;i<nb_istreams;i++) {
2046 ist->next_pts = AV_NOPTS_VALUE;
2050 /* set meta data information from input file if required */
2051 for (i=0;i<nb_meta_data_maps;i++) {
2052 AVFormatContext *out_file;
2053 AVFormatContext *in_file;
2054 AVMetadataTag *mtag;
2056 int out_file_index = meta_data_maps[i].out_file;
2057 int in_file_index = meta_data_maps[i].in_file;
2058 if (out_file_index < 0 || out_file_index >= nb_output_files) {
2059 snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
2060 out_file_index, out_file_index, in_file_index);
2061 ret = AVERROR(EINVAL);
2064 if (in_file_index < 0 || in_file_index >= nb_input_files) {
2065 snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
2066 in_file_index, out_file_index, in_file_index);
2067 ret = AVERROR(EINVAL);
2071 out_file = output_files[out_file_index];
2072 in_file = input_files[in_file_index];
2076 while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2077 av_metadata_set(&out_file->metadata, mtag->key, mtag->value);
2078 av_metadata_conv(out_file, out_file->oformat->metadata_conv,
2079 in_file->iformat->metadata_conv);
2082 /* open files and write file headers */
2083 for(i=0;i<nb_output_files;i++) {
2084 os = output_files[i];
2085 if (av_write_header(os) < 0) {
2086 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2087 ret = AVERROR(EINVAL);
2090 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2096 /* dump the file output parameters - cannot be done before in case
2098 for(i=0;i<nb_output_files;i++) {
2099 dump_format(output_files[i], i, output_files[i]->filename, 1);
2102 /* dump the stream mapping */
2104 fprintf(stderr, "Stream mapping:\n");
2105 for(i=0;i<nb_ostreams;i++) {
2107 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2108 ist_table[ost->source_index]->file_index,
2109 ist_table[ost->source_index]->index,
2112 if (ost->sync_ist != ist_table[ost->source_index])
2113 fprintf(stderr, " [sync #%d.%d]",
2114 ost->sync_ist->file_index,
2115 ost->sync_ist->index);
2116 fprintf(stderr, "\n");
2121 fprintf(stderr, "%s\n", error);
2126 print_sdp(output_files, nb_output_files);
2129 if (!using_stdin && verbose >= 0) {
2130 fprintf(stderr, "Press [q] to stop encoding\n");
2131 url_set_interrupt_cb(decode_interrupt_cb);
2135 timer_start = av_gettime();
2137 for(; received_sigterm == 0;) {
2138 int file_index, ist_index;
2146 /* if 'q' pressed, exits */
2150 /* read_key() returns 0 on EOF */
2156 /* select the stream that we must read now by looking at the
2157 smallest output pts */
2159 for(i=0;i<nb_ostreams;i++) {
2162 os = output_files[ost->file_index];
2163 ist = ist_table[ost->source_index];
2164 if(no_packet[ist->file_index])
2166 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2167 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2169 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2170 ipts = (double)ist->pts;
2171 if (!file_table[ist->file_index].eof_reached){
2172 if(ipts < ipts_min) {
2174 if(input_sync ) file_index = ist->file_index;
2176 if(opts < opts_min) {
2178 if(!input_sync) file_index = ist->file_index;
2181 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2186 /* if none, if is finished */
2187 if (file_index < 0) {
2188 if(no_packet_count){
2190 memset(no_packet, 0, sizeof(no_packet));
2197 /* finish if recording time exhausted */
2198 if (opts_min >= (recording_time / 1000000.0))
2201 /* finish if limit size exhausted */
2202 if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2205 /* read a frame from it and output it in the fifo */
2206 is = input_files[file_index];
2207 ret= av_read_frame(is, &pkt);
2208 if(ret == AVERROR(EAGAIN)){
2209 no_packet[file_index]=1;
2214 file_table[file_index].eof_reached = 1;
2222 memset(no_packet, 0, sizeof(no_packet));
2225 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2227 /* the following test is needed in case new streams appear
2228 dynamically in stream : we ignore them */
2229 if (pkt.stream_index >= file_table[file_index].nb_streams)
2230 goto discard_packet;
2231 ist_index = file_table[file_index].ist_index + pkt.stream_index;
2232 ist = ist_table[ist_index];
2234 goto discard_packet;
2236 if (pkt.dts != AV_NOPTS_VALUE)
2237 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2238 if (pkt.pts != AV_NOPTS_VALUE)
2239 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2241 if(input_files_ts_scale[file_index][pkt.stream_index]){
2242 if(pkt.pts != AV_NOPTS_VALUE)
2243 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2244 if(pkt.dts != AV_NOPTS_VALUE)
2245 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2248 //av_log(NULL, AV_LOG_ERROR, "timestamp=%"PRId64" %"PRId64"\n", pkt.pts, pkt.dts);
2251 // 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);
2252 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2253 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2254 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2255 int64_t delta= pkt_dts - ist->next_pts;
2256 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2257 input_files_ts_offset[ist->file_index]-= delta;
2259 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2260 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2261 if(pkt.pts != AV_NOPTS_VALUE)
2262 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2266 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2267 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2270 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2271 ist->file_index, ist->index);
2274 av_free_packet(&pkt);
2281 av_free_packet(&pkt);
2283 /* dump report by using the output first video and audio streams */
2284 //print_report(output_files, ost_table, nb_ostreams, 0);
2287 /* at the end of stream, we must flush the decoder buffers */
2288 for(i=0;i<nb_istreams;i++) {
2290 if (ist->decoding_needed) {
2291 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2297 /* write the trailer if needed and close file */
2298 for(i=0;i<nb_output_files;i++) {
2299 os = output_files[i];
2300 av_write_trailer(os);
2303 /* dump report by using the first video and audio streams */
2304 print_report(output_files, ost_table, nb_ostreams, 1);
2306 /* close each encoder */
2307 for(i=0;i<nb_ostreams;i++) {
2309 if (ost->encoding_needed) {
2310 av_freep(&ost->st->codec->stats_in);
2311 avcodec_close(ost->st->codec);
2315 /* close each decoder */
2316 for(i=0;i<nb_istreams;i++) {
2318 if (ist->decoding_needed) {
2319 avcodec_close(ist->st->codec);
2327 av_freep(&bit_buffer);
2328 av_free(file_table);
2331 for(i=0;i<nb_istreams;i++) {
2338 for(i=0;i<nb_ostreams;i++) {
2342 fclose(ost->logfile);
2343 ost->logfile = NULL;
2345 av_fifo_free(ost->fifo); /* works even if fifo is not
2346 initialized but set to zero */
2347 av_free(ost->pict_tmp.data[0]);
2348 if (ost->video_resample)
2349 sws_freeContext(ost->img_resample_ctx);
2351 audio_resample_close(ost->resample);
2352 if (ost->reformat_ctx)
2353 av_audio_convert_free(ost->reformat_ctx);
2363 int file_read(const char *filename)
2366 unsigned char buffer[1024];
2369 if (url_open(&h, filename, O_RDONLY) < 0) {
2370 printf("could not open '%s'\n", filename);
2374 len = url_read(h, buffer, sizeof(buffer));
2377 for(i=0;i<len;i++) putchar(buffer[i]);
2384 static void opt_format(const char *arg)
2386 /* compatibility stuff for pgmyuv */
2387 if (!strcmp(arg, "pgmyuv")) {
2388 pgmyuv_compatibility_hack=1;
2389 // opt_image_format(arg);
2391 fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2394 file_iformat = av_find_input_format(arg);
2395 file_oformat = guess_format(arg, NULL, NULL);
2396 if (!file_iformat && !file_oformat) {
2397 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2402 static void opt_video_rc_override_string(const char *arg)
2404 video_rc_override_string = arg;
2407 static int opt_me_threshold(const char *opt, const char *arg)
2409 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2413 static int opt_loglevel(const char *opt, const char *arg)
2415 int level = parse_number_or_die(opt, arg, OPT_INT, INT_MIN, INT_MAX);
2416 av_log_set_level(level);
2420 static int opt_verbose(const char *opt, const char *arg)
2422 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2426 static int opt_frame_rate(const char *opt, const char *arg)
2428 if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2429 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2435 static int opt_bitrate(const char *opt, const char *arg)
2437 int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2439 opt_default(opt, arg);
2441 if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2442 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2447 static void opt_frame_crop_top(const char *arg)
2449 frame_topBand = atoi(arg);
2450 if (frame_topBand < 0) {
2451 fprintf(stderr, "Incorrect top crop size\n");
2454 if ((frame_topBand % 2) != 0) {
2455 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2458 if ((frame_topBand) >= frame_height){
2459 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2462 frame_height -= frame_topBand;
2465 static void opt_frame_crop_bottom(const char *arg)
2467 frame_bottomBand = atoi(arg);
2468 if (frame_bottomBand < 0) {
2469 fprintf(stderr, "Incorrect bottom crop size\n");
2472 if ((frame_bottomBand % 2) != 0) {
2473 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2476 if ((frame_bottomBand) >= frame_height){
2477 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2480 frame_height -= frame_bottomBand;
2483 static void opt_frame_crop_left(const char *arg)
2485 frame_leftBand = atoi(arg);
2486 if (frame_leftBand < 0) {
2487 fprintf(stderr, "Incorrect left crop size\n");
2490 if ((frame_leftBand % 2) != 0) {
2491 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2494 if ((frame_leftBand) >= frame_width){
2495 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2498 frame_width -= frame_leftBand;
2501 static void opt_frame_crop_right(const char *arg)
2503 frame_rightBand = atoi(arg);
2504 if (frame_rightBand < 0) {
2505 fprintf(stderr, "Incorrect right crop size\n");
2508 if ((frame_rightBand % 2) != 0) {
2509 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2512 if ((frame_rightBand) >= frame_width){
2513 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2516 frame_width -= frame_rightBand;
2519 static void opt_frame_size(const char *arg)
2521 if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2522 fprintf(stderr, "Incorrect frame size\n");
2525 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2526 fprintf(stderr, "Frame size must be a multiple of 2\n");
2532 #define SCALEBITS 10
2533 #define ONE_HALF (1 << (SCALEBITS - 1))
2534 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2536 #define RGB_TO_Y(r, g, b) \
2537 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2538 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2540 #define RGB_TO_U(r1, g1, b1, shift)\
2541 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2542 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2544 #define RGB_TO_V(r1, g1, b1, shift)\
2545 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2546 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2548 static void opt_pad_color(const char *arg) {
2549 /* Input is expected to be six hex digits similar to
2550 how colors are expressed in html tags (but without the #) */
2551 int rgb = strtol(arg, NULL, 16);
2555 g = ((rgb >> 8) & 255);
2558 padcolor[0] = RGB_TO_Y(r,g,b);
2559 padcolor[1] = RGB_TO_U(r,g,b,0);
2560 padcolor[2] = RGB_TO_V(r,g,b,0);
2563 static void opt_frame_pad_top(const char *arg)
2565 frame_padtop = atoi(arg);
2566 if (frame_padtop < 0) {
2567 fprintf(stderr, "Incorrect top pad size\n");
2570 if ((frame_padtop % 2) != 0) {
2571 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2576 static void opt_frame_pad_bottom(const char *arg)
2578 frame_padbottom = atoi(arg);
2579 if (frame_padbottom < 0) {
2580 fprintf(stderr, "Incorrect bottom pad size\n");
2583 if ((frame_padbottom % 2) != 0) {
2584 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2590 static void opt_frame_pad_left(const char *arg)
2592 frame_padleft = atoi(arg);
2593 if (frame_padleft < 0) {
2594 fprintf(stderr, "Incorrect left pad size\n");
2597 if ((frame_padleft % 2) != 0) {
2598 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2604 static void opt_frame_pad_right(const char *arg)
2606 frame_padright = atoi(arg);
2607 if (frame_padright < 0) {
2608 fprintf(stderr, "Incorrect right pad size\n");
2611 if ((frame_padright % 2) != 0) {
2612 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2617 static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2621 for (i=-1; i < nb_fmts; i++) {
2622 get_fmt_string (fmt_str, sizeof(fmt_str), i);
2623 fprintf(stdout, "%s\n", fmt_str);
2627 static void opt_frame_pix_fmt(const char *arg)
2629 if (strcmp(arg, "list")) {
2630 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2631 if (frame_pix_fmt == PIX_FMT_NONE) {
2632 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2636 list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2641 static void opt_frame_aspect_ratio(const char *arg)
2648 p = strchr(arg, ':');
2650 x = strtol(arg, &end, 10);
2652 y = strtol(end+1, &end, 10);
2654 ar = (double)x / (double)y;
2656 ar = strtod(arg, NULL);
2659 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2662 frame_aspect_ratio = ar;
2665 static int opt_metadata(const char *opt, const char *arg)
2667 char *mid= strchr(arg, '=');
2670 fprintf(stderr, "Missing =\n");
2676 metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2677 metadata[metadata_count-1].key = av_strdup(arg);
2678 metadata[metadata_count-1].value= av_strdup(mid);
2683 static void opt_qscale(const char *arg)
2685 video_qscale = atof(arg);
2686 if (video_qscale <= 0 ||
2687 video_qscale > 255) {
2688 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2693 static void opt_top_field_first(const char *arg)
2695 top_field_first= atoi(arg);
2698 static int opt_thread_count(const char *opt, const char *arg)
2700 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2703 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2708 static void opt_audio_sample_fmt(const char *arg)
2710 if (strcmp(arg, "list"))
2711 audio_sample_fmt = avcodec_get_sample_fmt(arg);
2713 list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2718 static int opt_audio_rate(const char *opt, const char *arg)
2720 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2724 static int opt_audio_channels(const char *opt, const char *arg)
2726 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2730 static void opt_video_channel(const char *arg)
2732 video_channel = strtol(arg, NULL, 0);
2735 static void opt_video_standard(const char *arg)
2737 video_standard = av_strdup(arg);
2740 static void opt_codec(int *pstream_copy, char **pcodec_name,
2741 int codec_type, const char *arg)
2743 av_freep(pcodec_name);
2744 if (!strcmp(arg, "copy")) {
2747 *pcodec_name = av_strdup(arg);
2751 static void opt_audio_codec(const char *arg)
2753 opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2756 static void opt_audio_tag(const char *arg)
2759 audio_codec_tag= strtol(arg, &tail, 0);
2762 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2765 static void opt_video_tag(const char *arg)
2768 video_codec_tag= strtol(arg, &tail, 0);
2771 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2774 static void opt_video_codec(const char *arg)
2776 opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2779 static void opt_subtitle_codec(const char *arg)
2781 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2784 static void opt_subtitle_tag(const char *arg)
2787 subtitle_codec_tag= strtol(arg, &tail, 0);
2790 subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2793 static void opt_map(const char *arg)
2798 m = &stream_maps[nb_stream_maps++];
2800 m->file_index = strtol(arg, &p, 0);
2804 m->stream_index = strtol(p, &p, 0);
2807 m->sync_file_index = strtol(p, &p, 0);
2810 m->sync_stream_index = strtol(p, &p, 0);
2812 m->sync_file_index = m->file_index;
2813 m->sync_stream_index = m->stream_index;
2817 static void opt_map_meta_data(const char *arg)
2822 m = &meta_data_maps[nb_meta_data_maps++];
2824 m->out_file = strtol(arg, &p, 0);
2828 m->in_file = strtol(p, &p, 0);
2831 static void opt_input_ts_scale(const char *arg)
2833 unsigned int stream;
2837 stream = strtol(arg, &p, 0);
2840 scale= strtod(p, &p);
2842 if(stream >= MAX_STREAMS)
2845 input_files_ts_scale[nb_input_files][stream]= scale;
2848 static int opt_recording_time(const char *opt, const char *arg)
2850 recording_time = parse_time_or_die(opt, arg, 1);
2854 static int opt_start_time(const char *opt, const char *arg)
2856 start_time = parse_time_or_die(opt, arg, 1);
2860 static int opt_rec_timestamp(const char *opt, const char *arg)
2862 rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2866 static int opt_input_ts_offset(const char *opt, const char *arg)
2868 input_ts_offset = parse_time_or_die(opt, arg, 1);
2872 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2874 const char *codec_string = encoder ? "encoder" : "decoder";
2878 return CODEC_ID_NONE;
2880 avcodec_find_encoder_by_name(name) :
2881 avcodec_find_decoder_by_name(name);
2883 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2886 if(codec->type != type) {
2887 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2893 static void opt_input_file(const char *filename)
2895 AVFormatContext *ic;
2896 AVFormatParameters params, *ap = ¶ms;
2897 int err, i, ret, rfps, rfps_base;
2900 if (!strcmp(filename, "-"))
2903 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2904 !strcmp(filename, "/dev/stdin");
2906 /* get default parameters from command line */
2907 ic = avformat_alloc_context();
2909 memset(ap, 0, sizeof(*ap));
2910 ap->prealloced_context = 1;
2911 ap->sample_rate = audio_sample_rate;
2912 ap->channels = audio_channels;
2913 ap->time_base.den = frame_rate.num;
2914 ap->time_base.num = frame_rate.den;
2915 ap->width = frame_width + frame_padleft + frame_padright;
2916 ap->height = frame_height + frame_padtop + frame_padbottom;
2917 ap->pix_fmt = frame_pix_fmt;
2918 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2919 ap->channel = video_channel;
2920 ap->standard = video_standard;
2921 ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2922 ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2923 if(pgmyuv_compatibility_hack)
2924 ap->video_codec_id= CODEC_ID_PGMYUV;
2926 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2928 ic->video_codec_id = find_codec_or_die(video_codec_name , CODEC_TYPE_VIDEO , 0);
2929 ic->audio_codec_id = find_codec_or_die(audio_codec_name , CODEC_TYPE_AUDIO , 0);
2930 ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2931 ic->flags |= AVFMT_FLAG_NONBLOCK;
2933 /* open the input file with generic libav function */
2934 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2936 print_error(filename, err);
2941 for(i=0; i<ic->nb_programs; i++)
2942 if(ic->programs[i]->id != opt_programid)
2943 ic->programs[i]->discard = AVDISCARD_ALL;
2946 ic->loop_input = loop_input;
2948 /* If not enough info to get the stream parameters, we decode the
2949 first frames to get it. (used in mpeg case for example) */
2950 ret = av_find_stream_info(ic);
2951 if (ret < 0 && verbose >= 0) {
2952 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2956 timestamp = start_time;
2957 /* add the stream start time */
2958 if (ic->start_time != AV_NOPTS_VALUE)
2959 timestamp += ic->start_time;
2961 /* if seeking requested, we execute it */
2962 if (start_time != 0) {
2963 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2965 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2966 filename, (double)timestamp / AV_TIME_BASE);
2968 /* reset seek info */
2972 /* update the current parameters so that they match the one of the input stream */
2973 for(i=0;i<ic->nb_streams;i++) {
2974 AVCodecContext *enc = ic->streams[i]->codec;
2976 avcodec_thread_init(enc, thread_count);
2977 enc->thread_count= thread_count;
2978 switch(enc->codec_type) {
2979 case CODEC_TYPE_AUDIO:
2980 set_context_opts(enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2981 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2982 channel_layout = enc->channel_layout;
2983 audio_channels = enc->channels;
2984 audio_sample_rate = enc->sample_rate;
2985 audio_sample_fmt = enc->sample_fmt;
2986 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
2988 ic->streams[i]->discard= AVDISCARD_ALL;
2990 case CODEC_TYPE_VIDEO:
2991 set_context_opts(enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2992 frame_height = enc->height;
2993 frame_width = enc->width;
2994 if(ic->streams[i]->sample_aspect_ratio.num)
2995 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
2997 frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
2998 frame_aspect_ratio *= (float) enc->width / enc->height;
2999 frame_pix_fmt = enc->pix_fmt;
3000 rfps = ic->streams[i]->r_frame_rate.num;
3001 rfps_base = ic->streams[i]->r_frame_rate.den;
3002 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
3004 enc->debug |= FF_DEBUG_MV;
3006 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
3009 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3010 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
3012 (float)rfps / rfps_base, rfps, rfps_base);
3014 /* update the current frame rate to match the stream frame rate */
3015 frame_rate.num = rfps;
3016 frame_rate.den = rfps_base;
3018 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
3020 ic->streams[i]->discard= AVDISCARD_ALL;
3021 else if(video_discard)
3022 ic->streams[i]->discard= video_discard;
3024 case CODEC_TYPE_DATA:
3026 case CODEC_TYPE_SUBTITLE:
3027 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
3028 if(subtitle_disable)
3029 ic->streams[i]->discard = AVDISCARD_ALL;
3031 case CODEC_TYPE_ATTACHMENT:
3032 case CODEC_TYPE_UNKNOWN:
3040 input_files[nb_input_files] = ic;
3041 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3042 /* dump the file content */
3044 dump_format(ic, nb_input_files, filename, 0);
3047 file_iformat = NULL;
3048 file_oformat = NULL;
3052 av_freep(&video_codec_name);
3053 av_freep(&audio_codec_name);
3054 av_freep(&subtitle_codec_name);
3057 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3058 int *has_subtitle_ptr)
3060 int has_video, has_audio, has_subtitle, i, j;
3061 AVFormatContext *ic;
3066 for(j=0;j<nb_input_files;j++) {
3067 ic = input_files[j];
3068 for(i=0;i<ic->nb_streams;i++) {
3069 AVCodecContext *enc = ic->streams[i]->codec;
3070 switch(enc->codec_type) {
3071 case CODEC_TYPE_AUDIO:
3074 case CODEC_TYPE_VIDEO:
3077 case CODEC_TYPE_SUBTITLE:
3080 case CODEC_TYPE_DATA:
3081 case CODEC_TYPE_ATTACHMENT:
3082 case CODEC_TYPE_UNKNOWN:
3089 *has_video_ptr = has_video;
3090 *has_audio_ptr = has_audio;
3091 *has_subtitle_ptr = has_subtitle;
3094 static void new_video_stream(AVFormatContext *oc)
3097 AVCodecContext *video_enc;
3100 st = av_new_stream(oc, oc->nb_streams);
3102 fprintf(stderr, "Could not alloc stream\n");
3105 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
3106 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3107 video_bitstream_filters= NULL;
3110 avcodec_thread_init(st->codec, thread_count);
3112 video_enc = st->codec;
3115 video_enc->codec_tag= video_codec_tag;
3117 if( (video_global_header&1)
3118 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3119 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3120 avcodec_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3122 if(video_global_header&2){
3123 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3124 avcodec_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3127 if (video_stream_copy) {
3128 st->stream_copy = 1;
3129 video_enc->codec_type = CODEC_TYPE_VIDEO;
3130 video_enc->sample_aspect_ratio =
3131 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3136 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3138 if (video_codec_name) {
3139 codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3140 codec = avcodec_find_encoder_by_name(video_codec_name);
3141 output_codecs[nb_ocodecs] = codec;
3143 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3144 codec = avcodec_find_encoder(codec_id);
3147 video_enc->codec_id = codec_id;
3149 set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3151 if (codec && codec->supported_framerates && !force_fps)
3152 fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3153 video_enc->time_base.den = fps.num;
3154 video_enc->time_base.num = fps.den;
3156 video_enc->width = frame_width + frame_padright + frame_padleft;
3157 video_enc->height = frame_height + frame_padtop + frame_padbottom;
3158 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3159 video_enc->pix_fmt = frame_pix_fmt;
3160 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3162 if(codec && codec->pix_fmts){
3163 const enum PixelFormat *p= codec->pix_fmts;
3165 if(*p == video_enc->pix_fmt)
3169 video_enc->pix_fmt = codec->pix_fmts[0];
3173 video_enc->gop_size = 0;
3174 if (video_qscale || same_quality) {
3175 video_enc->flags |= CODEC_FLAG_QSCALE;
3176 video_enc->global_quality=
3177 st->quality = FF_QP2LAMBDA * video_qscale;
3181 video_enc->intra_matrix = intra_matrix;
3183 video_enc->inter_matrix = inter_matrix;
3185 video_enc->thread_count = thread_count;
3186 p= video_rc_override_string;
3189 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3191 fprintf(stderr, "error parsing rc_override\n");
3194 video_enc->rc_override=
3195 av_realloc(video_enc->rc_override,
3196 sizeof(RcOverride)*(i+1));
3197 video_enc->rc_override[i].start_frame= start;
3198 video_enc->rc_override[i].end_frame = end;
3200 video_enc->rc_override[i].qscale= q;
3201 video_enc->rc_override[i].quality_factor= 1.0;
3204 video_enc->rc_override[i].qscale= 0;
3205 video_enc->rc_override[i].quality_factor= -q/100.0;
3210 video_enc->rc_override_count=i;
3211 if (!video_enc->rc_initial_buffer_occupancy)
3212 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3213 video_enc->me_threshold= me_threshold;
3214 video_enc->intra_dc_precision= intra_dc_precision - 8;
3217 video_enc->flags|= CODEC_FLAG_PSNR;
3222 video_enc->flags |= CODEC_FLAG_PASS1;
3224 video_enc->flags |= CODEC_FLAG_PASS2;
3230 /* reset some key parameters */
3232 av_freep(&video_codec_name);
3233 video_stream_copy = 0;
3236 static void new_audio_stream(AVFormatContext *oc)
3239 AVCodecContext *audio_enc;
3242 st = av_new_stream(oc, oc->nb_streams);
3244 fprintf(stderr, "Could not alloc stream\n");
3247 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3249 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3250 audio_bitstream_filters= NULL;
3253 avcodec_thread_init(st->codec, thread_count);
3255 audio_enc = st->codec;
3256 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3259 audio_enc->codec_tag= audio_codec_tag;
3261 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3262 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3263 avcodec_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3265 if (audio_stream_copy) {
3266 st->stream_copy = 1;
3267 audio_enc->channels = audio_channels;
3271 set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3273 if (audio_codec_name) {
3274 codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3275 codec = avcodec_find_encoder_by_name(audio_codec_name);
3276 output_codecs[nb_ocodecs] = codec;
3278 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3279 codec = avcodec_find_encoder(codec_id);
3281 audio_enc->codec_id = codec_id;
3283 if (audio_qscale > QSCALE_NONE) {
3284 audio_enc->flags |= CODEC_FLAG_QSCALE;
3285 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3287 audio_enc->thread_count = thread_count;
3288 audio_enc->channels = audio_channels;
3289 audio_enc->sample_fmt = audio_sample_fmt;
3290 audio_enc->channel_layout = channel_layout;
3291 if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3292 audio_enc->channel_layout = 0;
3294 if(codec && codec->sample_fmts){
3295 const enum SampleFormat *p= codec->sample_fmts;
3297 if(*p == audio_enc->sample_fmt)
3301 audio_enc->sample_fmt = codec->sample_fmts[0];
3305 audio_enc->sample_rate = audio_sample_rate;
3306 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3307 if (audio_language) {
3308 av_metadata_set(&st->metadata, "language", audio_language);
3309 av_free(audio_language);
3310 audio_language = NULL;
3313 /* reset some key parameters */
3315 av_freep(&audio_codec_name);
3316 audio_stream_copy = 0;
3319 static void new_subtitle_stream(AVFormatContext *oc)
3322 AVCodecContext *subtitle_enc;
3324 st = av_new_stream(oc, oc->nb_streams);
3326 fprintf(stderr, "Could not alloc stream\n");
3329 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3331 bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3332 subtitle_bitstream_filters= NULL;
3334 subtitle_enc = st->codec;
3335 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3337 if(subtitle_codec_tag)
3338 subtitle_enc->codec_tag= subtitle_codec_tag;
3340 if (subtitle_stream_copy) {
3341 st->stream_copy = 1;
3343 set_context_opts(avcodec_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3344 subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3345 output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3349 if (subtitle_language) {
3350 av_metadata_set(&st->metadata, "language", subtitle_language);
3351 av_free(subtitle_language);
3352 subtitle_language = NULL;
3355 subtitle_disable = 0;
3356 av_freep(&subtitle_codec_name);
3357 subtitle_stream_copy = 0;
3360 static void opt_new_audio_stream(void)
3362 AVFormatContext *oc;
3363 if (nb_output_files <= 0) {
3364 fprintf(stderr, "At least one output file must be specified\n");
3367 oc = output_files[nb_output_files - 1];
3368 new_audio_stream(oc);
3371 static void opt_new_video_stream(void)
3373 AVFormatContext *oc;
3374 if (nb_output_files <= 0) {
3375 fprintf(stderr, "At least one output file must be specified\n");
3378 oc = output_files[nb_output_files - 1];
3379 new_video_stream(oc);
3382 static void opt_new_subtitle_stream(void)
3384 AVFormatContext *oc;
3385 if (nb_output_files <= 0) {
3386 fprintf(stderr, "At least one output file must be specified\n");
3389 oc = output_files[nb_output_files - 1];
3390 new_subtitle_stream(oc);
3393 static void opt_output_file(const char *filename)
3395 AVFormatContext *oc;
3396 int use_video, use_audio, use_subtitle;
3397 int input_has_video, input_has_audio, input_has_subtitle;
3398 AVFormatParameters params, *ap = ¶ms;
3400 if (!strcmp(filename, "-"))
3403 oc = avformat_alloc_context();
3405 if (!file_oformat) {
3406 file_oformat = guess_format(NULL, filename, NULL);
3407 if (!file_oformat) {
3408 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3414 oc->oformat = file_oformat;
3415 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3417 if (!strcmp(file_oformat->name, "ffm") &&
3418 av_strstart(filename, "http:", NULL)) {
3419 /* special case for files sent to ffserver: we get the stream
3420 parameters from ffserver */
3421 int err = read_ffserver_streams(oc, filename);
3423 print_error(filename, err);
3427 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3428 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3429 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3431 /* disable if no corresponding type found and at least one
3433 if (nb_input_files > 0) {
3434 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3435 &input_has_subtitle);
3436 if (!input_has_video)
3438 if (!input_has_audio)
3440 if (!input_has_subtitle)
3444 /* manual disable */
3445 if (audio_disable) {
3448 if (video_disable) {
3451 if (subtitle_disable) {
3456 new_video_stream(oc);
3460 new_audio_stream(oc);
3464 new_subtitle_stream(oc);
3467 oc->timestamp = rec_timestamp;
3469 for(; metadata_count>0; metadata_count--){
3470 av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3471 metadata[metadata_count-1].value);
3473 av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3476 output_files[nb_output_files++] = oc;
3478 /* check filename in case of an image number is expected */
3479 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3480 if (!av_filename_number_test(oc->filename)) {
3481 print_error(oc->filename, AVERROR_NUMEXPECTED);
3486 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3487 /* test if it already exists to avoid loosing precious files */
3488 if (!file_overwrite &&
3489 (strchr(filename, ':') == NULL ||
3490 filename[1] == ':' ||
3491 av_strstart(filename, "file:", NULL))) {
3492 if (url_exist(filename)) {
3494 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3496 if (!read_yesno()) {
3497 fprintf(stderr, "Not overwriting - exiting\n");
3502 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3510 if (url_fopen(&oc->pb, filename, o_direct ? URL_RDWR|URL_DIRECT : URL_WRONLY) < 0) {
3511 fprintf(stderr, "Could not open '%s'\n", filename);
3517 for (i=0; i<0x81; i++) {
3518 put_le32(oc->pb, i);
3520 put_flush_packet(oc->pb);
3522 url_close_buf(oc->pb);
3528 memset(ap, 0, sizeof(*ap));
3529 if (av_set_parameters(oc, ap) < 0) {
3530 fprintf(stderr, "%s: Invalid encoding parameters\n",
3535 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3536 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3537 oc->loop_output = loop_output;
3538 oc->flags |= AVFMT_FLAG_NONBLOCK;
3540 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3542 /* reset some options */
3543 file_oformat = NULL;
3544 file_iformat = NULL;
3547 /* same option as mencoder */
3548 static void opt_pass(const char *pass_str)
3551 pass = atoi(pass_str);
3552 if (pass != 1 && pass != 2) {
3553 fprintf(stderr, "pass number can be only 1 or 2\n");
3559 static int64_t getutime(void)
3562 struct rusage rusage;
3564 getrusage(RUSAGE_SELF, &rusage);
3565 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3566 #elif HAVE_GETPROCESSTIMES
3568 FILETIME c, e, k, u;
3569 proc = GetCurrentProcess();
3570 GetProcessTimes(proc, &c, &e, &k, &u);
3571 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3573 return av_gettime();
3577 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3580 const char *p = str;
3587 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3594 static void opt_inter_matrix(const char *arg)
3596 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3597 parse_matrix_coeffs(inter_matrix, arg);
3600 static void opt_intra_matrix(const char *arg)
3602 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3603 parse_matrix_coeffs(intra_matrix, arg);
3607 * Trivial log callback.
3608 * Only suitable for show_help and similar since it lacks prefix handling.
3610 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3612 vfprintf(stdout, fmt, vl);
3615 static void show_help(void)
3617 av_log_set_callback(log_callback_help);
3618 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3619 "Hyper fast Audio and Video encoder\n");
3621 show_help_options(options, "Main options:\n",
3622 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3623 show_help_options(options, "\nAdvanced options:\n",
3624 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3626 show_help_options(options, "\nVideo options:\n",
3627 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3629 show_help_options(options, "\nAdvanced Video options:\n",
3630 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3631 OPT_VIDEO | OPT_EXPERT);
3632 show_help_options(options, "\nAudio options:\n",
3633 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3635 show_help_options(options, "\nAdvanced Audio options:\n",
3636 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3637 OPT_AUDIO | OPT_EXPERT);
3638 show_help_options(options, "\nSubtitle options:\n",
3639 OPT_SUBTITLE | OPT_GRAB,
3641 show_help_options(options, "\nAudio/Video grab options:\n",
3645 av_opt_show(avcodec_opts[0], NULL);
3647 av_opt_show(avformat_opts, NULL);
3649 av_opt_show(sws_opts, NULL);
3652 static void opt_target(const char *arg)
3655 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3657 if(!strncmp(arg, "pal-", 4)) {
3660 } else if(!strncmp(arg, "ntsc-", 5)) {
3663 } else if(!strncmp(arg, "film-", 5)) {
3668 /* Calculate FR via float to avoid int overflow */
3669 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3672 } else if((fr == 29970) || (fr == 23976)) {
3675 /* Try to determine PAL/NTSC by peeking in the input files */
3676 if(nb_input_files) {
3678 for(j = 0; j < nb_input_files; j++) {
3679 for(i = 0; i < input_files[j]->nb_streams; i++) {
3680 AVCodecContext *c = input_files[j]->streams[i]->codec;
3681 if(c->codec_type != CODEC_TYPE_VIDEO)
3683 fr = c->time_base.den * 1000 / c->time_base.num;
3687 } else if((fr == 29970) || (fr == 23976)) {
3697 if(verbose && norm >= 0)
3698 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3702 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3703 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3704 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3708 if(!strcmp(arg, "vcd")) {
3710 opt_video_codec("mpeg1video");
3711 opt_audio_codec("mp2");
3714 opt_frame_size(norm ? "352x240" : "352x288");
3715 opt_frame_rate(NULL, frame_rates[norm]);
3716 opt_default("gop", norm ? "18" : "15");
3718 opt_default("b", "1150000");
3719 opt_default("maxrate", "1150000");
3720 opt_default("minrate", "1150000");
3721 opt_default("bufsize", "327680"); // 40*1024*8;
3723 opt_default("ab", "224000");
3724 audio_sample_rate = 44100;
3727 opt_default("packetsize", "2324");
3728 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3730 /* We have to offset the PTS, so that it is consistent with the SCR.
3731 SCR starts at 36000, but the first two packs contain only padding
3732 and the first pack from the other stream, respectively, may also have
3733 been written before.
3734 So the real data starts at SCR 36000+3*1200. */
3735 mux_preload= (36000+3*1200) / 90000.0; //0.44
3736 } else if(!strcmp(arg, "svcd")) {
3738 opt_video_codec("mpeg2video");
3739 opt_audio_codec("mp2");
3742 opt_frame_size(norm ? "480x480" : "480x576");
3743 opt_frame_rate(NULL, frame_rates[norm]);
3744 opt_default("gop", norm ? "18" : "15");
3746 opt_default("b", "2040000");
3747 opt_default("maxrate", "2516000");
3748 opt_default("minrate", "0"); //1145000;
3749 opt_default("bufsize", "1835008"); //224*1024*8;
3750 opt_default("flags", "+scan_offset");
3753 opt_default("ab", "224000");
3754 audio_sample_rate = 44100;
3756 opt_default("packetsize", "2324");
3758 } else if(!strcmp(arg, "dvd")) {
3760 opt_video_codec("mpeg2video");
3761 opt_audio_codec("ac3");
3764 opt_frame_size(norm ? "720x480" : "720x576");
3765 opt_frame_rate(NULL, frame_rates[norm]);
3766 opt_default("gop", norm ? "18" : "15");
3768 opt_default("b", "6000000");
3769 opt_default("maxrate", "9000000");
3770 opt_default("minrate", "0"); //1500000;
3771 opt_default("bufsize", "1835008"); //224*1024*8;
3773 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3774 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3776 opt_default("ab", "448000");
3777 audio_sample_rate = 48000;
3779 } else if(!strncmp(arg, "dv", 2)) {
3783 opt_frame_size(norm ? "720x480" : "720x576");
3784 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3785 (norm ? "yuv411p" : "yuv420p"));
3786 opt_frame_rate(NULL, frame_rates[norm]);
3788 audio_sample_rate = 48000;
3792 fprintf(stderr, "Unknown target: %s\n", arg);
3797 static void opt_vstats_file (const char *arg)
3799 av_free (vstats_filename);
3800 vstats_filename=av_strdup (arg);
3803 static void opt_vstats (void)
3806 time_t today2 = time(NULL);
3807 struct tm *today = localtime(&today2);
3809 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3811 opt_vstats_file(filename);
3814 static int opt_bsf(const char *opt, const char *arg)
3816 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3817 AVBitStreamFilterContext **bsfp;
3820 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3824 bsfp= *opt == 'v' ? &video_bitstream_filters :
3825 *opt == 'a' ? &audio_bitstream_filters :
3826 &subtitle_bitstream_filters;
3828 bsfp= &(*bsfp)->next;
3835 static int opt_preset(const char *opt, const char *arg)
3838 char filename[1000], tmp[1000], tmp2[1000], line[1000];
3840 const char *base[2]= { getenv("HOME"),
3843 for(i=!base[0]; i<2 && !f; i++){
3844 snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
3845 f= fopen(filename, "r");
3847 char *codec_name= *opt == 'v' ? video_codec_name :
3848 *opt == 'a' ? audio_codec_name :
3849 subtitle_codec_name;
3850 snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i], i ? "" : "/.ffmpeg", codec_name, arg);
3851 f= fopen(filename, "r");
3854 if(!f && ((arg[0]=='.' && arg[1]=='/') || arg[0]=='/' ||
3856 av_strlcpy(filename, arg, sizeof(filename));
3857 f= fopen(filename, "r");
3861 fprintf(stderr, "File for preset '%s' not found\n", arg);
3866 int e= fscanf(f, "%999[^\n]\n", line) - 1;
3867 if(line[0] == '#' && !e)
3869 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3871 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3874 if(!strcmp(tmp, "acodec")){
3875 opt_audio_codec(tmp2);
3876 }else if(!strcmp(tmp, "vcodec")){
3877 opt_video_codec(tmp2);
3878 }else if(!strcmp(tmp, "scodec")){
3879 opt_subtitle_codec(tmp2);
3880 }else if(opt_default(tmp, tmp2) < 0){
3881 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3891 static const OptionDef options[] = {
3893 { "renegotiate", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&renegotiate}, "renegotiate after several video frames", "number" },
3894 { "L", OPT_EXIT, {(void*)show_license}, "show license" },
3895 { "h", OPT_EXIT, {(void*)show_help}, "show help" },
3896 { "version", OPT_EXIT, {(void*)show_version}, "show version" },
3897 { "formats", OPT_EXIT, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3898 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3899 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3900 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3901 { "direct", OPT_BOOL, {(void*)&o_direct}, "write to output file using direct I/O (O_DIRECT)" },
3902 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3903 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3904 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3905 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3906 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3907 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3908 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
3909 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_rec_timestamp}, "set the timestamp ('now' to set the current time)", "time" },
3910 { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
3911 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3912 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3913 "add timings for benchmarking" },
3914 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3915 "dump each input packet" },
3916 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3917 "when dumping packets, also dump the payload" },
3918 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3919 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3920 { "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)", "" },
3921 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
3922 { "loglevel", HAS_ARG | OPT_FUNC2, {(void*)opt_loglevel}, "set libav* logging level", "number" },
3923 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3924 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3925 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3926 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3927 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3928 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3929 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3930 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3931 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3932 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3933 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
3934 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
3937 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3938 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3939 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3940 { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3941 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3942 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3943 { "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" },
3944 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3945 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3946 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3947 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3948 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3949 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3950 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3951 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3952 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3953 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3954 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3955 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3956 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3957 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3958 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3959 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
3960 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3961 "use same video quality as source (implies VBR)" },
3962 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3963 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
3964 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3965 "deinterlace pictures" },
3966 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3967 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3968 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3969 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3970 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3971 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3972 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3973 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3974 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3975 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3976 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
3979 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3980 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3981 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3982 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3983 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3984 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3985 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3986 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3987 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3988 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3989 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3990 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_sample_fmt}, "set sample format, 'list' as argument shows all the sample formats supported", "format" },
3992 /* subtitle options */
3993 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3994 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3995 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3996 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3997 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4000 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4001 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4002 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4005 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4006 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4008 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4009 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4010 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4012 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4013 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4014 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4016 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4020 #ifdef CONFIG_FFMPEG_WITH_FRSH
4022 void *av_encode_thread(void *arg)
4025 frsh_thread_id_t thread_id;
4027 /* bind this thread to vres */
4028 thread_id = fosa_thread_self();
4029 PXW(frsh_thread_bind(disk_vres, thread_id));
4031 ret = av_encode(output_files, nb_output_files,
4032 input_files, nb_input_files,
4033 stream_maps, nb_stream_maps);
4034 return (void*)(intptr_t)ret;
4039 frsh_thread_attr_t frsh_attr;
4040 frsh_thread_id_t thread;
4041 frsh_vres_id_t cpu_vres;
4042 frsh_contract_t cpu_contract;
4043 frsh_rel_time_t cpu_budget, cpu_period;
4045 frsh_rel_time_t disk_budget, disk_period;
4051 cpu_budget = fosa_msec_to_rel_time(5);
4052 cpu_period = fosa_msec_to_rel_time(1000/50);
4055 #define DISK_THROUGHPUT 20277LLU /* units??? probably MB/s */
4056 disk_budget = fosa_nsec_to_rel_time(1000000000LLU/*nsec/s*/ * 500000 /*bytes/s*/
4057 / (DISK_THROUGHPUT*1000000) /* bytes */); // is this correct?
4059 disk_budget = fosa_msec_to_rel_time(1);
4061 disk_period = fosa_msec_to_rel_time(1000/30);
4063 /* Contract negotiation for CPU */
4064 ret = frsh_contract_init(&cpu_contract);
4065 if (ret) PERROR_AND_EXIT(ret, "CPU:frsh_contract_init");
4067 ret = frsh_contract_set_basic_params(&cpu_contract,
4072 if (ret) PERROR_AND_EXIT(ret, "frsh_contract_set_basic_params");
4073 ret = frsh_contract_set_resource_and_label(&cpu_contract,
4074 FRSH_RT_PROCESSOR, FRSH_CPU_ID_DEFAULT, "recorder");
4075 if (ret) PERROR_AND_EXIT(ret, "frsh_contract_set_resource_and_label");
4077 ret = frsh_contract_negotiate(&cpu_contract, &cpu_vres);
4078 if (ret) PERROR_AND_EXIT(ret, "frsh_contract_negotiate cpu");
4079 printf("Aqcpu vres negotiated\n");
4081 /* Contract negotiation for Disk */
4082 ret = frsh_contract_init(&disk_contract);
4083 if (ret) PERROR_AND_EXIT(ret, "DISK:frsh_contract_init");
4085 ret = frsh_contract_set_basic_params(&disk_contract,
4088 FRSH_WT_INDETERMINATE,
4090 if (ret) PERROR_AND_EXIT(ret, "frsh_contract_set_basic_params");
4091 ret = frsh_contract_set_resource_and_label(&disk_contract,
4092 FRSH_RT_DISK, 0, output_files[0]->filename);
4093 if (ret) PERROR_AND_EXIT(ret, "frsh_contract_set_resource_and_label");
4095 ret = frsh_contract_negotiate(&disk_contract, &disk_vres);
4096 if (ret) PERROR_AND_EXIT(ret, "frsh_contract_negotiate disk");
4097 printf("Disk vres negotiated\n");
4099 pthread_attr_init(&frsh_attr);
4100 ret = frsh_thread_create_and_bind(cpu_vres, &thread, &frsh_attr,
4101 av_encode_thread, (void*) NULL);
4102 if (ret) PERROR_AND_EXIT(ret, "frsh_thread_create_and_bind");
4104 pthread_join(thread.pthread_id, (void**) NULL);
4106 printf("Ending contracts\n");
4108 ret = frsh_contract_cancel(cpu_vres);
4109 ret = frsh_contract_cancel(disk_vres);
4110 if (ret) PERROR_AND_EXIT(ret, "frsh_contract_cancel");
4112 printf("Finishing\n");
4115 #endif /* CONFIG_FFMPEG_WITH_FRSH */
4117 void flush_buffered_frames(AVFormatContext *s)
4120 while ((pktl = s->packet_buffer)) {
4121 av_free_packet(&pktl->pkt);
4122 s->packet_buffer = pktl->next;
4127 int main(int argc, char **argv)
4132 avcodec_register_all();
4133 avdevice_register_all();
4136 if(isatty(STDIN_FILENO))
4137 url_set_interrupt_cb(decode_interrupt_cb);
4139 for(i=0; i<CODEC_TYPE_NB; i++){
4140 avcodec_opts[i]= avcodec_alloc_context2(i);
4142 avformat_opts = avformat_alloc_context();
4143 sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
4148 parse_options(argc, argv, options, opt_output_file);
4150 if (nb_input_files == 0) {
4151 opt_input_file("sdp.txt");
4154 /* file converter / grab */
4155 if (nb_output_files <= 0) {
4157 opt_output_file("stream.mp4");
4160 for (i=0; i<nb_input_files; i++)
4161 flush_buffered_frames(input_files[i]);
4164 #if CONFIG_FFMPEG_WITH_FRSH
4165 if (frsh_stuff() < 0)
4168 if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
4169 stream_maps, nb_stream_maps) < 0)
4172 ti = getutime() - ti;
4174 printf("bench: utime=%0.3fs\n", ti / 1000000.0);