ffmpeg转码本地文件(一)

最新推荐文章于 2024-08-26 14:04:47 发布

置顶朱韦刚

最新推荐文章于 2024-08-26 14:04:47 发布

阅读量4.7k

点赞数 3

分类专栏： ffmpeg 朱韦刚的流媒体技术专栏

本文链接：https://blog.csdn.net/zhuweigangzwg/article/details/50837049

版权

朱韦刚的流媒体技术专栏同时被 2 个专栏收录

90 篇文章 222 订阅

订阅专栏

ffmpeg

31 篇文章 7 订阅

订阅专栏

ffmpeg转码本地文件(一)

实现目标：输入本地文件，实现本地文件转码,里面包含mux层转码，codec层转码，视频格式转换，音频重采样等功能，功能点请看注释，注意：注释很重要。

#ifndef __FFMPEG_H__
#define __FFMPEG_H__

#include "info.h"

extern "C"
{
#include "libavformat/avformat.h"
#include "libavformat/avio.h"
#include "libavcodec/avcodec.h"
#include "libswscale/swscale.h"
#include "libavutil/avutil.h"
#include "libavutil/mathematics.h"
#include "libswresample/swresample.h"
#include "libavutil/opt.h"
#include "libavutil/channel_layout.h"
#include "libavutil/samplefmt.h"
#include "libavdevice/avdevice.h"  //摄像头所用
#include "libavfilter/avfilter.h"
#include "libavutil/error.h"
#include "libavutil/mathematics.h"  
#include "libavutil/time.h"  
#include "libavutil/fifo.h"
#include "libavutil/audio_fifo.h"   //这里是做分片时候重采样编码音频用的
#include "inttypes.h"
#include "stdint.h"
};

#pragma comment(lib,"avformat.lib")
#pragma comment(lib,"avcodec.lib")
#pragma comment(lib,"avdevice.lib")
#pragma comment(lib,"avfilter.lib")
#pragma comment(lib,"avutil.lib")
#pragma comment(lib,"postproc.lib")
#pragma comment(lib,"swresample.lib")
#pragma comment(lib,"swscale.lib")

//#define INPUTURL   "../in_stream/22.flv" 
//#define INPUTURL "../in_stream/闪电侠.The.Flash.S01E01.中英字幕.HDTVrip.624X352.mp4"
//#define INPUTURL   "../in_stream/33.ts" 
//#define INPUTURL   "../in_stream/22mp4.mp4" 
//#define INPUTURL   "../in_stream/EYED0081.MOV" 
//#define INPUTURL   "../in_stream/李荣浩 - 李白.mp3" 
//#define INPUTURL   "../in_stream/avier1.mp4" 
//#define INPUTURL   "../in_stream/分歧者2预告片.mp4" 
//#define INPUTURL   "../in_stream/Class8简介.m4v" 
//#define INPUTURL   "../in_stream/22.ts" 
//#define INPUTURL   "../in_stream/44.mp3"
//#define INPUTURL   "../in_stream/ceshi.mp4"
//#define INPUTURL   "../in_stream/33.mp4"
#define INPUTURL   "../in_stream/father.avi"
//#define INPUTURL   "../in_stream/西海情歌.wav" 
//#define INPUTURL   "../in_stream/Furious_7_2015_International_Trailer_2_5.1-1080p-HDTN.mp4" 
//#define INPUTURL   "../in_stream/Wildlife.wmv" 
//#define INPUTURL   "../in_stream/单身男女2.HD1280超清国语版.mp4" 
//#define INPUTURL     "rtmp://221.228.193.50:1935/live/teststream1" 
#define OUTPUTURL  "../out_stream/father1111.mp4"
//#define OUTPUTURL    "rtmp://221.228.193.50:1935/live/zwg"
//#define OUTPUTURL    "rtmp://221.228.193.50:1935/live/zwg"

enum AVSampleFormat_t 
{
	AV_SAMPLE_FMT_NONE_t = -1,
	AV_SAMPLE_FMT_U8_t,          ///< unsigned 8 bits
	AV_SAMPLE_FMT_S16_t,         ///< signed 16 bits
	AV_SAMPLE_FMT_S32_t,         ///< signed 32 bits
	AV_SAMPLE_FMT_FLT_t,         ///< float
	AV_SAMPLE_FMT_DBL_t,         ///< double

	AV_SAMPLE_FMT_U8P_t,         ///< unsigned 8 bits, planar
	AV_SAMPLE_FMT_S16P_t,        ///< signed 16 bits, planar
	AV_SAMPLE_FMT_S32P_t,        ///< signed 32 bits, planar
	AV_SAMPLE_FMT_FLTP_t,        ///< float, planar
	AV_SAMPLE_FMT_DBLP_t,        ///< double, planar

	AV_SAMPLE_FMT_NB_t           ///< Number of sample formats. DO NOT USE if linking dynamically
};

/************************************************************************/
/************************************************************************/
//是否用音频fifo 否则用全局的fifo 两种方法
//#define AUDIO_FIFO
/************************************************************************/
/************************************************************************/


//video param
extern int m_dwWidth;
extern int m_dwHeight;
extern double m_dbFrameRate;  //帧率                                                  
extern AVCodecID video_codecID;
extern AVPixelFormat video_pixelfromat;
extern int gop_size;
extern int max_b_frame;
extern int thread_count; //用cpu内核数目

//audio param
extern int m_dwChannelCount; //声道
extern AVSampleFormat_t m_dwBitsPerSample; //样本
extern int m_dwFrequency;     //采样率
extern AVCodecID audio_codecID;
extern int audio_frame_size;
extern int m_audiomuxtimebasetrue;  //音频的mux层timebse是否正确

extern AVFifoBuffer * m_fifo; //存放pcm数据
extern AVAudioFifo * m_audiofifo; //音频存放pcm数据
extern int64_t m_first_audio_pts; //第一帧的音频pts
extern int m_is_first_audio_pts; //是否已经记录第一帧音频时间戳

#define AUDIO_ID            0                                                 //packet 中的ID ，如果先加入音频 pocket 则音频是 0  视频是1，否则相反(影响add_out_stream顺序)
#define VIDEO_ID            1

extern int nRet;                                                              //状态标志
extern AVFormatContext* icodec;												  //输入流context
extern AVFormatContext* ocodec ;                                              //输出流context
extern char szError[256];                                                     //错误字符串
extern AVStream* ovideo_st;
extern AVStream* oaudio_st;              
extern int video_stream_idx;
extern int audio_stream_idx;
extern AVCodec *audio_codec;
extern AVCodec *video_codec;
extern AVPacket pkt;   
extern AVBitStreamFilterContext * vbsf_aac_adtstoasc;                         //aac->adts to asc过滤器
static struct SwsContext * img_convert_ctx_video = NULL;
static int sws_flags = SWS_BICUBIC; //差值算法,双三次


int init_demux(char * Filename,AVFormatContext ** iframe_c);
int init_mux();
int uinit_demux();
int uinit_mux();
//for mux
AVStream * add_out_stream(AVFormatContext* output_format_context,AVMediaType codec_type_t); 
//for codec
AVStream * add_out_stream2(AVFormatContext* output_format_context,AVMediaType codec_type_t,AVCodec **codec); 
int init_decode(int stream_type);
int init_code(int stream_type);
int uinit_decode(int stream_type);
int uinit_code(int stream_type);
int perform_decode(int stream_type,AVFrame * picture);
int perform_code(int stream_type,AVFrame * picture);   //用于AVFifoBuffer
int perform_code2(int stream_type,AVFrame * picture);  //用于AVAudioFifo
void perform_yuv_conversion(AVFrame * pinframe,AVFrame * poutframe);
SwrContext * init_pcm_resample(AVFrame *in_frame, AVFrame *out_frame);
void uinit_pcm_resample(AVFrame * poutframe,SwrContext * swr_ctx);
int preform_pcm_resample(SwrContext * pSwrCtx,AVFrame *in_frame, AVFrame *out_frame);
int audio_support(AVCodec * pCodec,int *channel,int * playout,int *samplePerSec,AVSampleFormat_t *sample_fmt);
int video_support(AVCodec * pCodec,AVPixelFormat * video_pixelfromat);
int transcode(); 
void write_frame(AVFormatContext *ocodec,int ID,AVPacket pkt_t); //这个是根据传过来的buf 和size 写入文件

#endif

#include "ffmpeg.h"

int nRet = 0;
AVFormatContext* icodec = NULL; 
AVFormatContext* ocodec = NULL;
char szError[256]; 
AVStream * ovideo_st = NULL;
AVStream * oaudio_st = NULL;
int video_stream_idx = -1;
int audio_stream_idx = -1;
AVCodec *audio_codec = NULL;
AVCodec *video_codec = NULL;
AVPacket pkt;
AVBitStreamFilterContext * vbsf_aac_adtstoasc = NULL;

//video param
int m_dwWidth = 640;
int m_dwHeight = 480;
double m_dbFrameRate = 23;  //帧率                                                  
AVCodecID video_codecID = AV_CODEC_ID_H264;
AVPixelFormat video_pixelfromat = AV_PIX_FMT_YUV420P;
int bit_rate = 400000;
int gop_size = 12;
int max_b_frame = 2;
int thread_count = 2;

//audio param
int m_dwChannelCount = 2;      //声道
int m_dwFrequency = 48000;     //采样率
AVSampleFormat_t m_dwBitsPerSample = AV_SAMPLE_FMT_S16_t;    //样本
int m_audiomuxtimebasetrue = 1;  //音频的mux层timebse是否正确

//aac
AVCodecID audio_codecID = AV_CODEC_ID_AAC;
int audio_frame_size  = 1024;

//mp3
//AVCodecID audio_codecID = AV_CODEC_ID_MP3;
//int audio_frame_size  = 1152;

AVFifoBuffer * m_fifo = NULL;
AVAudioFifo * m_audiofifo  = NULL;
int64_t m_first_audio_pts = 0; 
int m_is_first_audio_pts = 0;

int init_demux(char * Filename,AVFormatContext ** iframe_c)
{
	int i = 0;
	nRet = avformat_open_input(iframe_c, Filename,NULL, NULL);
	if (nRet != 0)
	{
		av_strerror(nRet, szError, 256);
		printf(szError);
		printf("\n");
		printf("Call avformat_open_input function failed!\n");
		return 0;
	}
	if (avformat_find_stream_info(*iframe_c,NULL) < 0)
	{
		printf("Call av_find_stream_info function failed!\n");
		return 0;
	}
	//输出视频信息
	av_dump_format(*iframe_c, -1, Filename, 0);

	//添加音频信息到输出context
	for (i = 0; i < (*iframe_c)->nb_streams; i++)
	{
		if ((*iframe_c)->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO)
		{
			double FrameRate = (*iframe_c)->streams[i]->r_frame_rate.num /(double)(*iframe_c)->streams[i]->r_frame_rate.den;
			m_dbFrameRate =(int)(FrameRate + 0.5); 
			video_stream_idx = i;
		}
		else if ((*iframe_c)->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO)
		{
			audio_stream_idx = i;
			if(icodec->streams[audio_stream_idx]->time_base.den == 0 ||
				icodec->streams[audio_stream_idx]->time_base.num == 0 ||
				icodec->streams[audio_stream_idx]->codec->sample_rate == 0)
			{
				m_audiomuxtimebasetrue = 0;
			}
		}
	}

	return 1;
}

int init_mux()
{
	int i = 0;
	int ret = 0;
	/* allocate the output media context */
	avformat_alloc_output_context2(&ocodec, NULL,NULL, OUTPUTURL);
	if (!ocodec) 
	{
		return getchar();
	}
	AVOutputFormat* ofmt = NULL;
	ofmt = ocodec->oformat;

	/* open the output file, if needed */
	if (!(ofmt->flags & AVFMT_NOFILE))
	{
		if (avio_open(&ocodec->pb, OUTPUTURL, AVIO_FLAG_WRITE) < 0)
		{
			printf("Could not open '%s'\n", OUTPUTURL);
			return getchar();
		}
	}

	//这里添加的时候AUDIO_ID/VIDEO_ID有影响
	//添加音频信息到输出context
	if(audio_stream_idx != -1)//如果存在音频
	{
		ofmt->audio_codec = audio_codecID;
		//如果是音频需要编解码
		if(audio_codecID != icodec->streams[audio_stream_idx]->codec->codec_id ||
			1 != icodec->streams[audio_stream_idx]->codec->sample_fmt)
		{
			oaudio_st = add_out_stream2(ocodec, AVMEDIA_TYPE_AUDIO,&audio_codec);
		}
		else
		{
			oaudio_st = add_out_stream(ocodec, AVMEDIA_TYPE_AUDIO);
		}
		if ((strstr(ocodec->oformat->name, "flv") != NULL) || 
			(strstr(ocodec->oformat->name, "mp4") != NULL) || 
			(strstr(ocodec->oformat->name, "mov") != NULL) ||
			(strstr(ocodec->oformat->name, "3gp") != NULL))    
		{
			if (oaudio_st->codec->codec_id == AV_CODEC_ID_AAC) 
			{
				vbsf_aac_adtstoasc =  av_bitstream_filter_init("aac_adtstoasc");  
				if(vbsf_aac_adtstoasc == NULL)  
				{  
					return -1;  
				} 
			}
		}
	}


	//添加视频信息到输出context
	if (video_stream_idx != -1)//如果存在视频
	{
		ofmt->video_codec = video_codecID;
		//如果是视频需要编解码
		if(bit_rate != icodec->streams[video_stream_idx]->codec->bit_rate ||
			m_dwWidth != icodec->streams[video_stream_idx]->codec->width ||
			m_dwHeight != icodec->streams[video_stream_idx]->codec->height ||
			video_codecID != icodec->streams[video_stream_idx]->codec->codec_id || 
			m_dbFrameRate != av_q2d(icodec->streams[video_stream_idx]->r_frame_rate))
		{
			ovideo_st = add_out_stream2(ocodec, AVMEDIA_TYPE_VIDEO,&video_codec);
		}
		else
		{
			ovideo_st = add_out_stream(ocodec,AVMEDIA_TYPE_VIDEO);
		}
	}

	av_dump_format(ocodec, 0, OUTPUTURL, 1);

	if (video_stream_idx != -1)//如果存在视频
	{
		//如果是视频需要编解码
		if(bit_rate != icodec->streams[video_stream_idx]->codec->bit_rate ||
			m_dwWidth != icodec->streams[video_stream_idx]->codec->width ||
			m_dwHeight != icodec->streams[video_stream_idx]->codec->height ||
			video_codecID != icodec->streams[video_stream_idx]->codec->codec_id || 
			m_dbFrameRate != av_q2d(icodec->streams[video_stream_idx]->r_frame_rate))
		{
			//解码初始化
			ret = init_decode(VIDEO_ID);
			//编码初始化
			ret = init_code(VIDEO_ID);
		}
	}
	//如果是音频需要编解码
	if(audio_stream_idx != -1)//如果存在音频
	{
		if(audio_codecID != icodec->streams[audio_stream_idx]->codec->codec_id ||
			1 != icodec->streams[audio_stream_idx]->codec->sample_fmt)
		{
			//解码初始化
			ret = init_decode(AUDIO_ID);
			//编码初始化
			ret = init_code(AUDIO_ID);
		}
	}
	ret = avformat_write_header(ocodec, NULL);
	if (ret != 0)
	{
		printf("Call avformat_write_header function failed.\n");
		return 0;
	}
	return 1;
}

int uinit_demux()
{
	/* free the stream */
	av_free(icodec);
	return 1;
}

int uinit_mux()
{
	int i = 0;
	nRet = av_write_trailer(ocodec);
	if (nRet < 0)
	{
		av_strerror(nRet, szError, 256);
		printf(szError);
		printf("\n");
		printf("Call av_write_trailer function failed\n");
	}
	if (vbsf_aac_adtstoasc !=NULL)
	{
		av_bitstream_filter_close(vbsf_aac_adtstoasc); 
		vbsf_aac_adtstoasc = NULL;
	}
	av_dump_format(ocodec, -1, OUTPUTURL, 1); 

	if (video_stream_idx != -1)//如果存在视频
	{
		//如果是视频需要编解码
		if(bit_rate != icodec->streams[video_stream_idx]->codec->bit_rate ||
			m_dwWidth != icodec->streams[video_stream_idx]->codec->width ||
			m_dwHeight != icodec->streams[video_stream_idx]->codec->height ||
			video_codecID != icodec->streams[video_stream_idx]->codec->codec_id || 
			m_dbFrameRate != av_q2d(icodec->streams[video_stream_idx]->r_frame_rate))
		{
			uinit_decode(VIDEO_ID);
			uinit_code(VIDEO_ID);
		}
	}
	if(audio_stream_idx != -1)//如果存在音频
	{
		//如果是音频需要编解码
		if(audio_codecID != icodec->streams[audio_stream_idx]->codec->codec_id ||
			1 != icodec->streams[audio_stream_idx]->codec->sample_fmt)
		{
			uinit_decode(AUDIO_ID);
			uinit_code(AUDIO_ID);
		}
	}
	/* Free the streams. */
	for (i = 0; i < ocodec->nb_streams; i++) 
	{
		av_freep(&ocodec->streams[i]->codec);
		av_freep(&ocodec->streams[i]);
	}
	if (!(ocodec->oformat->flags & AVFMT_NOFILE))
	{
		/* Close the output file. */
		avio_close(ocodec->pb);
	}
	av_free(ocodec);
	return 1;
}

int init_decode(int stream_type)
{
	AVCodec *pcodec = NULL;
	AVCodecContext *cctext = NULL;

	if (stream_type == AUDIO_ID)
	{
		cctext = icodec->streams[audio_stream_idx]->codec;
		pcodec = avcodec_find_decoder(cctext->codec_id);
		if (!pcodec) 
		{
			return -1;
		}
	}
	else if (stream_type == VIDEO_ID)
	{
		cctext = icodec->streams[video_stream_idx]->codec;
		pcodec = avcodec_find_decoder(cctext->codec_id);
		if (!pcodec) 
		{
			return -1;
		}
	}
	//打开解码器
	nRet = avcodec_open2(cctext, pcodec, NULL); 
	if (nRet < 0)
	{
		printf("Could not open decoder\n");
		return -1;
	}
	return 1;
}

int init_code(int stream_type)
{
	AVCodecContext *cctext = NULL;

	if (stream_type == AUDIO_ID)
	{
		cctext = oaudio_st->codec;
		//打开编码器
		nRet = avcodec_open2(cctext, audio_codec, NULL); 
		if (nRet < 0)
		{
			printf("Could not open encoder\n");
			return 0;
		}
	}
	else if (stream_type == VIDEO_ID)
	{
		cctext = ovideo_st->codec;
		//打开编码器
		nRet = avcodec_open2(cctext, video_codec, NULL); 
		if (nRet < 0)
		{
			printf("Could not open encoder\n");
			return -1;
		}
	}
	return 1;
}

int uinit_decode(int stream_type)
{
	AVCodecContext *cctext = NULL;

	if (stream_type == AUDIO_ID)
	{
		cctext = oaudio_st->codec; 
	}
	else if (stream_type == VIDEO_ID)
	{
		cctext = icodec->streams[video_stream_idx]->codec; 
	}
	avcodec_close(cctext);
	return 1;
}

int uinit_code(int stream_type)
{
	AVCodecContext *cctext = NULL;

	if (stream_type == AUDIO_ID)
	{
		cctext = oaudio_st->codec; 
	}
	else if (stream_type == VIDEO_ID)
	{
		cctext = ovideo_st->codec; 
	}
	avcodec_close(cctext);
	return 1;
}

AVStream * add_out_stream(AVFormatContext* output_format_context,AVMediaType codec_type_t)
{
	AVStream * in_stream = NULL;
	AVStream * output_stream = NULL;
	AVCodecContext* output_codec_context = NULL;

	output_stream = avformat_new_stream(output_format_context,NULL);
	if (!output_stream)
	{
		return NULL;
	}

	switch (codec_type_t)
	{
	case AVMEDIA_TYPE_AUDIO:
		in_stream = icodec->streams[audio_stream_idx];
		break;
	case AVMEDIA_TYPE_VIDEO:
		in_stream = icodec->streams[video_stream_idx];
		break;
	default:
		break;
	}

	output_stream->id = output_format_context->nb_streams - 1;
	output_codec_context = output_stream->codec;
	output_stream->time_base  = in_stream->time_base;

	int ret = 0;
	ret = avcodec_copy_context(output_stream->codec, in_stream->codec);
	if (ret < 0) 
	{
		printf("Failed to copy context from input to output stream codec context\n");
		return NULL;
	}

	//这个很重要，要么纯复用解复用，不做编解码写头会失败,
	//另或者需要编解码如果不这样，生成的文件没有预览图，还有添加下面的header失败，置0之后会重新生成extradata
	output_codec_context->codec_tag = 0; 

	//if(! strcmp( output_format_context-> oformat-> name,  "mp4" ) ||
	//!strcmp (output_format_context ->oformat ->name , "mov" ) ||
	//!strcmp (output_format_context ->oformat ->name , "3gp" ) ||
	//!strcmp (output_format_context ->oformat ->name , "flv"))
	if(AVFMT_GLOBALHEADER & output_format_context->oformat->flags)
	{
		output_codec_context->flags |= CODEC_FLAG_GLOBAL_HEADER;
	}
	return output_stream;
}

AVStream * add_out_stream2(AVFormatContext* output_format_context,AVMediaType codec_type_t,AVCodec **codec)
{
	AVCodecContext* output_codec_context = NULL;
	AVStream * in_stream = NULL;
	AVStream * output_stream = NULL;
	AVCodecID codecID;

	switch (codec_type_t)
	{
	case AVMEDIA_TYPE_AUDIO:
		codecID = audio_codecID;
		in_stream = icodec->streams[audio_stream_idx];
		break;
	case AVMEDIA_TYPE_VIDEO:
		codecID = video_codecID;
		in_stream = icodec->streams[video_stream_idx];
		break;
	default:
		break;
	}

	/* find the encoder */
	*codec = avcodec_find_encoder(codecID);
	if (!(*codec)) 
	{
		return NULL;
	}

	output_stream = avformat_new_stream(output_format_context,*codec);
	if (!output_stream)
	{
		return NULL;
	}

	output_stream->id = output_format_context->nb_streams - 1;
	output_codec_context = output_stream->codec;
	output_stream->time_base  = in_stream->time_base;

	switch (codec_type_t)
	{
	case AVMEDIA_TYPE_AUDIO:
		output_codec_context->codec_id = audio_codecID;
		output_codec_context->codec_type = codec_type_t;
		output_stream->start_time = 0;
		output_codec_context->sample_rate = icodec->streams[audio_stream_idx]->codec->sample_rate;//m_dwFrequency;
		if(icodec->streams[audio_stream_idx]->codec->channels > 2)
		{
			output_codec_context->channels = m_dwChannelCount;
			output_codec_context->channel_layout = av_get_default_channel_layout(m_dwChannelCount);
		}
		else
		{
			output_codec_context->channels  = icodec->streams[audio_stream_idx]->codec->channels;
			if (icodec->streams[audio_stream_idx]->codec->channel_layout == 0)
			{
				output_codec_context->channel_layout = av_get_default_channel_layout(icodec->streams[audio_stream_idx]->codec->channels);
			}
			else
			{
				output_codec_context->channel_layout = icodec->streams[audio_stream_idx]->codec->channel_layout;
			}
		}
		//这个码率有些编码器不支持特别大，例如wav的码率是1411200 比aac大了10倍多
		output_codec_context->bit_rate = 128000;//icodec->streams[audio_stream_idx]->codec->bit_rate;
		output_codec_context->frame_size = audio_frame_size;
		output_codec_context->sample_fmt  = (AVSampleFormat)m_dwBitsPerSample; //样本
		output_codec_context->block_align = 0;
		//查看音频支持的声道，采样率，样本
		audio_support(*codec,&output_codec_context->channels,
			(int *)&output_codec_context->channel_layout,
			&output_codec_context->sample_rate,
			(AVSampleFormat_t *)&output_codec_context->sample_fmt);
		m_dwChannelCount = output_codec_context->channels;
		m_dwFrequency = output_codec_context->sample_rate;
		m_dwBitsPerSample = (AVSampleFormat_t)output_codec_context->sample_fmt;
		break;
	case AVMEDIA_TYPE_VIDEO:
		AVRational r_frame_rate_t;
		r_frame_rate_t.num = 100;
		r_frame_rate_t.den = (int)(m_dbFrameRate * 100);
		output_codec_context->time_base = in_stream->codec->time_base;
		output_stream->time_base  = in_stream->time_base;
		output_stream->r_frame_rate.num = r_frame_rate_t.den;
		output_stream->r_frame_rate.den = r_frame_rate_t.num;
		output_codec_context->codec_id = video_codecID;
		output_codec_context->codec_type = codec_type_t;
		output_stream->start_time = 0;
		output_codec_context->pix_fmt = video_pixelfromat;
		output_codec_context->width = m_dwWidth;
		output_codec_context->height = m_dwHeight;
		output_codec_context->bit_rate = bit_rate;
		output_codec_context->gop_size  = gop_size;         /* emit one intra frame every twelve frames at most */;
		output_codec_context->max_b_frames = max_b_frame;	//设置B帧最大数
		output_codec_context->thread_count = thread_count;  //线程数目
		output_codec_context->me_range = 16;
		output_codec_context->max_qdiff = 4;
		output_codec_context->qmin = 20; //调节清晰度和编码速度 //这个值调节编码后输出数据量越大输出数据量越小，越大编码速度越快，清晰度越差
		output_codec_context->qmax = 40; //调节清晰度和编码速度
		output_codec_context->qcompress = 0.6; 
		//查看视频支持的yuv格式
		video_support(*codec,&output_codec_context->pix_fmt);
		video_pixelfromat = output_codec_context->pix_fmt;
		break;
	default:
		break;
	}
	//这个很重要，要么纯复用解复用，不做编解码写头会失败,
	//另或者需要编解码如果不这样，生成的文件没有预览图，还有添加下面的header失败，置0之后会重新生成extradata
	output_codec_context->codec_tag = 0; 
	//if(! strcmp( output_format_context-> oformat-> name,  "mp4" ) ||
	//	!strcmp (output_format_context ->oformat ->name , "mov" ) ||
	//	!strcmp (output_format_context ->oformat ->name , "3gp" ) ||
	//	!strcmp (output_format_context ->oformat ->name , "flv" ))
	if(AVFMT_GLOBALHEADER & output_format_context->oformat->flags)
	{
		output_codec_context->flags |= CODEC_FLAG_GLOBAL_HEADER;
	}
	return output_stream;
}

int perform_decode(int stream_type,AVFrame * picture)
{
	AVCodecContext *cctext = NULL;
	int frameFinished = 0 ; 

	if (stream_type == AUDIO_ID)
	{
		cctext = icodec->streams[audio_stream_idx]->codec;
		avcodec_decode_audio4(cctext,picture,&frameFinished,&pkt);
		if(frameFinished)
		{
			return 0;
		}
	}
	else if (stream_type == VIDEO_ID)
	{
		cctext = icodec->streams[video_stream_idx]->codec;
		avcodec_decode_video2(cctext,picture,&frameFinished,&pkt);
		if(frameFinished)
		{
			return 0;
		}
	}
	return 1;
}

int perform_code(int stream_type,AVFrame * picture)
{
	AVCodecContext *cctext = NULL;
	AVPacket pkt_t;
	av_init_packet(&pkt_t);
	pkt_t.data = NULL; // packet data will be allocated by the encoder
	pkt_t.size = 0;
	int frameFinished = 0 ;

	if (stream_type == AUDIO_ID)
	{
		cctext = oaudio_st->codec;
		//如果进和出的的声道，样本，采样率不同,需要重采样
		if(icodec->streams[audio_stream_idx]->codec->sample_fmt != (AVSampleFormat)m_dwBitsPerSample ||
			icodec->streams[audio_stream_idx]->codec->channels != m_dwChannelCount ||
			icodec->streams[audio_stream_idx]->codec->sample_rate != m_dwFrequency)
		{
			int64_t pts_t = picture->pts;
			int duration_t = 0;
			if(m_audiomuxtimebasetrue == 0)
			{
				duration_t = (double)cctext->frame_size * (icodec->streams[audio_stream_idx]->codec->time_base.den /icodec->streams[audio_stream_idx]->codec->time_base.num)/ 
					icodec->streams[audio_stream_idx]->codec->sample_rate;
			}
			else
			{
				duration_t = (double)cctext->frame_size * (icodec->streams[audio_stream_idx]->time_base.den /icodec->streams[audio_stream_idx]->time_base.num)/ 
					icodec->streams[audio_stream_idx]->codec->sample_rate;
			}

			int frame_bytes = cctext->frame_size * av_get_bytes_per_sample(cctext->sample_fmt)* cctext->channels;
			AVFrame * pFrameResample = avcodec_alloc_frame();
			uint8_t * readbuff = new uint8_t[frame_bytes];

			if(av_sample_fmt_is_planar(cctext->sample_fmt))
			{
				frame_bytes /= cctext->channels;
			}

			while (av_fifo_size(m_fifo) >= frame_bytes) //取出写入的未读的包
			{
				pFrameResample->nb_samples = cctext->frame_size;
				av_fifo_generic_read(m_fifo, readbuff, frame_bytes, NULL);

				//这里一定要考虑音频分片的问题
				//如果是分片的avcodec_fill_audio_frame传入的buf是单声道的，但是buf_size 是两个声道加一起的数据量
				//如果不是分片的avcodec_fill_audio_frame传入的buf是双声道的，buf_size 是两个声道加一起的数据量
				if(av_sample_fmt_is_planar(cctext->sample_fmt))
				{
					avcodec_fill_audio_frame(pFrameResample,cctext->channels,cctext->sample_fmt,readbuff,frame_bytes * cctext->channels,1);
				}
				else
				{					
					avcodec_fill_audio_frame(pFrameResample,cctext->channels,cctext->sample_fmt,readbuff,frame_bytes,0);
				}

				if(m_is_first_audio_pts == 0)
				{
					m_first_audio_pts = pts_t;
					m_is_first_audio_pts = 1;
				}
				pFrameResample->pts = m_first_audio_pts;
				m_first_audio_pts += duration_t;


				pFrameResample->pts = av_rescale_q_rnd(pFrameResample->pts, icodec->streams[audio_stream_idx]->codec->time_base, oaudio_st->codec->time_base, AV_ROUND_NEAR_INF);
				nRet = avcodec_encode_audio2(cctext,&pkt_t,pFrameResample,&frameFinished);
				if (nRet>=0 && frameFinished)
				{
					write_frame(ocodec,AUDIO_ID,pkt_t);
					av_free_packet(&pkt_t);
				}
			}
			if (readbuff)
			{
				delete []readbuff;
				readbuff = NULL;
			}
			if (pFrameResample)
			{
				av_free(pFrameResample);
				pFrameResample = NULL;
			}
		}
		else
		{
			nRet = avcodec_encode_audio2(cctext,&pkt_t,picture,&frameFinished);
			if (nRet>=0 && frameFinished)
			{
				write_frame(ocodec,AUDIO_ID,pkt_t);
				av_free_packet(&pkt_t);
			}
		}
	}
	else if (stream_type == VIDEO_ID)
	{
		cctext = ovideo_st->codec;
		//ticks_per_frame这个值用的不对
		//if(icodec->streams[video_stream_idx]->codec->ticks_per_frame != 1)
		//{
		//	AVRational time_base_video_t;
		//	time_base_video_t.num = icodec->streams[video_stream_idx]->codec->time_base.num;
		//	time_base_video_t.den = icodec->streams[video_stream_idx]->codec->time_base.den /icodec->streams[video_stream_idx]->codec->ticks_per_frame;
		//	picture->pts = av_rescale_q_rnd(picture->pts, time_base_video_t, ovideo_st->codec->time_base, AV_ROUND_NEAR_INF);
		//}
		//else
		//{
		//	picture->pts = av_rescale_q_rnd(picture->pts, icodec->streams[video_stream_idx]->codec->time_base, ovideo_st->codec->time_base, AV_ROUND_NEAR_INF);
		//}
		picture->pts = av_rescale_q_rnd(picture->pts, icodec->streams[video_stream_idx]->codec->time_base, ovideo_st->codec->time_base, AV_ROUND_NEAR_INF);

		avcodec_encode_video2(cctext,&pkt_t,picture,&frameFinished);
		picture->pts++;
		if (frameFinished)
		{
			write_frame(ocodec,VIDEO_ID,pkt_t);
			av_free_packet(&pkt_t);
		}
	}
	return 1;
}

int perform_code2(int stream_type,AVFrame * picture)
{
	AVCodecContext *cctext = NULL;
	AVPacket pkt_t;
	av_init_packet(&pkt_t);
	pkt_t.data = NULL; // packet data will be allocated by the encoder
	pkt_t.size = 0;
	int frameFinished = 0 ;

	if (stream_type == AUDIO_ID)
	{
		cctext = oaudio_st->codec;
		//如果进和出的的声道，样本，采样率不同,需要重采样
		if(icodec->streams[audio_stream_idx]->codec->sample_fmt != (AVSampleFormat)m_dwBitsPerSample ||
			icodec->streams[audio_stream_idx]->codec->channels != m_dwChannelCount ||
			icodec->streams[audio_stream_idx]->codec->sample_rate != m_dwFrequency)
		{
			int64_t pts_t = picture->pts;
			int duration_t = 0;
			if(m_audiomuxtimebasetrue == 0)
			{
				duration_t = (double)cctext->frame_size * (icodec->streams[audio_stream_idx]->codec->time_base.den /icodec->streams[audio_stream_idx]->codec->time_base.num)/ 
					icodec->streams[audio_stream_idx]->codec->sample_rate;
			}
			else
			{
				duration_t = (double)cctext->frame_size * (icodec->streams[audio_stream_idx]->time_base.den /icodec->streams[audio_stream_idx]->time_base.num)/ 
					icodec->streams[audio_stream_idx]->codec->sample_rate;
			}

			AVFrame * pFrameResample = avcodec_alloc_frame();
			pFrameResample = av_frame_alloc();

			pFrameResample->nb_samples     = cctext->frame_size;
			pFrameResample->channel_layout = cctext->channel_layout;
			pFrameResample->channels = cctext->channels;
			pFrameResample->format         = cctext->sample_fmt;
			pFrameResample->sample_rate    = cctext->sample_rate;
			int error = 0;
			if ((error = av_frame_get_buffer(pFrameResample, 0)) < 0)
			{
				av_frame_free(&pFrameResample);
				return error;
			}

			while (av_audio_fifo_size(m_audiofifo) >= pFrameResample->nb_samples) //取出写入的未读的包
			{
				av_audio_fifo_read(m_audiofifo,(void **)pFrameResample->data,pFrameResample->nb_samples);

				if(m_is_first_audio_pts == 0)
				{
					m_first_audio_pts = pts_t;
					m_is_first_audio_pts = 1;
				}
				pFrameResample->pts = m_first_audio_pts;
				m_first_audio_pts += duration_t;


				pFrameResample->pts = av_rescale_q_rnd(pFrameResample->pts, icodec->streams[audio_stream_idx]->codec->time_base, oaudio_st->codec->time_base, AV_ROUND_NEAR_INF);
				nRet = avcodec_encode_audio2(cctext,&pkt_t,pFrameResample,&frameFinished);
				if (nRet>=0 && frameFinished)
				{
					write_frame(ocodec,AUDIO_ID,pkt_t);
					av_free_packet(&pkt_t);
				}
			}
			if (pFrameResample)
			{
				av_frame_free(&pFrameResample);
				pFrameResample = NULL;
			}
		}
		else
		{
			nRet = avcodec_encode_audio2(cctext,&pkt_t,picture,&frameFinished);
			if (nRet>=0 && frameFinished)
			{
				write_frame(ocodec,AUDIO_ID,pkt_t);
				av_free_packet(&pkt_t);
			}
		}
	}
	else if (stream_type == VIDEO_ID)
	{
		cctext = ovideo_st->codec;
		if(icodec->streams[video_stream_idx]->codec->ticks_per_frame != 1)
		{
			AVRational time_base_video_t;
			time_base_video_t.num = icodec->streams[video_stream_idx]->codec->time_base.num;
			time_base_video_t.den = icodec->streams[video_stream_idx]->codec->time_base.den /icodec->streams[video_stream_idx]->codec->ticks_per_frame;
			picture->pts = av_rescale_q_rnd(picture->pts, time_base_video_t, ovideo_st->codec->time_base, AV_ROUND_NEAR_INF);
		}
		else
		{
			picture->pts = av_rescale_q_rnd(picture->pts, icodec->streams[video_stream_idx]->codec->time_base, ovideo_st->codec->time_base, AV_ROUND_NEAR_INF);
		}
		avcodec_encode_video2(cctext,&pkt_t,picture,&frameFinished);
		picture->pts++;
		if (frameFinished)
		{
			write_frame(ocodec,VIDEO_ID,pkt_t);
			av_free_packet(&pkt_t);
		}
	}
	return 1;
}

void perform_yuv_conversion(AVFrame * pinframe,AVFrame * poutframe)
{
	//设置转换context
	if (img_convert_ctx_video == NULL)   
	{
		img_convert_ctx_video = sws_getContext(icodec->streams[video_stream_idx]->codec->width, icodec->streams[video_stream_idx]->codec->height, 
			icodec->streams[video_stream_idx]->codec->pix_fmt,
			m_dwWidth, m_dwHeight,
			video_pixelfromat,
			sws_flags, NULL, NULL, NULL);
		if (img_convert_ctx_video == NULL)
		{
			printf("Cannot initialize the conversion context\n");
		}
	}
	//开始转换
	sws_scale(img_convert_ctx_video, pinframe->data, pinframe->linesize,         
		0, icodec->streams[video_stream_idx]->codec->height, poutframe->data, poutframe->linesize);
	poutframe->pkt_pts = pinframe->pkt_pts;
	poutframe->pkt_dts = pinframe->pkt_dts;
	//有时pkt_pts和pkt_dts不同，并且pkt_pts是编码前的dts,这里要给avframe传入pkt_dts而不能用pkt_pts
	//poutframe->pts = poutframe->pkt_pts;
	poutframe->pts = pinframe->pkt_dts;
}

SwrContext * init_pcm_resample(AVFrame *in_frame, AVFrame *out_frame)
{
	SwrContext * swr_ctx = NULL;
	swr_ctx = swr_alloc();
	if (!swr_ctx)
	{
		printf("swr_alloc error \n");
		return NULL;
	}
	AVCodecContext * audio_dec_ctx = icodec->streams[audio_stream_idx]->codec;
	AVSampleFormat sample_fmt;
	sample_fmt = (AVSampleFormat)m_dwBitsPerSample; //样本
	if (audio_dec_ctx->channel_layout == 0)
	{
		audio_dec_ctx->channel_layout = av_get_default_channel_layout(icodec->streams[audio_stream_idx]->codec->channels);
	}
	/* set options */
	av_opt_set_int(swr_ctx, "in_channel_layout",    audio_dec_ctx->channel_layout, 0);
	av_opt_set_int(swr_ctx, "in_sample_rate",       audio_dec_ctx->sample_rate, 0);
	av_opt_set_sample_fmt(swr_ctx, "in_sample_fmt", audio_dec_ctx->sample_fmt, 0);
	if(icodec->streams[audio_stream_idx]->codec->channels > 2)
	{
		av_opt_set_int(swr_ctx, "out_channel_layout",    av_get_default_channel_layout(m_dwChannelCount), 0);	
	}
	else
	{
		av_opt_set_int(swr_ctx, "out_channel_layout", audio_dec_ctx->channel_layout, 0);
	}
	av_opt_set_int(swr_ctx, "out_sample_rate",       audio_dec_ctx->sample_rate, 0);
	av_opt_set_sample_fmt(swr_ctx, "out_sample_fmt", sample_fmt, 0);
	swr_init(swr_ctx);

	int64_t src_nb_samples = in_frame->nb_samples;
	out_frame->nb_samples = av_rescale_rnd(swr_get_delay(swr_ctx,oaudio_st->codec->sample_rate) + src_nb_samples,
		oaudio_st->codec->sample_rate, oaudio_st->codec->sample_rate, AV_ROUND_UP);

	int ret = av_samples_alloc(out_frame->data, &out_frame->linesize[0], 
		icodec->streams[audio_stream_idx]->codec->channels, out_frame->nb_samples,oaudio_st->codec->sample_fmt,1);
	if (ret < 0)
	{
		return NULL;
	}

#ifdef AUDIO_FIFO
	m_audiofifo  = av_audio_fifo_alloc(oaudio_st->codec->sample_fmt, oaudio_st->codec->channels,
		out_frame->nb_samples);
#else
	//pcm分包初始化
	int buffersize = av_samples_get_buffer_size(NULL, oaudio_st->codec->channels,
		2048, oaudio_st->codec->sample_fmt, 1);
	m_fifo = av_fifo_alloc(buffersize);
#endif
	return swr_ctx;
}

int preform_pcm_resample(SwrContext * pSwrCtx,AVFrame *in_frame, AVFrame *out_frame)
{
	int ret = 0;
	if (pSwrCtx != NULL) 
	{
		ret = swr_convert(pSwrCtx, out_frame->data, out_frame->nb_samples, 
			(const uint8_t**)in_frame->data, in_frame->nb_samples);
		if (ret < 0)
		{
			return -1;
		}
		//修改分包内存
		int buffersize = av_samples_get_buffer_size(&out_frame->linesize[0], oaudio_st->codec->channels,
			ret, oaudio_st->codec->sample_fmt, 1);
#ifdef AUDIO_FIFO
		int sss = av_audio_fifo_size(m_audiofifo);
		sss = av_audio_fifo_realloc(m_audiofifo, av_audio_fifo_size(m_audiofifo) + out_frame->nb_samples);
		av_audio_fifo_write(m_audiofifo,(void **)out_frame->data,out_frame->nb_samples);
		sss = av_audio_fifo_size(m_audiofifo);
#else
		int sss = av_fifo_size(m_fifo);
		sss = av_fifo_realloc2(m_fifo, av_fifo_size(m_fifo) + out_frame->linesize[0]);
		sss = av_fifo_size(m_fifo);
		av_fifo_generic_write(m_fifo, out_frame->data[0], out_frame->linesize[0], NULL);
#endif
		out_frame->pkt_pts = in_frame->pkt_pts;
		out_frame->pkt_dts = in_frame->pkt_dts;
		//有时pkt_pts和pkt_dts不同，并且pkt_pts是编码前的dts,这里要给avframe传入pkt_dts而不能用pkt_pts
		//out_frame->pts = out_frame->pkt_pts;
		out_frame->pts = in_frame->pkt_dts;
	}
	return 0;
}

void uinit_pcm_resample(AVFrame * poutframe,SwrContext * swr_ctx)
{
	if (poutframe)
	{
		avcodec_free_frame(&poutframe);
		poutframe = NULL;
	}
	if (swr_ctx)
	{
		swr_free(&swr_ctx);
		swr_ctx = NULL;
	}
#ifdef AUDIO_FIFO
	if(m_audiofifo)
	{
		av_audio_fifo_free(m_audiofifo);
		m_audiofifo = NULL;
	}
#else
	//析构pcm分包结构
	if(m_fifo)
	{
		av_fifo_free(m_fifo);
		m_fifo = NULL;
	}
#endif
}


int audio_support(AVCodec * pCodec,int *channel,int * playout,int *samplePerSec,AVSampleFormat_t * sample_fmt)
{
	//支持的声道
	if(NULL != pCodec->channel_layouts)
	{
		uint64_t layout = av_get_default_channel_layout(*channel);
		if(0 == layout)
		{
			return 0;
		}

		int i = 0;	
		int j = 0;
		while(0 != pCodec->channel_layouts[j])
		{
			printf("pCodec->channel_layouts[j] : %d\n",pCodec->channel_layouts[j]);
			++j;
		}
		while(0 != pCodec->channel_layouts[i])
		{
			if(layout == pCodec->channel_layouts[i])
			{
				break;
			}
			++i;
		}
		//未找到
		if(0 == pCodec->channel_layouts[i])
		{
			*playout = pCodec->channel_layouts[i-1];
			*channel = av_get_channel_layout_nb_channels(*playout);
		}
	}

	//支持的采样率
	if(NULL != pCodec->supported_samplerates)
	{
		int i = 0;
		int j = 0;
		while(0 != pCodec->supported_samplerates[j])
		{
			printf("pCodec->supported_samplerates[j] : %d\n",pCodec->supported_samplerates[j]);
			++j;
		}
		while(0 != pCodec->supported_samplerates[i])
		{
			if(*samplePerSec == pCodec->supported_samplerates[i])
			{
				break;
			}
			++i;
		}
		//未找到
		if(0 == pCodec->supported_samplerates[i])
		{
			*samplePerSec = pCodec->supported_samplerates[i-1];
		}
	}

	//支持的样本
	if(NULL != pCodec->sample_fmts)
	{
		int i = 0;
		int j = 0;
		while(-1 != pCodec->sample_fmts[j])
		{
			printf("pCodec->sample_fmts[j] : %d\n",pCodec->sample_fmts[j]);
			++j;
		}
		while(-1 != pCodec->sample_fmts[i])
		{
			if(*sample_fmt == pCodec->sample_fmts[i])
			{
				break;
			}
			++i;
		}
		//未找到
		if(-1 == pCodec->sample_fmts[i])
		{
			*sample_fmt = (AVSampleFormat_t)pCodec->sample_fmts[i-1];
		}
	}

	return 1;
}

int video_support(AVCodec * pCodec,AVPixelFormat * video_pixelfromat)
{
	//支持的yuv格式
	if(NULL != pCodec->pix_fmts)
	{
		int i = 0;
		int j = 0;
		while(0 != pCodec->pix_fmts[j])
		{
			printf("pCodec->pix_fmts[j] : %d\n",pCodec->pix_fmts[j]);
			++j;
		}
		while(0 != pCodec->pix_fmts[i])
		{
			if(*video_pixelfromat == pCodec->pix_fmts[i])
			{
				break;
			}
			++i;
		}
		//未找到
		if(-1 == pCodec->pix_fmts[i])
		{
			*video_pixelfromat = pCodec->pix_fmts[i-1];
		}
	}
	return 1;
}

void write_frame(AVFormatContext *ocodec,int ID,AVPacket pkt_t)
{
	int64_t pts = 0, dts = 0;
	int nRet = -1;

	if(ID == VIDEO_ID)
	{
		AVPacket videopacket_t;
		av_init_packet(&videopacket_t);

		videopacket_t.pts = av_rescale_q_rnd(pkt_t.pts, icodec->streams[video_stream_idx]->time_base, ovideo_st->time_base, AV_ROUND_NEAR_INF);
		videopacket_t.dts = av_rescale_q_rnd(pkt_t.dts, icodec->streams[video_stream_idx]->time_base, ovideo_st->time_base, AV_ROUND_NEAR_INF);
		videopacket_t.duration = av_rescale_q(pkt_t.duration,icodec->streams[video_stream_idx]->time_base, ovideo_st->time_base);
		videopacket_t.flags = pkt_t.flags;
		videopacket_t.stream_index = VIDEO_ID; //这里add_out_stream顺序有影响
		videopacket_t.data = pkt_t.data;
		videopacket_t.size = pkt_t.size;
		nRet = av_interleaved_write_frame(ocodec, &videopacket_t);
		if (nRet != 0)
		{
			printf("error av_interleaved_write_frame _ video\n");
		}
		printf("video\n");
	}
	else if(ID == AUDIO_ID)
	{
		AVPacket audiopacket_t;
		av_init_packet(&audiopacket_t);

		if(m_audiomuxtimebasetrue == 0)
		{
			audiopacket_t.pts = av_rescale_q_rnd(pkt_t.pts, icodec->streams[audio_stream_idx]->codec->time_base, oaudio_st->time_base, AV_ROUND_NEAR_INF);
			audiopacket_t.dts = av_rescale_q_rnd(pkt_t.dts, icodec->streams[audio_stream_idx]->codec->time_base, oaudio_st->time_base, AV_ROUND_NEAR_INF);
			audiopacket_t.duration = av_rescale_q(pkt_t.duration,icodec->streams[audio_stream_idx]->codec->time_base, oaudio_st->time_base);
		}
		else
		{
			audiopacket_t.pts = av_rescale_q_rnd(pkt_t.pts, icodec->streams[audio_stream_idx]->time_base, oaudio_st->time_base, AV_ROUND_NEAR_INF);
			audiopacket_t.dts = av_rescale_q_rnd(pkt_t.dts, icodec->streams[audio_stream_idx]->time_base, oaudio_st->time_base, AV_ROUND_NEAR_INF);
			audiopacket_t.duration = av_rescale_q(pkt_t.duration,icodec->streams[audio_stream_idx]->time_base, oaudio_st->time_base);
		}
		audiopacket_t.flags = pkt_t.flags;
		audiopacket_t.stream_index = AUDIO_ID; //这里add_out_stream顺序有影响
		audiopacket_t.data = pkt_t.data;
		audiopacket_t.size = pkt_t.size;

		//添加过滤器
		if(! strcmp( ocodec->oformat-> name,  "mp4" ) ||
			!strcmp (ocodec ->oformat ->name , "mov" ) ||
			!strcmp (ocodec ->oformat ->name , "3gp" ) ||
			!strcmp (ocodec ->oformat ->name , "flv" ))
		{
			if (oaudio_st->codec->codec_id == AV_CODEC_ID_AAC)
			{
				if (vbsf_aac_adtstoasc != NULL)
				{
					AVPacket filteredPacket = audiopacket_t; 
					int a = av_bitstream_filter_filter(vbsf_aac_adtstoasc,                                           
						oaudio_st->codec, NULL,&filteredPacket.data, &filteredPacket.size,
						audiopacket_t.data, audiopacket_t.size, audiopacket_t.flags & AV_PKT_FLAG_KEY); 
					if (a >  0)             
					{                
						av_free_packet(&audiopacket_t); 
						filteredPacket.destruct = av_destruct_packet;  
						audiopacket_t = filteredPacket;             
					}   
					else if (a == 0)
					{
						audiopacket_t = filteredPacket;   
					}
					else if (a < 0)            
					{                
						fprintf(stderr, "%s failed for stream %d, codec %s",
							vbsf_aac_adtstoasc->filter->name,audiopacket_t.stream_index,oaudio_st->codec->codec ?  oaudio_st->codec->codec->name : "copy");
						av_free_packet(&audiopacket_t);   

					}
				}
			}
		}
		nRet = av_interleaved_write_frame(ocodec, &audiopacket_t);
		if (nRet != 0)
		{
			printf("error av_interleaved_write_frame _ audio\n");
		}
		printf("audio\n");
	}
}

int transcode()
{
	AVFrame *pinframe = NULL;
	AVFrame * pout_video_frame = NULL;
	AVFrame * pout_audio_frame = NULL;
	SwrContext * swr_ctx = NULL;
	int dst_nb_samples = -1;
	int resampled_data_size = 0;
	//分配一个AVFrame并设置默认值
	pinframe = avcodec_alloc_frame(); 
	pout_video_frame = avcodec_alloc_frame();
	pout_audio_frame = avcodec_alloc_frame();
	pinframe->pts = 0;
	pout_video_frame->pts = 0;
	pout_audio_frame->pts = 0;
	if (pinframe == NULL)
	{
		printf("avcodec_alloc_frame pinframe error\n");
		return 0;
	}
	//video
	if (pout_video_frame == NULL)
	{
		printf("avcodec_alloc_frame pout_video_frame error\n");
		return 0;
	}
	int Out_size = avpicture_get_size(video_pixelfromat, m_dwWidth,m_dwHeight);
	uint8_t * pOutput_buf =( uint8_t *)malloc(Out_size * 3 * sizeof(char)); //最大分配的空间，能满足yuv的各种格式
	avpicture_fill((AVPicture *)pout_video_frame, (unsigned char *)pOutput_buf, video_pixelfromat,m_dwWidth, m_dwHeight); //内存关联

	//audio
	if (pout_audio_frame == NULL)
	{
		printf("avcodec_alloc_frame pout_audio_frame error\n");
		return 0;
	}
	avcodec_get_frame_defaults(pout_audio_frame);

	//开始解包
	while (1)
	{
		av_init_packet(&pkt);
		if (av_read_frame(icodec, &pkt) < 0)
		{
			break;
		}
		//视频
		if(pkt.stream_index == video_stream_idx) 
		{
			//如果是视频需要编解码
			if(bit_rate != icodec->streams[video_stream_idx]->codec->bit_rate ||
				m_dwWidth != icodec->streams[video_stream_idx]->codec->width ||
				m_dwHeight != icodec->streams[video_stream_idx]->codec->height ||
				video_codecID != icodec->streams[video_stream_idx]->codec->codec_id || 
				m_dbFrameRate != av_q2d(icodec->streams[video_stream_idx]->r_frame_rate))
			{
				nRet = perform_decode(VIDEO_ID,pinframe);
				if (nRet == 0)
				{
					perform_yuv_conversion(pinframe,pout_video_frame);
#ifdef AUDIO_FIFO
					nRet = perform_code2(VIDEO_ID,pout_video_frame);
#else
					nRet = perform_code(VIDEO_ID,pout_video_frame);
#endif
				}
			}
			else
			{
				write_frame(ocodec,VIDEO_ID,pkt);
			}
		}
		//音频
		else if (pkt.stream_index == audio_stream_idx)
		{
			//如果是音频需要编解码
			if(audio_codecID != icodec->streams[audio_stream_idx]->codec->codec_id ||
				1 != icodec->streams[audio_stream_idx]->codec->sample_fmt)
			{
				nRet = perform_decode(AUDIO_ID,pinframe);
				if (nRet == 0)
				{
					//如果进和出的的声道，样本，采样率不同,需要重采样
					if(icodec->streams[audio_stream_idx]->codec->sample_fmt != (AVSampleFormat)m_dwBitsPerSample ||
						icodec->streams[audio_stream_idx]->codec->channels != m_dwChannelCount ||
						icodec->streams[audio_stream_idx]->codec->sample_rate != m_dwFrequency)
					{
						if (swr_ctx == NULL)
						{
							swr_ctx = init_pcm_resample(pinframe,pout_audio_frame);
						}
						preform_pcm_resample(swr_ctx,pinframe,pout_audio_frame);
#ifdef AUDIO_FIFO
						perform_code2(AUDIO_ID,pout_audio_frame);
#else
						perform_code(AUDIO_ID,pout_audio_frame);
#endif
					}
					else
					{
						pinframe->pts = pinframe->pkt_pts;
#ifdef AUDIO_FIFO
						perform_code2(AUDIO_ID,pinframe);
#else
						perform_code(AUDIO_ID,pinframe);
#endif
					}
				}
			}
			else
			{
				write_frame(ocodec,AUDIO_ID,pkt);
			}
		}
	}
	if (pinframe)
	{
		avcodec_free_frame(&pinframe);
		pinframe = NULL;
	}
	if (pout_video_frame)
	{
		avcodec_free_frame(&pout_video_frame);
		pout_video_frame = NULL;
	}
	uinit_pcm_resample(pout_audio_frame,swr_ctx);
	return 1;
}

实现效果：