finished most of decode flow

+#include "AVDecoder.h"
+
+
+CAVDecoder::CAVDecoder() :
+_a_start_time_ms(INT64_MAX),
+_v_start_time_ms(INT64_MAX),
+_cur_a_ts_ms(INT64_MAX),
+_cur_v_ts_ms(INT64_MAX),
+_end_time_ms(0),
+_cur_a_frame(NULL),
+_cur_v_frame(NULL)
+{
+}
+
+
+CAVDecoder::~CAVDecoder()
+{
+}
+
+int CAVDecoder::add(media_info &info)
+{
+	if (info.m_type == mt_audio) {
+		_a_start_time_ms = info.start_time_ms;
+		_a_end_time_ms = info.end_time_ms;
+		_audio_info.push_back(info);
+		_audio_decoder.add(info);
+	}
+	else {
+		_v_start_time_ms = info.start_time_ms;
+		_v_end_time_ms = info.end_time_ms;
+		_video_info.push_back(info);
+		_video_decoder.add(info);
+	}
+
+	if (_cur_a_ts_ms == INT64_MAX) {
+		_cur_a_ts_ms = info.start_time_ms;
+		_cur_v_ts_ms = info.start_time_ms;
+	}
+
+	if (_end_time_ms < info.end_time_ms) {
+		_end_time_ms = info.end_time_ms;
+	}
+
+	return 0;
+}
+
+unsigned int CAVDecoder::getuid()
+{
+	return 0;
+}
+
+bool CAVDecoder::get_one_v_frame()
+{
+	int64_t ts;
+	int ret = -1;
+	if (_video_info.size()) {
+		ret = _video_decoder.get_one_frame(&_cur_v_frame, ts);
+		if (ret == 0) {
+			_cur_v_ts_ms = _v_start_time_ms + ts;
+		}
+		else {
+			_video_info.pop_front();
+			if (_cur_v_ts_ms < _end_time_ms) {
+				_cur_v_ts_ms += 50;//return last v frame
+				ret = 0;
+			}
+		}
+	}
+
+	if (ret) {//no video decoded
+		if (_cur_v_ts_ms < _end_time_ms) {//should have as video frame
+			_cur_v_ts_ms += 50;//return last v frame
+			ret = 0;
+			if (!_cur_v_frame) {
+				_cur_v_frame = get_blank_frame();
+			}
+    	}
+	}
+
+	return ret == 0;
+}
+
+AVFrame * CAVDecoder::get_blank_frame()
+{
+	return NULL;
+}
+
+AVFrame * CAVDecoder::get_silence_frame()
+{
+	return NULL;
+}
+
+
+
+void CAVDecoder::free_cur_a_frame()
+{
+	if (_cur_a_frame) {
+		av_frame_free(&_cur_a_frame);
+	}
+}
+
+
+void CAVDecoder::free_cur_v_frame()
+{
+	if (_cur_v_frame) {
+		av_frame_free(&_cur_v_frame);
+	}
+}
+
+bool CAVDecoder::get_one_a_frame()
+{
+	int64_t ts;
+	int ret = -1;
+	if (_audio_info.size()) {
+		ret = _audio_decoder.get_one_frame(&_cur_v_frame, ts);
+		if (ret == 0) {
+			_cur_a_ts_ms = _a_start_time_ms + ts;
+		}
+		else {
+			_audio_info.pop_front();
+			if (_cur_a_ts_ms < _end_time_ms) {
+				_cur_a_ts_ms += AFRAME_DURATION_MS;//return silence frame
+				ret = 0;
+			}
+		}
+	}
+
+	if (ret) {//no video decoded
+		if (_cur_a_ts_ms < _end_time_ms) {//should have a audio frame
+			_cur_a_ts_ms += AFRAME_DURATION_MS;//return last a frame
+			ret = 0;
+			if (!_cur_a_frame) {
+				_cur_a_frame = get_silence_frame();
+			}
+		}
+	}
+
+	return ret == 0;
+}

+#pragma once
+#include "AudioDecoder.h"
+#include "VideoDecoder.h"
+
+class CAVDecoder
+{
+public:
+	CAVDecoder();
+	virtual ~CAVDecoder();
+
+	int add(media_info &info);
+
+	unsigned int getuid();
+	bool get_one_a_frame();
+	bool get_one_v_frame();
+	int64_t _cur_a_ts_ms;
+	int64_t _cur_v_ts_ms;
+
+protected:
+	list<media_info> _video_info;
+	list<media_info> _audio_info;
+	CAudioDecoder _audio_decoder;
+	CVideoDecoder _video_decoder;
+	int64_t _a_start_time_ms;
+	int64_t _a_end_time_ms;
+	int64_t _v_start_time_ms;
+	int64_t _v_end_time_ms;
+	int64_t _end_time_ms;
+	AVFrame * _cur_a_frame;
+	AVFrame * _cur_v_frame;
+private:
+	AVFrame * get_blank_frame();
+	AVFrame * get_silence_frame();
+public:
+	void free_cur_a_frame();
+	void free_cur_v_frame();
+};
+

+#include "AVTranscoder.h"
+
+
+CAVTranscoder::CAVTranscoder():
+_start_time(INT64_MAX),
+_all_processed(true)
+{
+}
+
+
+CAVTranscoder::~CAVTranscoder()
+{
+}
+
+int CAVTranscoder::add(media_info & info)
+{
+	_all_processed = false;
+	if (_start_time == INT64_MAX) {
+		_start_time = info.start_time_ms;
+		_cur_v_time = _start_time;
+		_cur_a_time = _start_time;
+	}
+	vector < CAVDecoder *>::iterator it = _decoders.begin();
+	for (; it != _decoders.end(); it++) {
+		if ((*it)->getuid() == info.uid){
+			(*it)->add(info);
+			break;
+		}
+	}
+	if (it == _decoders.end()) {
+		CAVDecoder * pVideoDecoder = new CAVDecoder();
+		pVideoDecoder->add(info);
+		_decoders.push_back(pVideoDecoder);
+	}
+	return 0;
+}
+
+int64_t CAVTranscoder::transcode()
+{
+	vector<CAVDecoder *> decoders_got_frame;
+	vector < CAVDecoder *>::iterator it = _decoders.begin();
+	for (; it != _decoders.end();) {
+		if((*it)->get_one_v_frame()){
+			decoders_got_frame.push_back(*it);
+		}
+		else {
+			it = _decoders.erase(it);
+			continue;
+		}
+		it++;
+	}
+	
+	_all_processed = decoders_got_frame.size() == 0;
+	mix_and_output_vframe(decoders_got_frame);
+
+	_cur_v_time += 50;
+	//sws_scale(img_convert_ctx, (const uint8_t* const*)pFrame->data, pFrame->linesize, 0, pCodecCtx->height, pFrameYUV->data, pFrameYUV->linesize);
+	
+	while (_cur_a_time < _cur_v_time)
+	{
+		decoders_got_frame.clear();
+		vector < CAVDecoder *>::iterator it = _decoders.begin();
+		for (; it != _decoders.end();) {
+			if ((*it)->get_one_a_frame()){
+				decoders_got_frame.push_back(*it);
+			}
+			else {
+				it = _decoders.erase(it);
+				continue;
+			}
+			it++;
+		}
+		mix_and_output_aframe(decoders_got_frame);
+		_cur_a_time += AFRAME_DURATION_MS;
+	}
+	
+	return _cur_v_time;
+}
+
+bool CAVTranscoder::all_processed()
+{
+	return _all_processed;
+}
+
+int CAVTranscoder::close()
+{
+	return 0;
+}
+
+
+int CAVTranscoder::open_output_file(const char *filename)
+{
+	AVStream *out_stream;
+	AVCodecContext *dec_ctx, *enc_ctx;
+	AVCodec *encoder;
+	int ret;
+	unsigned int i;
+
+	ofmt_ctx = NULL;
+	avformat_alloc_output_context2(&ofmt_ctx, NULL, NULL, filename);
+	if (!ofmt_ctx) {
+		av_log(NULL, AV_LOG_ERROR, "Could not create output context\n");
+		return AVERROR_UNKNOWN;
+	}
+
+
+	for (i = 0; i < 2; i++) {
+		out_stream = avformat_new_stream(ofmt_ctx, NULL);
+		if (!out_stream) {
+			av_log(NULL, AV_LOG_ERROR, "Failed allocating output stream\n");
+			return AVERROR_UNKNOWN;
+		}
+
+		enc_ctx = out_stream->codec;
+
+		if (ofmt_ctx->oformat->flags & AVFMT_GLOBALHEADER)
+			enc_ctx->flags |= CODEC_FLAG_GLOBAL_HEADER;
+
+
+		if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO
+			|| dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {
+			/* in this example, we choose transcoding to same codec */
+			encoder = avcodec_find_encoder(dec_ctx->codec_id);
+			if (!encoder) {
+				av_log(NULL, AV_LOG_FATAL, "Necessary encoder not found\n");
+				return AVERROR_INVALIDDATA;
+			}
+
+			/* In this example, we transcode to same properties (picture size,
+			* sample rate etc.). These properties can be changed for output
+			* streams easily using filters */
+			if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {
+				enc_ctx->height = dec_ctx->height;
+				enc_ctx->width = dec_ctx->width;
+				enc_ctx->sample_aspect_ratio = dec_ctx->sample_aspect_ratio;
+				/* take first format from list of supported formats */
+				enc_ctx->pix_fmt = encoder->pix_fmts[0];
+				/* video time_base can be set to whatever is handy and supported by encoder */
+				enc_ctx->time_base = dec_ctx->time_base;
+
+				enc_ctx->me_range = 16;
+				enc_ctx->max_qdiff = 4;
+				enc_ctx->qmin = 10;
+				enc_ctx->qmax = 30;
+				enc_ctx->qcompress = 0.6;
+			}
+			else {
+				enc_ctx->sample_rate = dec_ctx->sample_rate;
+				enc_ctx->channel_layout = dec_ctx->channel_layout;
+				enc_ctx->channels = av_get_channel_layout_nb_channels(enc_ctx->channel_layout);
+				/* take first format from list of supported formats */
+				enc_ctx->sample_fmt = encoder->sample_fmts[0];
+				enc_ctx->time_base.num = 1;
+				enc_ctx->time_base.den = enc_ctx->sample_rate;
+			}
+
+			/* Third parameter can be used to pass settings to encoder */
+			ret = avcodec_open2(enc_ctx, encoder, NULL);
+			if (ret < 0) {
+				av_log(NULL, AV_LOG_ERROR, "Cannot open video encoder for stream #%u\n", i);
+				return ret;
+			}
+		}
+		else if (dec_ctx->codec_type == AVMEDIA_TYPE_UNKNOWN) {
+			av_log(NULL, AV_LOG_FATAL, "Elementary stream #%d is of unknown type, cannot proceed\n", i);
+			return AVERROR_INVALIDDATA;
+		}
+#if 0
+		else {
+			/* if this stream must be remuxed */
+			ret = avcodec_copy_context(ofmt_ctx->streams[i]->codec,
+				ifmt_ctx->streams[i]->codec);
+			if (ret < 0) {
+				av_log(NULL, AV_LOG_ERROR, "Copying stream context failed\n");
+				return ret;
+			}
+#endif
+		}
+
+#if 0
+	av_dump_format(ofmt_ctx, 0, filename, 1);
+
+	if (!(ofmt_ctx->oformat->flags & AVFMT_NOFILE)) {
+		ret = avio_open(&ofmt_ctx->pb, filename, AVIO_FLAG_WRITE);
+		if (ret < 0) {
+			av_log(NULL, AV_LOG_ERROR, "Could not open output file '%s'", filename);
+			return ret;
+		}
+	}
+
+	/* init muxer, write output file header */
+	ret = avformat_write_header(ofmt_ctx, NULL);
+	if (ret < 0) {
+		av_log(NULL, AV_LOG_ERROR, "Error occurred when opening output file\n");
+		return ret;
+	}
+#endif
+	return 0;
+}
+
+
+	int CAVTranscoder::mix_and_output_vframe(vector<CAVDecoder *> & decoders_got_frame)
+	{
+		vector < CAVDecoder *>::iterator it = decoders_got_frame.begin();
+		for (; it != decoders_got_frame.end(); it++) {
+			(*it)->free_cur_a_frame();
+		}
+		return 0;
+	}
+
+	int CAVTranscoder::mix_and_output_aframe(vector<CAVDecoder *> & decoders_got_frame)
+	{
+		vector < CAVDecoder *>::iterator it = decoders_got_frame.begin();
+		for (; it != decoders_got_frame.end(); it++) {
+			(*it)->free_cur_v_frame();
+		}
+		return 0;
+	}
+
+	int encode_write_frame(AVFrame *filt_frame, unsigned int stream_index, int *got_frame) {
+		int ret;
+	int got_frame_local;
+	AVPacket enc_pkt;
+#if 0
+	int(*enc_func)(AVCodecContext *, AVPacket *, const AVFrame *, int *) =
+		(ifmt_ctx->streams[stream_index]->codec->codec_type ==
+		AVMEDIA_TYPE_VIDEO) ? avcodec_encode_video2 : avcodec_encode_audio2;
+
+	if (!got_frame)
+		got_frame = &got_frame_local;
+
+	av_log(NULL, AV_LOG_INFO, "Encoding frame\n");
+	/* encode filtered frame */
+	enc_pkt.data = NULL;
+	enc_pkt.size = 0;
+	av_init_packet(&enc_pkt);
+	ret = enc_func(ofmt_ctx->streams[stream_index]->codec, &enc_pkt,
+		filt_frame, got_frame);
+	av_frame_free(&filt_frame);
+	if (ret < 0)
+		return ret;
+	if (!(*got_frame))
+		return 0;
+
+	/* prepare packet for muxing */
+	enc_pkt.stream_index = stream_index;
+	av_packet_rescale_ts(&enc_pkt,
+		ofmt_ctx->streams[stream_index]->codec->time_base,
+		ofmt_ctx->streams[stream_index]->time_base);
+
+	av_log(NULL, AV_LOG_DEBUG, "Muxing frame\n");
+	/* mux encoded frame */
+	ret = av_interleaved_write_frame(ofmt_ctx, &enc_pkt);
+#endif
+	return ret;
+}
+
+#if 0
+static int flush_encoder(unsigned int stream_index)
+{
+	int ret;
+	int got_frame;
+
+	if (!(ofmt_ctx->streams[stream_index]->codec->codec->capabilities &
+		CODEC_CAP_DELAY))
+		return 0;
+
+	while (1) {
+		av_log(NULL, AV_LOG_INFO, "Flushing stream #%u encoder\n", stream_index);
+		ret = encode_write_frame(NULL, stream_index, &got_frame);
+		if (ret < 0)
+			break;
+		if (!got_frame)
+			return 0;
+	}
+	return ret;
+}
+#endif

+#pragma once
+#include "AVDecoder.h"
+
+
+class CAVTranscoder
+{
+public:
+	CAVTranscoder();
+	virtual ~CAVTranscoder();
+
+	int add(media_info & info);
+	int64_t transcode();
+	bool all_processed();
+	int close();
+
+protected:
+	int open_output_file(const char *filename);
+
+protected:
+	vector < CAVDecoder *> _decoders;
+
+	AVFormatContext *ofmt_ctx;
+	int64_t _start_time;
+	int64_t _cur_a_time;
+	int64_t _cur_v_time;
+private:
+	int mix_and_output_vframe(vector<CAVDecoder *> & decoders_got_frame);
+	int mix_and_output_aframe(vector<CAVDecoder *> & decoders_got_frame);
+	bool _all_processed;
+};
+

+#include "AudioDecoder.h"
+AVRational timebase_ms = { 1, 1000 };
+
+CAudioDecoder::CAudioDecoder() :
+_start_time(-10.0),
+_is_finished(false)
+{
+
+}
+
+CAudioDecoder::~CAudioDecoder()
+{
+}
+
+int CAudioDecoder::add(media_info &info)
+{
+	if (_start_time < -1.0) {//the the start time of this decoder
+		_start_time = info.start_time;
+	}
+	_info.push_back(info);
+
+	int ret;
+
+	do{
+		if ((ret = open_input_file(info.name.c_str())) < 0)
+			break;
+
+		if ((ret = init_filters()) < 0)
+			break;
+
+		_is_finished = false;
+	} while (0);
+
+	return ret ? 1 : 0;
+}
+
+
+
+int CAudioDecoder::init_filter(FilteringContext* fctx, AVCodecContext *dec_ctx,
+	const char *filter_spec)
+{
+	char args[512];
+	int ret = 0;
+	AVFilter *buffersrc = NULL;
+	AVFilter *buffersink = NULL;
+	AVFilterContext *buffersrc_ctx = NULL;
+	AVFilterContext *buffersink_ctx = NULL;
+	AVFilterInOut *outputs = avfilter_inout_alloc();
+	AVFilterInOut *inputs = avfilter_inout_alloc();
+	AVFilterGraph *filter_graph = avfilter_graph_alloc();
+
+	if (!outputs || !inputs || !filter_graph) {
+		ret = AVERROR(ENOMEM);
+		goto end;
+	}
+
+	if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {
+		buffersrc = avfilter_get_by_name("buffer");
+		buffersink = avfilter_get_by_name("buffersink");
+		if (!buffersrc || !buffersink) {
+			av_log(NULL, AV_LOG_ERROR, "filtering source or sink element not found\n");
+			ret = AVERROR_UNKNOWN;
+			goto end;
+		}
+
+		snprintf(args, sizeof(args),
+			"video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
+			dec_ctx->width, dec_ctx->height, dec_ctx->pix_fmt,
+			dec_ctx->time_base.num, dec_ctx->time_base.den,
+			dec_ctx->sample_aspect_ratio.num,
+			dec_ctx->sample_aspect_ratio.den);
+
+		ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in",
+			args, NULL, filter_graph);
+		if (ret < 0) {
+			av_log(NULL, AV_LOG_ERROR, "Cannot create buffer source\n");
+			goto end;
+		}
+
+		ret = avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out",
+			NULL, NULL, filter_graph);
+		if (ret < 0) {
+			av_log(NULL, AV_LOG_ERROR, "Cannot create buffer sink\n");
+			goto end;
+		}
+
+		AVPixelFormat fmt = AV_PIX_FMT_YUV420P;
+		ret = av_opt_set_bin(buffersink_ctx, "pix_fmts",
+			(uint8_t*)&fmt, sizeof(AVPixelFormat),
+			AV_OPT_SEARCH_CHILDREN);
+		if (ret < 0) {
+			av_log(NULL, AV_LOG_ERROR, "Cannot set output pixel format\n");
+			goto end;
+		}
+	}
+	else if (dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {
+		buffersrc = avfilter_get_by_name("abuffer");
+		buffersink = avfilter_get_by_name("abuffersink");
+		if (!buffersrc || !buffersink) {
+			av_log(NULL, AV_LOG_ERROR, "filtering source or sink element not found\n");
+			ret = AVERROR_UNKNOWN;
+			goto end;
+		}
+
+		if (!dec_ctx->channel_layout)
+			dec_ctx->channel_layout =
+			av_get_default_channel_layout(dec_ctx->channels);
+		sprintf(args, //sizeof(args),
+			"time_base=%d/%d:sample_rate=%d:sample_fmt=%s:channel_layout=0x%"PRIx64,
+			dec_ctx->time_base.num, dec_ctx->time_base.den, dec_ctx->sample_rate,
+			av_get_sample_fmt_name(dec_ctx->sample_fmt),
+			dec_ctx->channel_layout);
+		ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in",
+			args, NULL, filter_graph);
+		if (ret < 0) {
+			av_log(NULL, AV_LOG_ERROR, "Cannot create audio buffer source\n");
+			goto end;
+		}
+
+		ret = avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out",
+			NULL, NULL, filter_graph);
+		if (ret < 0) {
+			av_log(NULL, AV_LOG_ERROR, "Cannot create audio buffer sink\n");
+			goto end;
+		}
+		enum AVSampleFormat sample_fmt = AV_SAMPLE_FMT_S16;
+		ret = av_opt_set_bin(buffersink_ctx, "sample_fmts",
+			(uint8_t*)&sample_fmt, sizeof(sample_fmt),
+			AV_OPT_SEARCH_CHILDREN);
+		if (ret < 0) {
+			av_log(NULL, AV_LOG_ERROR, "Cannot set output sample format\n");
+			goto end;
+		}
+
+		uint64_t channel_layout = AV_CH_LAYOUT_MONO;
+		ret = av_opt_set_bin(buffersink_ctx, "channel_layouts",
+			(uint8_t*)&channel_layout,
+			sizeof(channel_layout), AV_OPT_SEARCH_CHILDREN);
+		if (ret < 0) {
+			av_log(NULL, AV_LOG_ERROR, "Cannot set output channel layout\n");
+			goto end;
+		}
+
+		int sample_rate = 46000;
+		ret = av_opt_set_bin(buffersink_ctx, "sample_rates",
+			(uint8_t*)&sample_rate, sizeof(sample_rate),
+			AV_OPT_SEARCH_CHILDREN);
+		if (ret < 0) {
+			av_log(NULL, AV_LOG_ERROR, "Cannot set output sample rate\n");
+			goto end;
+		}
+	}
+	else {
+		ret = AVERROR_UNKNOWN;
+		goto end;
+	}
+
+	/* Endpoints for the filter graph. */
+	outputs->name = av_strdup("in");
+	outputs->filter_ctx = buffersrc_ctx;
+	outputs->pad_idx = 0;
+	outputs->next = NULL;
+
+	inputs->name = av_strdup("out");
+	inputs->filter_ctx = buffersink_ctx;
+	inputs->pad_idx = 0;
+	inputs->next = NULL;
+
+	if (!outputs->name || !inputs->name) {
+		ret = AVERROR(ENOMEM);
+		goto end;
+	}
+
+	if ((ret = avfilter_graph_parse_ptr(filter_graph, filter_spec,
+		&inputs, &outputs, NULL)) < 0)
+		goto end;
+
+	if ((ret = avfilter_graph_config(filter_graph, NULL)) < 0)
+		goto end;
+
+	/* Fill FilteringContext */
+	fctx->buffersrc_ctx = buffersrc_ctx;
+	fctx->buffersink_ctx = buffersink_ctx;
+	fctx->filter_graph = filter_graph;
+
+end:
+	avfilter_inout_free(&inputs);
+	avfilter_inout_free(&outputs);
+
+	return ret;
+}
+
+int CAudioDecoder::init_filters(void)
+{
+	const char *filter_spec;
+	unsigned int i;
+	int ret;
+	filter_ctx = (FilteringContext *)av_malloc_array(ifmt_ctx->nb_streams, sizeof(*filter_ctx));
+	if (!filter_ctx)
+		return AVERROR(ENOMEM);
+
+	for (i = 0; i < ifmt_ctx->nb_streams; i++) {
+		filter_ctx[i].buffersrc_ctx = NULL;
+		filter_ctx[i].buffersink_ctx = NULL;
+		filter_ctx[i].filter_graph = NULL;
+		if (!(ifmt_ctx->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO
+			|| ifmt_ctx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO))
+			continue;
+
+
+		if (ifmt_ctx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
+			filter_spec = "fps=fps=20"; /* passthrough (dummy) filter for video */
+			_codec_timebase.num = 1;
+			_codec_timebase.den = 20;
+		}
+		else
+			filter_spec = "anull"; /* passthrough (dummy) filter for audio */
+		ret = init_filter(&filter_ctx[i], ifmt_ctx->streams[i]->codec,
+			filter_spec);
+		if (ret)
+			return ret;
+	}
+	return 0;
+}
+
+int CAudioDecoder::open_input_file(const char *filename)
+{
+	int ret;
+	unsigned int i;
+
+	ifmt_ctx = NULL;
+	if ((ret = avformat_open_input(&ifmt_ctx, filename, NULL, NULL)) < 0) {
+		av_log(NULL, AV_LOG_ERROR, "Cannot open input file\n");
+		return ret;
+	}
+
+	if ((ret = avformat_find_stream_info(ifmt_ctx, NULL)) < 0) {
+		av_log(NULL, AV_LOG_ERROR, "Cannot find stream information\n");
+		return ret;
+	}
+
+	for (i = 0; i < ifmt_ctx->nb_streams; i++) {
+		AVStream *stream;
+		AVCodecContext *codec_ctx;
+		stream = ifmt_ctx->streams[i];
+		codec_ctx = stream->codec;
+		/* Reencode video & audio and remux subtitles etc. */
+		if (codec_ctx->codec_type == AVMEDIA_TYPE_VIDEO
+			|| codec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {
+			/* Open decoder */
+			ret = avcodec_open2(codec_ctx,
+				avcodec_find_decoder(codec_ctx->codec_id), NULL);
+			if (ret < 0) {
+				av_log(NULL, AV_LOG_ERROR, "Failed to open decoder for stream #%u\n", i);
+				return ret;
+			}
+		}
+	}
+
+	av_dump_format(ifmt_ctx, 0, filename, 0);
+	return 0;
+}
+
+
+int CAudioDecoder::filter_encode_write_frame(AVFrame *frame, unsigned int stream_index)
+{
+	int ret;
+	AVFrame *filt_frame;
+
+	//av_log(NULL, AV_LOG_INFO, "Pushing decoded frame to filters\n");
+	/* push the decoded frame into the filtergraph */
+	ret = av_buffersrc_add_frame_flags(filter_ctx[stream_index].buffersrc_ctx,
+		frame, 0);
+	if (ret < 0) {
+		av_log(NULL, AV_LOG_ERROR, "Error while feeding the filtergraph\n");
+		return ret;
+	}
+
+	/* pull filtered frames from the filtergraph */
+	while (1) {
+		filt_frame = av_frame_alloc();
+		if (!filt_frame) {
+			ret = AVERROR(ENOMEM);
+			break;
+		}
+		//av_log(NULL, AV_LOG_INFO, "Pulling filtered frame from filters\n");
+		ret = av_buffersink_get_frame(filter_ctx[stream_index].buffersink_ctx,
+			filt_frame);
+		if (ret < 0) {
+			/* if no more frames for output - returns AVERROR(EAGAIN)
+			* if flushed and no more frames for output - returns AVERROR_EOF
+			* rewrite retcode to 0 to show it as normal procedure completion
+			*/
+			if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
+				ret = 0;
+			av_frame_free(&filt_frame);
+			break;
+		}
+
+		filt_frame->pict_type = AV_PICTURE_TYPE_NONE;
+		//todo: callback filted frame
+		_decoded_frames.push_back(filt_frame);
+	}
+
+	return ret;
+}
+
+unsigned int CAudioDecoder::getuid()
+{
+	return 0;
+}
+
+int CAudioDecoder::get_one_frame(AVFrame ** pFrame, int64_t & ts)
+{
+	int ret;
+	AVPacket packet;
+	AVFrame *frame = NULL;
+	enum AVMediaType type;
+	unsigned int stream_index;
+	unsigned int i;
+	int got_frame;
+
+	if (_decoded_frames.size() > 0) {
+		*pFrame = _decoded_frames.front();
+		ts = av_rescale_q((*pFrame)->pts, _codec_timebase, timebase_ms);
+		_decoded_frames.pop_front();
+
+		return 0;
+	}
+
+	if (_is_finished){
+		return -1;
+	}
+
+	int(*dec_func)(AVCodecContext *, AVFrame *, int *, const AVPacket *);
+	memset(&packet, 0, sizeof(AVPacket));
+
+	/* read all packets */
+	while (1) {
+		if ((ret = av_read_frame(ifmt_ctx, &packet)) < 0)
+			break;
+		stream_index = packet.stream_index;
+		type = ifmt_ctx->streams[packet.stream_index]->codec->codec_type;
+		av_log(NULL, AV_LOG_DEBUG, "Demuxer gave frame of stream_index %u\n",
+			stream_index);
+
+		if (filter_ctx[stream_index].filter_graph) {
+			av_log(NULL, AV_LOG_DEBUG, "Going to reencode&filter the frame\n");
+			frame = av_frame_alloc();
+			if (!frame) {
+				ret = AVERROR(ENOMEM);
+				break;
+			}
+
+			av_packet_rescale_ts(&packet,
+				ifmt_ctx->streams[stream_index]->time_base,
+				ifmt_ctx->streams[stream_index]->codec->time_base);
+			dec_func = (type == AVMEDIA_TYPE_VIDEO) ? avcodec_decode_video2 :
+				avcodec_decode_audio4;
+			ret = dec_func(ifmt_ctx->streams[stream_index]->codec, frame,
+				&got_frame, &packet);
+			if (ret < 0) {
+				av_frame_free(&frame);
+				av_log(NULL, AV_LOG_ERROR, "Decoding failed\n");
+				break;
+			}
+
+			if (got_frame) {
+				frame->pts = av_frame_get_best_effort_timestamp(frame);
+				ret = filter_encode_write_frame(frame, stream_index);
+				if (_decoded_frames.size() > 0) {
+					*pFrame = _decoded_frames.front();
+					_decoded_frames.pop_front();
+					ts = av_rescale_q((*pFrame)->pts, _codec_timebase, timebase_ms);
+					return 0;
+				}
+				if (ret < 0)
+					goto end;
+			}
+			else {
+				av_frame_free(&frame);
+			}
+		}
+		av_packet_unref(&packet);
+
+	}
+
+	/* flush filters and encoders */
+	for (i = 0; i < ifmt_ctx->nb_streams; i++) {
+		/* flush filter */
+		if (!filter_ctx[i].filter_graph)
+			continue;
+		ret = filter_encode_write_frame(NULL, i);
+		if (ret < 0) {
+			av_log(NULL, AV_LOG_ERROR, "Flushing filter failed\n");
+			goto end;
+		}
+
+	}
+end:;
+	av_packet_unref(&packet);
+	av_frame_free(&frame);
+	for (i = 0; i < ifmt_ctx->nb_streams; i++) {
+		avcodec_close(ifmt_ctx->streams[i]->codec);
+		if (filter_ctx && filter_ctx[i].filter_graph)
+			avfilter_graph_free(&filter_ctx[i].filter_graph);
+	}
+	av_free(filter_ctx);
+	avformat_close_input(&ifmt_ctx);
+	_is_finished = true;
+
+	return 0;
+}

+#pragma once
+#include "media_info.h"
+#include <list>
+class CAudioDecoder
+{
+public:
+	CAudioDecoder();
+	virtual ~CAudioDecoder();
+
+	int add(media_info &info);
+
+	unsigned int getuid();
+
+	int get_one_frame(AVFrame ** pFrame, int64_t & ts);
+
+protected:
+	int open_input_file(const char *filename);
+	int init_filters(void);
+	int init_filter(FilteringContext* fctx, AVCodecContext *dec_ctx, const char *filter_spec);
+	int filter_encode_write_frame(AVFrame *frame, unsigned int stream_index);
+
+protected:
+	vector<media_info> _info;
+	list<AVFrame * > _decoded_frames;
+	float _start_time;
+
+	AVFormatContext *ifmt_ctx;
+
+	FilteringContext *filter_ctx;
+
+	bool _is_finished;
+	AVRational _codec_timebase;
+};

+#include "AudioEncoder.h"
+
+
+CAudioEncoder::CAudioEncoder()
+{
+}
+
+
+CAudioEncoder::~CAudioEncoder()
+{
+}

+#pragma once
+class CAudioEncoder
+{
+public:
+	CAudioEncoder();
+	virtual ~CAudioEncoder();
+};
+

 #include "VideoDecoder.h"
 #include "VideoDecoder.h"
+extern AVRational timebase_ms;
 
 
-CVideoDecoder::CVideoDecoder()
+CVideoDecoder::CVideoDecoder() :
+_start_time(-10.0),
+_is_finished(false)
 {
 {
 
 
 }
 }
@@ -11,10 +14,400 @@ CVideoDecoder::~CVideoDecoder()
 
 
 int CVideoDecoder::add(media_info &info)
 int CVideoDecoder::add(media_info &info)
 {
 {
+	if (_start_time < -1.0) {//the the start time of this decoder
+		_start_time = info.start_time;
+	}
+	_info.push_back(info);
+
+	int ret;
+
+	do{
+		if ((ret = open_input_file(info.name.c_str())) < 0)
+			break;
+
+		if ((ret = init_filters()) < 0)
+			break;
+
+		_is_finished = false;
+	} while (0);
+
+	return ret ? 1 : 0;
+}
+
+
+
+int CVideoDecoder::init_filter(FilteringContext* fctx, AVCodecContext *dec_ctx,
+	const char *filter_spec)
+{
+	char args[512];
+	int ret = 0;
+	AVFilter *buffersrc = NULL;
+	AVFilter *buffersink = NULL;
+	AVFilterContext *buffersrc_ctx = NULL;
+	AVFilterContext *buffersink_ctx = NULL;
+	AVFilterInOut *outputs = avfilter_inout_alloc();
+	AVFilterInOut *inputs = avfilter_inout_alloc();
+	AVFilterGraph *filter_graph = avfilter_graph_alloc();
+
+	if (!outputs || !inputs || !filter_graph) {
+		ret = AVERROR(ENOMEM);
+		goto end;
+	}
+
+	if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {
+		buffersrc = avfilter_get_by_name("buffer");
+		buffersink = avfilter_get_by_name("buffersink");
+		if (!buffersrc || !buffersink) {
+			av_log(NULL, AV_LOG_ERROR, "filtering source or sink element not found\n");
+			ret = AVERROR_UNKNOWN;
+			goto end;
+		}
+
+		snprintf(args, sizeof(args),
+			"video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
+			dec_ctx->width, dec_ctx->height, dec_ctx->pix_fmt,
+			dec_ctx->time_base.num, dec_ctx->time_base.den,
+			dec_ctx->sample_aspect_ratio.num,
+			dec_ctx->sample_aspect_ratio.den);
+
+		ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in",
+			args, NULL, filter_graph);
+		if (ret < 0) {
+			av_log(NULL, AV_LOG_ERROR, "Cannot create buffer source\n");
+			goto end;
+		}
+
+		ret = avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out",
+			NULL, NULL, filter_graph);
+		if (ret < 0) {
+			av_log(NULL, AV_LOG_ERROR, "Cannot create buffer sink\n");
+			goto end;
+		}
+
+		AVPixelFormat fmt = AV_PIX_FMT_YUV420P;
+		ret = av_opt_set_bin(buffersink_ctx, "pix_fmts",
+			(uint8_t*)&fmt, sizeof(AVPixelFormat),
+			AV_OPT_SEARCH_CHILDREN);
+		if (ret < 0) {
+			av_log(NULL, AV_LOG_ERROR, "Cannot set output pixel format\n");
+			goto end;
+		}
+	}
+#if 0
+	else if (dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {
+		buffersrc = avfilter_get_by_name("abuffer");
+		buffersink = avfilter_get_by_name("abuffersink");
+		if (!buffersrc || !buffersink) {
+			av_log(NULL, AV_LOG_ERROR, "filtering source or sink element not found\n");
+			ret = AVERROR_UNKNOWN;
+			goto end;
+		}
+
+		if (!dec_ctx->channel_layout)
+			dec_ctx->channel_layout =
+			av_get_default_channel_layout(dec_ctx->channels);
+		sprintf(args, //sizeof(args),
+			"time_base=%d/%d:sample_rate=%d:sample_fmt=%s:channel_layout=0x%"PRIx64,
+			dec_ctx->time_base.num, dec_ctx->time_base.den, dec_ctx->sample_rate,
+			av_get_sample_fmt_name(dec_ctx->sample_fmt),
+			dec_ctx->channel_layout);
+		ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in",
+			args, NULL, filter_graph);
+		if (ret < 0) {
+			av_log(NULL, AV_LOG_ERROR, "Cannot create audio buffer source\n");
+			goto end;
+		}
+
+		ret = avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out",
+			NULL, NULL, filter_graph);
+		if (ret < 0) {
+			av_log(NULL, AV_LOG_ERROR, "Cannot create audio buffer sink\n");
+			goto end;
+		}
+
+		ret = av_opt_set_bin(buffersink_ctx, "sample_fmts",
+			(uint8_t*)&enc_ctx->sample_fmt, sizeof(enc_ctx->sample_fmt),
+			AV_OPT_SEARCH_CHILDREN);
+		if (ret < 0) {
+			av_log(NULL, AV_LOG_ERROR, "Cannot set output sample format\n");
+			goto end;
+		}
+
+		ret = av_opt_set_bin(buffersink_ctx, "channel_layouts",
+			(uint8_t*)&enc_ctx->channel_layout,
+			sizeof(enc_ctx->channel_layout), AV_OPT_SEARCH_CHILDREN);
+		if (ret < 0) {
+			av_log(NULL, AV_LOG_ERROR, "Cannot set output channel layout\n");
+			goto end;
+		}
+
+		ret = av_opt_set_bin(buffersink_ctx, "sample_rates",
+			(uint8_t*)&enc_ctx->sample_rate, sizeof(enc_ctx->sample_rate),
+			AV_OPT_SEARCH_CHILDREN);
+		if (ret < 0) {
+			av_log(NULL, AV_LOG_ERROR, "Cannot set output sample rate\n");
+			goto end;
+		}
+	}
+#endif
+	else {
+		ret = AVERROR_UNKNOWN;
+		goto end;
+	}
+
+	/* Endpoints for the filter graph. */
+	outputs->name = av_strdup("in");
+	outputs->filter_ctx = buffersrc_ctx;
+	outputs->pad_idx = 0;
+	outputs->next = NULL;
+
+	inputs->name = av_strdup("out");
+	inputs->filter_ctx = buffersink_ctx;
+	inputs->pad_idx = 0;
+	inputs->next = NULL;
+
+	if (!outputs->name || !inputs->name) {
+		ret = AVERROR(ENOMEM);
+		goto end;
+	}
+
+	if ((ret = avfilter_graph_parse_ptr(filter_graph, filter_spec,
+		&inputs, &outputs, NULL)) < 0)
+		goto end;
+
+	if ((ret = avfilter_graph_config(filter_graph, NULL)) < 0)
+		goto end;
+
+	/* Fill FilteringContext */
+	fctx->buffersrc_ctx = buffersrc_ctx;
+	fctx->buffersink_ctx = buffersink_ctx;
+	fctx->filter_graph = filter_graph;
+
+end:
+	avfilter_inout_free(&inputs);
+	avfilter_inout_free(&outputs);
+
+	return ret;
+}
+
+int CVideoDecoder::init_filters(void)
+{
+	const char *filter_spec;
+	unsigned int i;
+	int ret;
+	filter_ctx = (FilteringContext *)av_malloc_array(ifmt_ctx->nb_streams, sizeof(*filter_ctx));
+	if (!filter_ctx)
+		return AVERROR(ENOMEM);
+
+	for (i = 0; i < ifmt_ctx->nb_streams; i++) {
+		filter_ctx[i].buffersrc_ctx = NULL;
+		filter_ctx[i].buffersink_ctx = NULL;
+		filter_ctx[i].filter_graph = NULL;
+		if (!(ifmt_ctx->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO
+			|| ifmt_ctx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO))
+			continue;
+
+
+		if (ifmt_ctx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
+			filter_spec = "fps=fps=20"; /* passthrough (dummy) filter for video */
+			_codec_timebase.num = 1;
+			_codec_timebase.den = 20;
+		}
+		else
+			filter_spec = "anull"; /* passthrough (dummy) filter for audio */
+		ret = init_filter(&filter_ctx[i], ifmt_ctx->streams[i]->codec,
+			filter_spec);
+		if (ret)
+			return ret;
+	}
 	return 0;
 	return 0;
 }
 }
 
 
+int CVideoDecoder::open_input_file(const char *filename)
+{
+	int ret;
+	unsigned int i;
+
+	ifmt_ctx = NULL;
+	if ((ret = avformat_open_input(&ifmt_ctx, filename, NULL, NULL)) < 0) {
+		av_log(NULL, AV_LOG_ERROR, "Cannot open input file\n");
+		return ret;
+	}
+
+	if ((ret = avformat_find_stream_info(ifmt_ctx, NULL)) < 0) {
+		av_log(NULL, AV_LOG_ERROR, "Cannot find stream information\n");
+		return ret;
+	}
+
+	for (i = 0; i < ifmt_ctx->nb_streams; i++) {
+		AVStream *stream;
+		AVCodecContext *codec_ctx;
+		stream = ifmt_ctx->streams[i];
+		codec_ctx = stream->codec;
+		/* Reencode video & audio and remux subtitles etc. */
+		if (codec_ctx->codec_type == AVMEDIA_TYPE_VIDEO
+			|| codec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {
+			/* Open decoder */
+			ret = avcodec_open2(codec_ctx,
+				avcodec_find_decoder(codec_ctx->codec_id), NULL);
+			if (ret < 0) {
+				av_log(NULL, AV_LOG_ERROR, "Failed to open decoder for stream #%u\n", i);
+				return ret;
+			}
+		}
+	}
+
+	av_dump_format(ifmt_ctx, 0, filename, 0);
+	return 0;
+}
+
+
+int CVideoDecoder::filter_encode_write_frame(AVFrame *frame, unsigned int stream_index)
+{
+	int ret;
+	AVFrame *filt_frame;
+
+	//av_log(NULL, AV_LOG_INFO, "Pushing decoded frame to filters\n");
+	/* push the decoded frame into the filtergraph */
+	ret = av_buffersrc_add_frame_flags(filter_ctx[stream_index].buffersrc_ctx,
+		frame, 0);
+	if (ret < 0) {
+		av_log(NULL, AV_LOG_ERROR, "Error while feeding the filtergraph\n");
+		return ret;
+	}
+
+	/* pull filtered frames from the filtergraph */
+	while (1) {
+		filt_frame = av_frame_alloc();
+		if (!filt_frame) {
+			ret = AVERROR(ENOMEM);
+			break;
+		}
+		//av_log(NULL, AV_LOG_INFO, "Pulling filtered frame from filters\n");
+		ret = av_buffersink_get_frame(filter_ctx[stream_index].buffersink_ctx,
+			filt_frame);
+		if (ret < 0) {
+			/* if no more frames for output - returns AVERROR(EAGAIN)
+			* if flushed and no more frames for output - returns AVERROR_EOF
+			* rewrite retcode to 0 to show it as normal procedure completion
+			*/
+			if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
+				ret = 0;
+			av_frame_free(&filt_frame);
+			break;
+		}
+
+		filt_frame->pict_type = AV_PICTURE_TYPE_NONE;
+		//todo: callback filted frame
+		_decoded_frames.push_back(filt_frame);
+	}
+
+	return ret;
+}
+
 unsigned int CVideoDecoder::getuid()
 unsigned int CVideoDecoder::getuid()
 {
 {
 	return 0;
 	return 0;
 }
 }
+
+int CVideoDecoder::get_one_frame(AVFrame ** pFrame, int64_t & ts)
+{
+	int ret;
+	AVPacket packet;
+	AVFrame *frame = NULL;
+	enum AVMediaType type;
+	unsigned int stream_index;
+	unsigned int i;
+	int got_frame;
+
+	if (_decoded_frames.size() > 0) {
+		*pFrame = _decoded_frames.front();
+		ts = av_rescale_q((*pFrame)->pts, _codec_timebase, timebase_ms);
+		_decoded_frames.pop_front();
+
+		return 0;
+	}
+
+	if (_is_finished){
+		return -1;
+	}
+	
+	int(*dec_func)(AVCodecContext *, AVFrame *, int *, const AVPacket *);
+	memset(&packet, 0, sizeof(AVPacket));
+
+	/* read all packets */
+	while (1) {
+		if ((ret = av_read_frame(ifmt_ctx, &packet)) < 0)
+			break;
+		stream_index = packet.stream_index;
+		type = ifmt_ctx->streams[packet.stream_index]->codec->codec_type;
+		av_log(NULL, AV_LOG_DEBUG, "Demuxer gave frame of stream_index %u\n",
+			stream_index);
+
+		if (filter_ctx[stream_index].filter_graph) {
+			av_log(NULL, AV_LOG_DEBUG, "Going to reencode&filter the frame\n");
+			frame = av_frame_alloc();
+			if (!frame) {
+				ret = AVERROR(ENOMEM);
+				break;
+			}
+
+			av_packet_rescale_ts(&packet,
+				ifmt_ctx->streams[stream_index]->time_base,
+				ifmt_ctx->streams[stream_index]->codec->time_base);
+			dec_func = (type == AVMEDIA_TYPE_VIDEO) ? avcodec_decode_video2 :
+				avcodec_decode_audio4;
+			ret = dec_func(ifmt_ctx->streams[stream_index]->codec, frame,
+				&got_frame, &packet);
+			if (ret < 0) {
+				av_frame_free(&frame);
+				av_log(NULL, AV_LOG_ERROR, "Decoding failed\n");
+				break;
+			}
+
+			if (got_frame) {
+				frame->pts = av_frame_get_best_effort_timestamp(frame);
+				ret = filter_encode_write_frame(frame, stream_index);
+				if (_decoded_frames.size() > 0) {
+					*pFrame = _decoded_frames.front();
+					_decoded_frames.pop_front();
+					ts = av_rescale_q((*pFrame)->pts, _codec_timebase, timebase_ms);
+					return 0;
+				}
+				if (ret < 0)
+					goto end;
+			}
+			else {
+				av_frame_free(&frame);
+			}
+		}
+		av_packet_unref(&packet);
+
+	}
+
+	/* flush filters and encoders */
+	for (i = 0; i < ifmt_ctx->nb_streams; i++) {
+		/* flush filter */
+		if (!filter_ctx[i].filter_graph)
+			continue;
+		ret = filter_encode_write_frame(NULL, i);
+		if (ret < 0) {
+			av_log(NULL, AV_LOG_ERROR, "Flushing filter failed\n");
+			goto end;
+		}
+
+   }
+end:;
+	av_packet_unref(&packet);
+	av_frame_free(&frame);
+	for (i = 0; i < ifmt_ctx->nb_streams; i++) {
+		avcodec_close(ifmt_ctx->streams[i]->codec);
+		if (filter_ctx && filter_ctx[i].filter_graph)
+			avfilter_graph_free(&filter_ctx[i].filter_graph);
+	}
+	av_free(filter_ctx);
+	avformat_close_input(&ifmt_ctx);
+	_is_finished = true;
+
+	return 0;
+}

 #pragma once
 #pragma once
-#include <string>
-#include <vector>
-using   namespace  std;
-
-enum media_type{
-	mt_audio = 0,
-	mt_video = 1,
-	mt_av = 3,
-};
-
-enum media_role {
-	mr_teacher = 0,
-	mr_student = 1,
-};
-
-enum timestamp_type{
-	tt_start = 0,
-	tt_end = 1,
-};
-
-class media_info {
-public:
-	float type_time;//the time for start or end according to the m_type
-	float start_time;
-	float end_time;
-	string name;
-	int rotate;
-
-	float duration;
-	int index;
-	unsigned int uid;
-	media_type m_type;
-	media_role m_role;
-	timestamp_type t_type;
-};
-
+#include "media_info.h"
+#include <list>
 class CVideoDecoder
 class CVideoDecoder
 {
 {
 public:
 public:
@@ -45,7 +11,24 @@ public:
 
 
 	unsigned int getuid();
 	unsigned int getuid();
 
 
+	int get_one_frame(AVFrame ** pFrame, int64_t & ts);
+
+protected:
+	int open_input_file(const char *filename);
+	int init_filters(void);
+	int init_filter(FilteringContext* fctx, AVCodecContext *dec_ctx, const char *filter_spec);
+	int filter_encode_write_frame(AVFrame *frame, unsigned int stream_index);
+
 protected:
 protected:
 	vector<media_info> _info;
 	vector<media_info> _info;
+	list<AVFrame * > _decoded_frames;
+	float _start_time;
+
+	AVFormatContext *ifmt_ctx;
+
+	FilteringContext *filter_ctx;
+
+	bool _is_finished;
+	AVRational _codec_timebase;
 };
 };
 
 

+#include "VideoEncoder.h"
+
+
+CVideoEncoder::CVideoEncoder()
+{
+}
+
+
+CVideoEncoder::~CVideoEncoder()
+{
+}

+#pragma once
+class CVideoEncoder
+{
+public:
+	CVideoEncoder();
+	virtual ~CVideoEncoder();
+};
+

-#include "VideoTranscoder.h"
-
-
-CVideoTranscoder::CVideoTranscoder()
-{
-}
-
-
-CVideoTranscoder::~CVideoTranscoder()
-{
-}
-
-int CVideoTranscoder::add(media_info & info)
-{
-	vector < CVideoDecoder *>::iterator it = _decoders.begin();
-	for (; it != _decoders.end(); it++) {
-		if ((*it)->getuid() == info.uid){
-			(*it)->add(info);
-			break;
-		}
-	}
-	if (it == _decoders.end()) {
-		CVideoDecoder * pVideoDecoder = new CVideoDecoder();
-		pVideoDecoder->add(info);
-		_decoders.push_back(pVideoDecoder);
-	}
-	return 0;
-}
-
-float CVideoTranscoder::transcode()
-{
-	throw std::logic_error("The method or operation is not implemented.");
-}
-
-bool CVideoTranscoder::all_processed()
-{
-	throw std::logic_error("The method or operation is not implemented.");
-}
-
-int CVideoTranscoder::close()
-{
-	throw std::logic_error("The method or operation is not implemented.");
-}

-#pragma once
-#include "VideoDecoder.h"
-
-
-class CVideoTranscoder
-{
-public:
-	CVideoTranscoder();
-	virtual ~CVideoTranscoder();
-
-	int add(media_info & info);
-	float transcode();
-	bool all_processed();
-	int close();
-
-protected:
-	vector < CVideoDecoder *> _decoders;
-};
-

+#pragma  once
+
+#include <string>
+#include <vector>
+#include <stdint.h>
+using   namespace  std;
+
+enum media_type{
+	mt_audio = 0,
+	mt_video = 1,
+	mt_av = 3,
+};
+
+enum media_role {
+	mr_teacher = 0,
+	mr_student = 1,
+};
+
+enum timestamp_type{
+	tt_start = 0,
+	tt_end = 1,
+};
+
+class media_info {
+public:
+	float type_time;//the time for start or end according to the m_type
+	float start_time;
+	int64_t start_time_ms;
+	float end_time;
+	int64_t end_time_ms;
+	string name;
+	int rotate;
+
+	float duration;
+	int index;
+	unsigned int uid;
+	media_type m_type;
+	media_role m_role;
+	timestamp_type t_type;
+};
+
+#define __STDC_FORMAT_MACROS
+#include <stdint.h>
+#include <inttypes.h>
+extern "C" {
+#include <libavcodec/avcodec.h>
+#include <libavformat/avformat.h>
+#include <libavfilter/avfiltergraph.h>
+#include <libavfilter/buffersink.h>
+#include <libavfilter/buffersrc.h>
+#include <libavutil/opt.h>
+#include <libavutil/pixdesc.h>
+}
+#ifdef WIN32
+#pragma comment(lib, "avcodec.lib")
+#pragma comment(lib, "avdevice.lib")
+#pragma comment(lib, "avfilter.lib")
+#pragma comment(lib, "avformat.lib")
+#pragma comment(lib, "avutil.lib")
+#pragma comment(lib, "postproc.lib")
+#pragma comment(lib, "swresample.lib")
+#pragma comment(lib, "swscale.lib")
+#endif
+
+#if _MSC_VER
+#define snprintf _snprintf
+#define PRIu64       "I64u"
+#define PRId64       "I64d"
+#define PRIx64       "I64x"
+#define PRIX64       "I64X"
+#endif
+
+typedef struct FilteringContext {
+	AVFilterContext *buffersink_ctx;
+	AVFilterContext *buffersrc_ctx;
+	AVFilterGraph *filter_graph;
+} FilteringContext;
+
+
+#define AFRAME_DURATION_MS 20
+#define VFRAME_DURATION_MS 50

@@ -8,7 +8,7 @@
 #include <list>
 #include <list>
 #include <deque>
 #include <deque>
 #include "tools.h"
 #include "tools.h"
-#include "VideoTranscoder.h"
+#include "AVTranscoder.h"
 
 
 bool only_print = false;
 bool only_print = false;
 bool keep_tmp_files = false;
 bool keep_tmp_files = false;
@@ -594,6 +594,8 @@ void add_media_infos()
 		m.rotate = f.rotate;
 		m.rotate = f.rotate;
 		m.m_role = f.m_role;
 		m.m_role = f.m_role;
 		m.uid = f.uid;
 		m.uid = f.uid;
+		m.start_time_ms = f.start_time * 1000;
+		m.end_time_ms = f.end_time * 1000;
 		add_media_info(m);
 		add_media_info(m);
 		m.t_type = tt_end;
 		m.t_type = tt_end;
 		m.type_time = m.end_time;
 		m.type_time = m.end_time;
@@ -871,608 +873,22 @@ int load_record_info(char * record_info)
 
 
 
 
 
 
-#define __STDC_FORMAT_MACROS
-#include <stdint.h>
-#include <inttypes.h>
-extern "C" {
-#include <libavcodec/avcodec.h>
-#include <libavformat/avformat.h>
-#include <libavfilter/avfiltergraph.h>
-#include <libavfilter/buffersink.h>
-#include <libavfilter/buffersrc.h>
-#include <libavutil/opt.h>
-#include <libavutil/pixdesc.h>
-}
-#ifdef WIN32
-#pragma comment(lib, "avcodec.lib")
-#pragma comment(lib, "avdevice.lib")
-#pragma comment(lib, "avfilter.lib")
-#pragma comment(lib, "avformat.lib")
-#pragma comment(lib, "avutil.lib")
-#pragma comment(lib, "postproc.lib")
-#pragma comment(lib, "swresample.lib")
-#pragma comment(lib, "swscale.lib")
-#endif
-
-#if _MSC_VER
-#define snprintf _snprintf
-#define PRIu64       "I64u"
-#define PRId64       "I64d"
-#define PRIx64       "I64x"
-#define PRIX64       "I64X"
-#endif
-
-
-static AVFormatContext *ifmt_ctx;
-static AVFormatContext *ofmt_ctx;
-typedef struct FilteringContext {
-	AVFilterContext *buffersink_ctx;
-	AVFilterContext *buffersrc_ctx;
-	AVFilterGraph *filter_graph;
-} FilteringContext;
-static FilteringContext *filter_ctx;
-
-static int open_input_file(const char *filename)
-{
-	int ret;
-	unsigned int i;
-
-	ifmt_ctx = NULL;
-	if ((ret = avformat_open_input(&ifmt_ctx, filename, NULL, NULL)) < 0) {
-		av_log(NULL, AV_LOG_ERROR, "Cannot open input file\n");
-		return ret;
-	}
-
-	if ((ret = avformat_find_stream_info(ifmt_ctx, NULL)) < 0) {
-		av_log(NULL, AV_LOG_ERROR, "Cannot find stream information\n");
-		return ret;
-	}
-
-	for (i = 0; i < ifmt_ctx->nb_streams; i++) {
-		AVStream *stream;
-		AVCodecContext *codec_ctx;
-		stream = ifmt_ctx->streams[i];
-		codec_ctx = stream->codec;
-		/* Reencode video & audio and remux subtitles etc. */
-		if (codec_ctx->codec_type == AVMEDIA_TYPE_VIDEO
-			|| codec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {
-			/* Open decoder */
-			ret = avcodec_open2(codec_ctx,
-				avcodec_find_decoder(codec_ctx->codec_id), NULL);
-			if (ret < 0) {
-				av_log(NULL, AV_LOG_ERROR, "Failed to open decoder for stream #%u\n", i);
-				return ret;
-			}
-		}
-	}
-
-	av_dump_format(ifmt_ctx, 0, filename, 0);
-	return 0;
-}
-
-static int open_output_file(const char *filename)
-{
-	AVStream *out_stream;
-	AVStream *in_stream;
-	AVCodecContext *dec_ctx, *enc_ctx;
-	AVCodec *encoder;
-	int ret;
-	unsigned int i;
-
-	ofmt_ctx = NULL;
-	avformat_alloc_output_context2(&ofmt_ctx, NULL, NULL, filename);
-	if (!ofmt_ctx) {
-		av_log(NULL, AV_LOG_ERROR, "Could not create output context\n");
-		return AVERROR_UNKNOWN;
-	}
-
-
-	for (i = 0; i < ifmt_ctx->nb_streams; i++) {
-		out_stream = avformat_new_stream(ofmt_ctx, NULL);
-		if (!out_stream) {
-			av_log(NULL, AV_LOG_ERROR, "Failed allocating output stream\n");
-			return AVERROR_UNKNOWN;
-		}
-
-		in_stream = ifmt_ctx->streams[i];
-		dec_ctx = in_stream->codec;
-		enc_ctx = out_stream->codec;
-
-		if (ofmt_ctx->oformat->flags & AVFMT_GLOBALHEADER)
-			enc_ctx->flags |= CODEC_FLAG_GLOBAL_HEADER;
-
-
-		if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO
-			|| dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {
-			/* in this example, we choose transcoding to same codec */
-			encoder = avcodec_find_encoder(dec_ctx->codec_id);
-			if (!encoder) {
-				av_log(NULL, AV_LOG_FATAL, "Necessary encoder not found\n");
-				return AVERROR_INVALIDDATA;
-			}
-
-			/* In this example, we transcode to same properties (picture size,
-			* sample rate etc.). These properties can be changed for output
-			* streams easily using filters */
-			if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {
-				enc_ctx->height = dec_ctx->height;
-				enc_ctx->width = dec_ctx->width;
-				enc_ctx->sample_aspect_ratio = dec_ctx->sample_aspect_ratio;
-				/* take first format from list of supported formats */
-				enc_ctx->pix_fmt = encoder->pix_fmts[0];
-				/* video time_base can be set to whatever is handy and supported by encoder */
-				enc_ctx->time_base = dec_ctx->time_base;
-
-				enc_ctx->me_range = 16;
-				enc_ctx->max_qdiff = 4;
-				enc_ctx->qmin = 10;
-				enc_ctx->qmax = 30;
-				enc_ctx->qcompress = 0.6;
-			}
-			else {
-				enc_ctx->sample_rate = dec_ctx->sample_rate;
-				enc_ctx->channel_layout = dec_ctx->channel_layout;
-				enc_ctx->channels = av_get_channel_layout_nb_channels(enc_ctx->channel_layout);
-				/* take first format from list of supported formats */
-				enc_ctx->sample_fmt = encoder->sample_fmts[0];
-				enc_ctx->time_base.num = 1;
-				enc_ctx->time_base.den = enc_ctx->sample_rate;
-			}
-
-			/* Third parameter can be used to pass settings to encoder */
-			ret = avcodec_open2(enc_ctx, encoder, NULL);
-			if (ret < 0) {
-				av_log(NULL, AV_LOG_ERROR, "Cannot open video encoder for stream #%u\n", i);
-				return ret;
-			}
-		}
-		else if (dec_ctx->codec_type == AVMEDIA_TYPE_UNKNOWN) {
-			av_log(NULL, AV_LOG_FATAL, "Elementary stream #%d is of unknown type, cannot proceed\n", i);
-			return AVERROR_INVALIDDATA;
-		}
-		else {
-			/* if this stream must be remuxed */
-			ret = avcodec_copy_context(ofmt_ctx->streams[i]->codec,
-				ifmt_ctx->streams[i]->codec);
-			if (ret < 0) {
-				av_log(NULL, AV_LOG_ERROR, "Copying stream context failed\n");
-				return ret;
-			}
-		}
-	}
-	av_dump_format(ofmt_ctx, 0, filename, 1);
-
-	if (!(ofmt_ctx->oformat->flags & AVFMT_NOFILE)) {
-		ret = avio_open(&ofmt_ctx->pb, filename, AVIO_FLAG_WRITE);
-		if (ret < 0) {
-			av_log(NULL, AV_LOG_ERROR, "Could not open output file '%s'", filename);
-			return ret;
-		}
-	}
-
-	/* init muxer, write output file header */
-	ret = avformat_write_header(ofmt_ctx, NULL);
-	if (ret < 0) {
-		av_log(NULL, AV_LOG_ERROR, "Error occurred when opening output file\n");
-		return ret;
-	}
-
-	return 0;
-}
-
-static int init_filter(FilteringContext* fctx, AVCodecContext *dec_ctx,
-	AVCodecContext *enc_ctx, const char *filter_spec)
-{
-	char args[512];
-	int ret = 0;
-	AVFilter *buffersrc = NULL;
-	AVFilter *buffersink = NULL;
-	AVFilterContext *buffersrc_ctx = NULL;
-	AVFilterContext *buffersink_ctx = NULL;
-	AVFilterInOut *outputs = avfilter_inout_alloc();
-	AVFilterInOut *inputs = avfilter_inout_alloc();
-	AVFilterGraph *filter_graph = avfilter_graph_alloc();
-
-	if (!outputs || !inputs || !filter_graph) {
-		ret = AVERROR(ENOMEM);
-		goto end;
-	}
-
-	if (dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {
-		buffersrc = avfilter_get_by_name("buffer");
-		buffersink = avfilter_get_by_name("buffersink");
-		if (!buffersrc || !buffersink) {
-			av_log(NULL, AV_LOG_ERROR, "filtering source or sink element not found\n");
-			ret = AVERROR_UNKNOWN;
-			goto end;
-		}
-
-		snprintf(args, sizeof(args),
-			"video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:pixel_aspect=%d/%d",
-			dec_ctx->width, dec_ctx->height, dec_ctx->pix_fmt,
-			dec_ctx->time_base.num, dec_ctx->time_base.den,
-			dec_ctx->sample_aspect_ratio.num,
-			dec_ctx->sample_aspect_ratio.den);
-
-		ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in",
-			args, NULL, filter_graph);
-		if (ret < 0) {
-			av_log(NULL, AV_LOG_ERROR, "Cannot create buffer source\n");
-			goto end;
-		}
-
-		ret = avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out",
-			NULL, NULL, filter_graph);
-		if (ret < 0) {
-			av_log(NULL, AV_LOG_ERROR, "Cannot create buffer sink\n");
-			goto end;
-		}
-
-		ret = av_opt_set_bin(buffersink_ctx, "pix_fmts",
-			(uint8_t*)&enc_ctx->pix_fmt, sizeof(enc_ctx->pix_fmt),
-			AV_OPT_SEARCH_CHILDREN);
-		if (ret < 0) {
-			av_log(NULL, AV_LOG_ERROR, "Cannot set output pixel format\n");
-			goto end;
-		}
-	}
-	else if (dec_ctx->codec_type == AVMEDIA_TYPE_AUDIO) {
-		buffersrc = avfilter_get_by_name("abuffer");
-		buffersink = avfilter_get_by_name("abuffersink");
-		if (!buffersrc || !buffersink) {
-			av_log(NULL, AV_LOG_ERROR, "filtering source or sink element not found\n");
-			ret = AVERROR_UNKNOWN;
-			goto end;
-		}
-
-		if (!dec_ctx->channel_layout)
-			dec_ctx->channel_layout =
-			av_get_default_channel_layout(dec_ctx->channels);
-		sprintf(args, //sizeof(args),
-			"time_base=%d/%d:sample_rate=%d:sample_fmt=%s:channel_layout=0x%"PRIx64,
-			dec_ctx->time_base.num, dec_ctx->time_base.den, dec_ctx->sample_rate,
-			av_get_sample_fmt_name(dec_ctx->sample_fmt),
-			dec_ctx->channel_layout);
-		ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in",
-			args, NULL, filter_graph);
-		if (ret < 0) {
-			av_log(NULL, AV_LOG_ERROR, "Cannot create audio buffer source\n");
-			goto end;
-		}
-
-		ret = avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out",
-			NULL, NULL, filter_graph);
-		if (ret < 0) {
-			av_log(NULL, AV_LOG_ERROR, "Cannot create audio buffer sink\n");
-			goto end;
-		}
-
-		ret = av_opt_set_bin(buffersink_ctx, "sample_fmts",
-			(uint8_t*)&enc_ctx->sample_fmt, sizeof(enc_ctx->sample_fmt),
-			AV_OPT_SEARCH_CHILDREN);
-		if (ret < 0) {
-			av_log(NULL, AV_LOG_ERROR, "Cannot set output sample format\n");
-			goto end;
-		}
-
-		ret = av_opt_set_bin(buffersink_ctx, "channel_layouts",
-			(uint8_t*)&enc_ctx->channel_layout,
-			sizeof(enc_ctx->channel_layout), AV_OPT_SEARCH_CHILDREN);
-		if (ret < 0) {
-			av_log(NULL, AV_LOG_ERROR, "Cannot set output channel layout\n");
-			goto end;
-		}
-
-		ret = av_opt_set_bin(buffersink_ctx, "sample_rates",
-			(uint8_t*)&enc_ctx->sample_rate, sizeof(enc_ctx->sample_rate),
-			AV_OPT_SEARCH_CHILDREN);
-		if (ret < 0) {
-			av_log(NULL, AV_LOG_ERROR, "Cannot set output sample rate\n");
-			goto end;
-		}
-	}
-	else {
-		ret = AVERROR_UNKNOWN;
-		goto end;
-	}
-
-	/* Endpoints for the filter graph. */
-	outputs->name = av_strdup("in");
-	outputs->filter_ctx = buffersrc_ctx;
-	outputs->pad_idx = 0;
-	outputs->next = NULL;
-
-	inputs->name = av_strdup("out");
-	inputs->filter_ctx = buffersink_ctx;
-	inputs->pad_idx = 0;
-	inputs->next = NULL;
-
-	if (!outputs->name || !inputs->name) {
-		ret = AVERROR(ENOMEM);
-		goto end;
-	}
-
-	if ((ret = avfilter_graph_parse_ptr(filter_graph, filter_spec,
-		&inputs, &outputs, NULL)) < 0)
-		goto end;
-
-	if ((ret = avfilter_graph_config(filter_graph, NULL)) < 0)
-		goto end;
-
-	/* Fill FilteringContext */
-	fctx->buffersrc_ctx = buffersrc_ctx;
-	fctx->buffersink_ctx = buffersink_ctx;
-	fctx->filter_graph = filter_graph;
-
-end:
-	avfilter_inout_free(&inputs);
-	avfilter_inout_free(&outputs);
-
-	return ret;
-}
-
-static int init_filters(void)
-{
-	const char *filter_spec;
-	unsigned int i;
-	int ret;
-	filter_ctx = (FilteringContext *)av_malloc_array(ifmt_ctx->nb_streams, sizeof(*filter_ctx));
-	if (!filter_ctx)
-		return AVERROR(ENOMEM);
-
-	for (i = 0; i < ifmt_ctx->nb_streams; i++) {
-		filter_ctx[i].buffersrc_ctx = NULL;
-		filter_ctx[i].buffersink_ctx = NULL;
-		filter_ctx[i].filter_graph = NULL;
-		if (!(ifmt_ctx->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO
-			|| ifmt_ctx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO))
-			continue;
-
-
-		if (ifmt_ctx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO)
-			filter_spec = "null"; /* passthrough (dummy) filter for video */
-		else
-			filter_spec = "anull"; /* passthrough (dummy) filter for audio */
-		ret = init_filter(&filter_ctx[i], ifmt_ctx->streams[i]->codec,
-			ofmt_ctx->streams[i]->codec, filter_spec);
-		if (ret)
-			return ret;
-	}
-	return 0;
-}
-
-static int encode_write_frame(AVFrame *filt_frame, unsigned int stream_index, int *got_frame) {
-	int ret;
-	int got_frame_local;
-	AVPacket enc_pkt;
-	int(*enc_func)(AVCodecContext *, AVPacket *, const AVFrame *, int *) =
-		(ifmt_ctx->streams[stream_index]->codec->codec_type ==
-		AVMEDIA_TYPE_VIDEO) ? avcodec_encode_video2 : avcodec_encode_audio2;
-
-	if (!got_frame)
-		got_frame = &got_frame_local;
-
-	av_log(NULL, AV_LOG_INFO, "Encoding frame\n");
-	/* encode filtered frame */
-	enc_pkt.data = NULL;
-	enc_pkt.size = 0;
-	av_init_packet(&enc_pkt);
-	ret = enc_func(ofmt_ctx->streams[stream_index]->codec, &enc_pkt,
-		filt_frame, got_frame);
-	av_frame_free(&filt_frame);
-	if (ret < 0)
-		return ret;
-	if (!(*got_frame))
-		return 0;
-
-	/* prepare packet for muxing */
-	enc_pkt.stream_index = stream_index;
-	av_packet_rescale_ts(&enc_pkt,
-		ofmt_ctx->streams[stream_index]->codec->time_base,
-		ofmt_ctx->streams[stream_index]->time_base);
-
-	av_log(NULL, AV_LOG_DEBUG, "Muxing frame\n");
-	/* mux encoded frame */
-	ret = av_interleaved_write_frame(ofmt_ctx, &enc_pkt);
-	return ret;
-}
-
-static int filter_encode_write_frame(AVFrame *frame, unsigned int stream_index)
-{
-	int ret;
-	AVFrame *filt_frame;
-
-	av_log(NULL, AV_LOG_INFO, "Pushing decoded frame to filters\n");
-	/* push the decoded frame into the filtergraph */
-	ret = av_buffersrc_add_frame_flags(filter_ctx[stream_index].buffersrc_ctx,
-		frame, 0);
-	if (ret < 0) {
-		av_log(NULL, AV_LOG_ERROR, "Error while feeding the filtergraph\n");
-		return ret;
-	}
-
-	/* pull filtered frames from the filtergraph */
-	while (1) {
-		filt_frame = av_frame_alloc();
-		if (!filt_frame) {
-			ret = AVERROR(ENOMEM);
-			break;
-		}
-		av_log(NULL, AV_LOG_INFO, "Pulling filtered frame from filters\n");
-		ret = av_buffersink_get_frame(filter_ctx[stream_index].buffersink_ctx,
-			filt_frame);
-		if (ret < 0) {
-			/* if no more frames for output - returns AVERROR(EAGAIN)
-			* if flushed and no more frames for output - returns AVERROR_EOF
-			* rewrite retcode to 0 to show it as normal procedure completion
-			*/
-			if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
-				ret = 0;
-			av_frame_free(&filt_frame);
-			break;
-		}
-
-		filt_frame->pict_type = AV_PICTURE_TYPE_NONE;
-		ret = encode_write_frame(filt_frame, stream_index, NULL);
-		if (ret < 0)
-			break;
-	}
-
-	return ret;
-}
-
-static int flush_encoder(unsigned int stream_index)
-{
-	int ret;
-	int got_frame;
-
-	if (!(ofmt_ctx->streams[stream_index]->codec->codec->capabilities &
-		CODEC_CAP_DELAY))
-		return 0;
-
-	while (1) {
-		av_log(NULL, AV_LOG_INFO, "Flushing stream #%u encoder\n", stream_index);
-		ret = encode_write_frame(NULL, stream_index, &got_frame);
-		if (ret < 0)
-			break;
-		if (!got_frame)
-			return 0;
-	}
-	return ret;
-}
-
-int transcode(const char * input){
-	int ret;
-	AVPacket packet;
-	AVFrame *frame = NULL;
-	enum AVMediaType type;
-	unsigned int stream_index;
-	unsigned int i;
-	int got_frame;
-	int(*dec_func)(AVCodecContext *, AVFrame *, int *, const AVPacket *);
-	memset(&packet, 0, sizeof(AVPacket));
-
-	char output[1024];
-	get_output_file_name(input, "pip_", output);
-
-	if ((ret = open_input_file(input)) < 0)
-		goto end;
-	if ((ret = open_output_file(output)) < 0)
-		goto end;
-	if ((ret = init_filters()) < 0)
-		goto end;
-
-	/* read all packets */
-	while (1) {
-		if ((ret = av_read_frame(ifmt_ctx, &packet)) < 0)
-			break;
-		stream_index = packet.stream_index;
-		type = ifmt_ctx->streams[packet.stream_index]->codec->codec_type;
-		av_log(NULL, AV_LOG_DEBUG, "Demuxer gave frame of stream_index %u\n",
-			stream_index);
-
-		if (filter_ctx[stream_index].filter_graph) {
-			av_log(NULL, AV_LOG_DEBUG, "Going to reencode&filter the frame\n");
-			frame = av_frame_alloc();
-			if (!frame) {
-				ret = AVERROR(ENOMEM);
-				break;
-			}
-			av_packet_rescale_ts(&packet,
-				ifmt_ctx->streams[stream_index]->time_base,
-				ifmt_ctx->streams[stream_index]->codec->time_base);
-			dec_func = (type == AVMEDIA_TYPE_VIDEO) ? avcodec_decode_video2 :
-				avcodec_decode_audio4;
-			ret = dec_func(ifmt_ctx->streams[stream_index]->codec, frame,
-				&got_frame, &packet);
-			if (ret < 0) {
-				av_frame_free(&frame);
-				av_log(NULL, AV_LOG_ERROR, "Decoding failed\n");
-				break;
-			}
-
-			if (got_frame) {
-				frame->pts = av_frame_get_best_effort_timestamp(frame);
-				ret = filter_encode_write_frame(frame, stream_index);
-				av_frame_free(&frame);
-				if (ret < 0)
-					goto end;
-			}
-			else {
-				av_frame_free(&frame);
-			}
-		}
-		else {
-			/* remux this frame without reencoding */
-			av_packet_rescale_ts(&packet,
-				ifmt_ctx->streams[stream_index]->time_base,
-				ofmt_ctx->streams[stream_index]->time_base);
-
-			ret = av_interleaved_write_frame(ofmt_ctx, &packet);
-			if (ret < 0)
-				goto end;
-		}
-		av_packet_unref(&packet);
-	}
-
-	/* flush filters and encoders */
-	for (i = 0; i < ifmt_ctx->nb_streams; i++) {
-		/* flush filter */
-		if (!filter_ctx[i].filter_graph)
-			continue;
-		ret = filter_encode_write_frame(NULL, i);
-		if (ret < 0) {
-			av_log(NULL, AV_LOG_ERROR, "Flushing filter failed\n");
-			goto end;
-		}
-
-		/* flush encoder */
-		ret = flush_encoder(i);
-		if (ret < 0) {
-			av_log(NULL, AV_LOG_ERROR, "Flushing encoder failed\n");
-			goto end;
-		}
-	}
-
-	av_write_trailer(ofmt_ctx);
-end:
-	av_packet_unref(&packet);
-	av_frame_free(&frame);
-	for (i = 0; i < ifmt_ctx->nb_streams; i++) {
-		avcodec_close(ifmt_ctx->streams[i]->codec);
-		if (ofmt_ctx && ofmt_ctx->nb_streams > i && ofmt_ctx->streams[i] && ofmt_ctx->streams[i]->codec)
-			avcodec_close(ofmt_ctx->streams[i]->codec);
-		if (filter_ctx && filter_ctx[i].filter_graph)
-			avfilter_graph_free(&filter_ctx[i].filter_graph);
-	}
-	av_free(filter_ctx);
-	avformat_close_input(&ifmt_ctx);
-	if (ofmt_ctx && !(ofmt_ctx->oformat->flags & AVFMT_NOFILE))
-		avio_closep(&ofmt_ctx->pb);
-	avformat_free_context(ofmt_ctx);
-
-	//if (ret < 0)
-	//  av_log(NULL, AV_LOG_ERROR, "Error occurred: %s\n", av_err2str(ret));
-
-	return ret ? 1 : 0;
-}
-
-#define MIN_TIME_INTERVAL 0.2
+#define MIN_TIME_INTERVAL 25
 
 
 int process_av_files()
 int process_av_files()
 {
 {
 	av_register_all();
 	av_register_all();
 	avfilter_register_all();
 	avfilter_register_all();
 
 
-	CVideoTranscoder videoTranscoder;
+	CAVTranscoder videoTranscoder;
 
 
-	float cur_time = 0.0;
+	int64_t cur_time = 0;
 	bool has_file = sorted_media.size();
 	bool has_file = sorted_media.size();
 	while (has_file){
 	while (has_file){
 		while (has_file){
 		while (has_file){
 			media_info info = sorted_media.front();
 			media_info info = sorted_media.front();
 
 
-			if (info.start_time - cur_time < MIN_TIME_INTERVAL) {
+			if (info.start_time_ms - cur_time < MIN_TIME_INTERVAL) {
 				sorted_media.pop_front();
 				sorted_media.pop_front();
 				videoTranscoder.add(info);
 				videoTranscoder.add(info);
 			}
 			}

@@ -82,14 +82,23 @@
     <Text Include="ReadMe.txt" />
     <Text Include="ReadMe.txt" />
   </ItemGroup>
   </ItemGroup>
   <ItemGroup>
   <ItemGroup>
+    <ClCompile Include="AudioDecoder.cpp" />
+    <ClCompile Include="AudioEncoder.cpp" />
+    <ClCompile Include="AVDecoder.cpp" />
     <ClCompile Include="merge_pip.cpp" />
     <ClCompile Include="merge_pip.cpp" />
     <ClCompile Include="tools.cpp" />
     <ClCompile Include="tools.cpp" />
     <ClCompile Include="VideoDecoder.cpp" />
     <ClCompile Include="VideoDecoder.cpp" />
-    <ClCompile Include="VideoTranscoder.cpp" />
+    <ClCompile Include="AVTranscoder.cpp" />
+    <ClCompile Include="VideoEncoder.cpp" />
   </ItemGroup>
   </ItemGroup>
   <ItemGroup>
   <ItemGroup>
+    <ClInclude Include="AudioDecoder.h" />
+    <ClInclude Include="AudioEncoder.h" />
+    <ClInclude Include="AVDecoder.h" />
+    <ClInclude Include="media_info.h" />
     <ClInclude Include="VideoDecoder.h" />
     <ClInclude Include="VideoDecoder.h" />
-    <ClInclude Include="VideoTranscoder.h" />
+    <ClInclude Include="AVTranscoder.h" />
+    <ClInclude Include="VideoEncoder.h" />
   </ItemGroup>
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
   <ImportGroup Label="ExtensionTargets">

@@ -24,18 +24,45 @@
     <ClCompile Include="merge_pip.cpp">
     <ClCompile Include="merge_pip.cpp">
       <Filter>源文件</Filter>
       <Filter>源文件</Filter>
     </ClCompile>
     </ClCompile>
-    <ClCompile Include="VideoTranscoder.cpp">
+    <ClCompile Include="VideoDecoder.cpp">
       <Filter>源文件</Filter>
       <Filter>源文件</Filter>
     </ClCompile>
     </ClCompile>
-    <ClCompile Include="VideoDecoder.cpp">
+    <ClCompile Include="AVDecoder.cpp">
+      <Filter>源文件</Filter>
+    </ClCompile>
+    <ClCompile Include="AudioDecoder.cpp">
+      <Filter>源文件</Filter>
+    </ClCompile>
+    <ClCompile Include="AVTranscoder.cpp">
+      <Filter>源文件</Filter>
+    </ClCompile>
+    <ClCompile Include="VideoEncoder.cpp">
+      <Filter>源文件</Filter>
+    </ClCompile>
+    <ClCompile Include="AudioEncoder.cpp">
       <Filter>源文件</Filter>
       <Filter>源文件</Filter>
     </ClCompile>
     </ClCompile>
   </ItemGroup>
   </ItemGroup>
   <ItemGroup>
   <ItemGroup>
-    <ClInclude Include="VideoTranscoder.h">
+    <ClInclude Include="VideoDecoder.h">
       <Filter>头文件</Filter>
       <Filter>头文件</Filter>
     </ClInclude>
     </ClInclude>
-    <ClInclude Include="VideoDecoder.h">
+    <ClInclude Include="AVDecoder.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
+    <ClInclude Include="AudioDecoder.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
+    <ClInclude Include="media_info.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
+    <ClInclude Include="AVTranscoder.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
+    <ClInclude Include="VideoEncoder.h">
+      <Filter>头文件</Filter>
+    </ClInclude>
+    <ClInclude Include="AudioEncoder.h">
       <Filter>头文件</Filter>
       <Filter>头文件</Filter>
     </ClInclude>
     </ClInclude>
   </ItemGroup>
   </ItemGroup>