SDL播放视频

// PlayVideo.cpp : Defines the entry point for the console application.

//







extern "C"

{

#include <libavcodec/avcodec.h>

#include <libavformat/avformat.h>

#include <libswscale/swscale.h>

#include <libswresample/swresample.h>

#include <libavutil/avstring.h>

#include <libavutil/pixfmt.h>

#include <libavutil/log.h>

};

#include <windows.h>

#include <stdio.h>

#include <math.h>

#include <SDL.h>

#include <SDL_thread.h>

#include <SDL_main.h>





#pragma comment(lib, "libmingwex.lib")

#pragma comment(lib, "libgcc.lib")

#pragma comment(lib, "avformat.lib")

#pragma comment(lib, "avutil.lib")

#pragma comment(lib, "avcodec.lib")

#pragma comment(lib, "swresample.lib")

#pragma comment(lib, "swscale.lib")



#pragma comment(lib, "SDL.lib")

#pragma comment(lib, "SDLmain.lib")



//speedloss is decided by scale

//#define PICTURE_W 640  

//#define PICTURE_H 352  

//#define PICTURE_PW 640  

//#define PICTURE_PH 352  

//change 100 

#define MAX_QUEUE_SIZE     50



#define VIDEO_PICTURE_QUEUE_SIZE 2  









typedef struct VideoPicture_t{  

	SDL_Overlay *bmp;  

	double pts;  

	double duration;  

	int width,height;  

}VideoPicture;  





struct play_info_t{  

	//先注释掉同步

	double audio_clock;//解码时钟  

	double audio_current_pts;//当前音频的pts  

	double vedio_clock;//解码时钟  

	double last_frame_pts;//上一帧的PTS值  

	double last_frame_delay;//上一帧的延时  

	double frame_timer;  



	AVCodecContext *pVideoCodecCtx;  

	AVCodecContext *pAudioCodecCtx;  



	VideoPicture pictq[VIDEO_PICTURE_QUEUE_SIZE];  

	int pictq_size, pictq_rindex, pictq_windex;  

	SDL_mutex *pictq_mutex;  

	SDL_cond *pictq_cond;  



	struct SwrContext *audio_conv;  

	struct SwsContext *video_conv;  

};  



struct play_info_t g_play_info;  









typedef struct PacketQueue {  

	AVPacketList *first_pkt, *last_pkt;  

	int nb_packets;  

	int size;  

	SDL_mutex *mutex;  

	SDL_cond *cond;  

} PacketQueue;  



PacketQueue audio_queue;  

PacketQueue video_queue;  

int quit = 0;  

SDL_Surface *screen;  

SDL_Overlay *bmp;  

SDL_Rect rect;  



int global_video_pkt_pts=0;  

int our_get_buffer(struct AVCodecContext *c, AVFrame *pic) {  

	int ret = avcodec_default_get_buffer(c, pic);  

	uint64_t *pts = (uint64_t *)av_malloc(sizeof(uint64_t));  

	*pts = global_video_pkt_pts;  

	pic->opaque = pts;  

	return ret;  

}  

void our_release_buffer(struct AVCodecContext *c, AVFrame *pic) {  

	if(pic) av_freep(&pic->opaque);  

	avcodec_default_release_buffer(c, pic);  

}  



double get_audio_clock(void)  

{  

	return g_play_info.audio_current_pts;  

} 



double get_video_clock(void)  

{  

	return g_play_info.vedio_clock;  

} 



void picture_queque_init(struct play_info_t *play)  

{  

	int i;  

	play->pictq_cond=SDL_CreateCond();  

	play->pictq_mutex=SDL_CreateMutex();  

	play->pictq_rindex=play->pictq_windex=0;  

	play->pictq_size=0;  

	memset(play->pictq,0,sizeof(play->pictq));  

	for(i=0;i<VIDEO_PICTURE_QUEUE_SIZE;i++){  //注释掉   g_play_info.pVideoCodecCtx->height

		//play->pictq[i].bmp=SDL_CreateYUVOverlay(PICTURE_W,PICTURE_H,SDL_YUY2_OVERLAY,screen);  

		play->pictq[i].bmp=SDL_CreateYUVOverlay(g_play_info.pVideoCodecCtx->width,g_play_info.pVideoCodecCtx->height,SDL_YUY2_OVERLAY,screen);  

	}  

}  



void picture_queque_destroy(struct play_info_t *play)  

{  

	int i;  

	for(i=0;i<VIDEO_PICTURE_QUEUE_SIZE;i++){  

		SDL_FreeYUVOverlay(play->pictq[i].bmp);  

	}  

}  







void packet_queue_init(PacketQueue *q) {  

	memset(q, 0, sizeof(PacketQueue));  

	q->mutex = SDL_CreateMutex();  

	q->cond = SDL_CreateCond();  

}  



int packet_queue_put(PacketQueue *q, AVPacket *pkt) {  

	AVPacketList *pkt1;  

	if(av_dup_packet(pkt) < 0) {  

		return -1;  

	}  

	pkt1 = (AVPacketList *)av_malloc(sizeof(AVPacketList));  

	if (!pkt1)  

		return -1;  

	pkt1->pkt = *pkt;  

	pkt1->next = NULL;  

	SDL_LockMutex(q->mutex);  

	if (!q->last_pkt)  

		q->first_pkt = pkt1;  

	else  

		q->last_pkt->next = pkt1;  

	q->last_pkt = pkt1;  

	q->nb_packets++;  

	q->size += pkt1->pkt.size;  

	SDL_CondSignal(q->cond);  

	SDL_UnlockMutex(q->mutex);  

	return 0;  

}  





static int packet_queue_get(PacketQueue *q, AVPacket *pkt, int block) {  

	AVPacketList *pkt1;  

	int ret;  

	SDL_LockMutex(q->mutex);  

	for(;;) {  

		if(quit) {  

			ret = -1;  

			break;  

		}  

		pkt1 = q->first_pkt;  

		if (pkt1) {  

			q->first_pkt = pkt1->next;  

			if (!q->first_pkt)  

				q->last_pkt = NULL;  

			q->nb_packets--;  

			q->size -= pkt1->pkt.size;  

			*pkt = pkt1->pkt;  

			av_free(pkt1);  

			ret = 1;  

			break;  

		} else if (!block) {  

			ret = 0;  

			break;  

		} else {  

			SDL_CondWait(q->cond, q->mutex);  

		}  

	}  

	SDL_UnlockMutex(q->mutex);  

	return ret;  

}  



int decode_interrupt_cb(void) {  

	return quit;  

}  



//计算正确的pts值  

double sync_video(struct play_info_t *play,AVFrame* frame,double pts)  

{  

	double frame_delay;  

	if(pts!=0)  

		play->vedio_clock=pts;  

	else  

		pts=play->vedio_clock;  

	frame_delay=av_q2d(play->pVideoCodecCtx->time_base);//一帧占用的时间  

	frame_delay+=frame->repeat_pict*(frame_delay*0.5);//计算重复帧  

	play->vedio_clock+=frame_delay;  

	return pts;  

}  



int audio_decode_frame(struct play_info_t* play, uint8_t *audio_buf,int buf_size) {  

	AVCodecContext *aCodecCtx=play->pAudioCodecCtx;  

	AVFrame *pAudioFrame=avcodec_alloc_frame();  

	AVPacket pkt,pkt1;  

	int frame_finished=0;  

	int pkt_pos,pkt_len;  

	int src_len=0,dst_len=0,data_size=0;  

	float pts=0;  

	avcodec_get_frame_defaults(pAudioFrame);  



	uint8_t *out[]={audio_buf};  



	for(;!quit;){  

		if(packet_queue_get(&audio_queue, &pkt, 1) < 0) {  

			av_free(pAudioFrame);  

			return -1;  

		}  

		pkt1=pkt;  

		pkt_pos=0;  

		pkt_len=pkt.size;  



		while(pkt_pos<pkt.size && !quit){  

			if((src_len=avcodec_decode_audio4(aCodecCtx,pAudioFrame,&frame_finished,&pkt1))<0){  

				av_free_packet(&pkt);  

				av_free(pAudioFrame);  

				return -1;  

			}  



		/*	play->audio_clock+=(double)(pAudioFrame->linesize[0])/  

				(aCodecCtx->channels*aCodecCtx->sample_rate*av_get_bytes_per_sample(aCodecCtx->sample_fmt));  */

			if(video_queue.nb_packets>= 100 || audio_queue.nb_packets>= 200){  //改写

				//printf("%d---%d\n",video_queue.nb_packets,audio_queue.nb_packets);  

				Sleep(20); //  change   10000



			} 

			else if(video_queue.nb_packets>= 50 || audio_queue.nb_packets>= 100)

			{

				Sleep(10);



			}



			if(frame_finished){ 

				const uint8_t **in=(const uint8_t **)pAudioFrame->data;

				int len=swr_convert(play->audio_conv,out,buf_size/aCodecCtx->channels/av_get_bytes_per_sample(AV_SAMPLE_FMT_S16),  

					in,pAudioFrame->linesize[0]/aCodecCtx->channels/av_get_bytes_per_sample((AVSampleFormat)pAudioFrame->format));  

				len=len*aCodecCtx->channels*av_get_bytes_per_sample(AV_SAMPLE_FMT_S16);  

				av_free(pAudioFrame);  

				av_free_packet(&pkt);  

				return len;  

			}else{  

				if (!pkt1.data && aCodecCtx->codec->capabilities & CODEC_CAP_DELAY){  

					break;  

				}  

			}  

			pkt_pos+=src_len;//已经解码的长度  

			pkt1.data=pkt.data+pkt_pos;  

			pkt1.size=pkt.size-pkt_pos;  



		





		}  

		av_free_packet(&pkt);  

	}  

	av_free(pAudioFrame);  

	return dst_len;  

}  



//decode the audio data ,and copy the result to stream  

void SDLCALL audio_callback(void *userdata, Uint8 *stream, int len)  

{  

	struct play_info_t *play=(struct play_info_t*)userdata;  

	AVCodecContext *aCodecCtx = play->pAudioCodecCtx;  

	int len1, audio_size;  

	static uint8_t audio_buf[(AVCODEC_MAX_AUDIO_FRAME_SIZE * 3) / 2];  

	static unsigned int audio_buf_size = 0;  

	static unsigned int audio_buf_index = 0;  

	int bytes_per_sec=2*aCodecCtx->channels*aCodecCtx->sample_rate;  



	while(len > 0 && !quit) {  

		if(audio_buf_index >= audio_buf_size) {  

			audio_size = audio_decode_frame(play, audio_buf,sizeof(audio_buf));  

			if(audio_size < 0) {  

				audio_buf_size = 1024;  

				memset(audio_buf, 0, audio_buf_size);  

			} else {  

				audio_buf_size = audio_size;  

			}  

			audio_buf_index = 0;  

		}  

		len1 = audio_buf_size - audio_buf_index;  



		if(len1 > len)  

			len1 = len;  

		memcpy(stream, (uint8_t *)audio_buf + audio_buf_index, len1);  

		len -= len1;  

		stream += len1;  

		audio_buf_index += len1;  

	}  

	//先注释掉同步,自然播放

	if(audio_buf_size > audio_buf_index){  

		play->audio_current_pts=play->audio_clock-((double)(audio_buf_size-audio_buf_index)/(double)bytes_per_sec);  

		if(play->audio_current_pts<0)  

			play->audio_current_pts=play->audio_clock;  

		printf("audio-pts:%f\n",play->audio_current_pts);  

	}  

}  



int SDLCALL video_decode_callback(void* arg)  

{  

	printf("---in video decode thread ---\n");  

	struct play_info_t* play=(struct play_info_t*)arg;  

	AVCodecContext *pVideoCodecCtx=play->pVideoCodecCtx;  

	double pts;  

	VideoPicture *vp;  

	AVPacket pkt;  

	int frame_finished;  

	AVPicture pict = { { 0 } };  

	AVFrame *pVideoFrame=avcodec_alloc_frame();  

	if(pVideoFrame==NULL){  

		printf("can't alloc video frame!\n");  

		return -1;  

	}  



	while(!quit){  

		if(packet_queue_get(&video_queue, &pkt, 1) < 0) {  

			return -1;  

		}  

		pts = 0;  

		// Save global pts to be stored in pFrame in first call  

		global_video_pkt_pts = pkt.pts;  

		avcodec_decode_video2(pVideoCodecCtx,pVideoFrame,&frame_finished,&pkt);  

		if(pkt.dts == AV_NOPTS_VALUE && pVideoFrame->opaque && *(uint64_t*)pVideoFrame->opaque != AV_NOPTS_VALUE){  

			pts = *(uint64_t *)pVideoFrame->opaque;  

		} else if(pkt.dts!=AV_NOPTS_VALUE){  

			pts=pkt.dts;  

		}else{  

			pts=0;  

		}  

		pts*=av_q2d(pVideoCodecCtx->time_base);  



		av_free_packet(&pkt);  

		if(video_queue.nb_packets>= 100 || audio_queue.nb_packets>= 200){  //改写

			printf("%d---%d\n",video_queue.nb_packets,audio_queue.nb_packets);  

			Sleep(20); //  change   10000

	

		} 

		else if(video_queue.nb_packets>= 50 || audio_queue.nb_packets>= 100)

		{

			Sleep(10);

	

		}

		if(frame_finished){  

			SDL_LockMutex(play->pictq_mutex);  

			while(play->pictq_size >= VIDEO_PICTURE_QUEUE_SIZE && !quit){  

				SDL_CondWait(play->pictq_cond,play->pictq_mutex);  

			}  

			SDL_UnlockMutex(play->pictq_mutex);  

			if(quit)  

				goto out;  



			vp=&play->pictq[play->pictq_windex];  

			SDL_Overlay *bmp=vp->bmp; //定义 

			//序列化帧  

			pts=sync_video(&g_play_info,pVideoFrame,pts);  

			vp->pts=pts;  

			printf("video-pts:%f\n",pts);  



			SDL_LockYUVOverlay(bmp);  //加锁

			pict.data[0]=bmp->pixels[0];  

			pict.data[1]=bmp->pixels[2];  

			pict.data[2]=bmp->pixels[1];  

			pict.linesize[0]=bmp->pitches[0];  

			pict.linesize[1]=bmp->pitches[2];  

			pict.linesize[2]=bmp->pitches[1];  

			sws_scale(play->video_conv,pVideoFrame->data,pVideoFrame->linesize,0,  

				pVideoFrame->height,pict.data,pict.linesize);  

			SDL_UnlockYUVOverlay(bmp);  





			play->pictq_windex=(play->pictq_windex+1)%VIDEO_PICTURE_QUEUE_SIZE;  

			SDL_LockMutex(play->pictq_mutex);  

			play->pictq_size++;  

			SDL_UnlockMutex(play->pictq_mutex);  



		}  

	}  

out:  

	av_free(pVideoFrame);  

	printf("---- exit video_decode_callback ----\n");  

	return 0;  

}  



void video_image_display(struct play_info_t *play)  

{  

	double delay,time;  

	VideoPicture *vp;  

	double diff,sync_threshold;  

	if(play->pictq_size>0){  

		vp=&play->pictq[play->pictq_rindex];  

		delay=vp->pts - play->last_frame_pts;  

		if(delay>0 && delay<10){  

			play->last_frame_delay=delay;  

		}  

		delay=play->last_frame_delay;  



		diff=vp->pts-get_audio_clock();  

		sync_threshold = FFMAX(0.01, delay);  

		if (fabs(diff) < 10) {  

			if (diff <= -sync_threshold)  

				delay = 0;  

			else if (diff >= sync_threshold)  

				delay = 2 * delay;  

		}  



		time=av_gettime()/1000000.0;  

		if(time < play->frame_timer+delay)  

			return ;  



		if(delay>0)  

			play->frame_timer+=delay;  

		play->last_frame_pts=vp->pts;  



		SDL_DisplayYUVOverlay(vp->bmp,&rect);  //显示



		play->pictq_rindex=(play->pictq_rindex+1)%VIDEO_PICTURE_QUEUE_SIZE;  



		SDL_LockMutex(play->pictq_mutex);  

		play->pictq_size--;  

		SDL_CondSignal(play->pictq_cond);  

		SDL_UnlockMutex(play->pictq_mutex);  



	}  

}  



int SDLCALL video_show_callback(void* arg)  

{   

	double delay=80;  
	struct play_info_t *play=(struct play_info_t*)arg;  

	while(!quit){  

		video_image_display(play);  

		Sleep(delay);  

	}  

	printf("----exit video_show_callback ----\n");  

	return 0;  

}  



void player_log_callback(void* ptr, int level, const char* fmt, va_list vl)  

{  

	static int print_prefix = 0;  

	static int count;  

	char line[1024];  

	av_log_format_line(ptr, level, fmt, vl, line, sizeof(line), &print_prefix);  

	printf("%s",line);  

}  









int main(int argc,char *argv[])  

{  

	if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER)<0){  

		printf("Init SDL err!\n");  

		return -1;  

	}  



	av_log_set_callback(player_log_callback);  

	av_register_all();  



	AVFormatContext *pFormatCtx;  

	pFormatCtx=avformat_alloc_context();  

	argv[1]="test.mp4";
	if(avformat_open_input(&pFormatCtx,argv[1],NULL,NULL)<0){  

		printf("avformat_open_input err!\n");  

		return -1;  

	}  



	if(avformat_find_stream_info(pFormatCtx,NULL)<0){  

		printf("avformat_find_stream_info err!\n");  

		return -1;  

	}  



	//av_dump_format(pFormatCtx,0,argv[1],0);  



	int video_stream=-1,audio_stream=-1,i;  

	for(i=0;i<pFormatCtx->nb_streams;i++){  

		if(pFormatCtx->streams[i]->codec->codec_type==AVMEDIA_TYPE_VIDEO){  

			video_stream=i;  

		}  

		if(pFormatCtx->streams[i]->codec->codec_type==AVMEDIA_TYPE_AUDIO){  

			audio_stream=i;  

		}  

	}  

	if(video_stream==-1 || audio_stream==-1){  

		printf("not find video or audio stream!\n");  

		avformat_close_input(&pFormatCtx);  

		return -1;  

	}  

	g_play_info.pVideoCodecCtx=pFormatCtx->streams[video_stream]->codec;  

	g_play_info.pAudioCodecCtx=pFormatCtx->streams[audio_stream]->codec;  



	//find the decoder  

	AVCodec *pVideoCodec=avcodec_find_decoder(g_play_info.pVideoCodecCtx->codec_id);  

	if(pVideoCodec==NULL){  

		printf("not find video decoder!\n");  

		avformat_close_input(&pFormatCtx);  

		return -1;  

	}  

	AVCodec *pAudioCodec=avcodec_find_decoder(g_play_info.pAudioCodecCtx->codec_id);  

	if(pVideoCodec==NULL){  

		printf("not find audio decoder!\n");  

		avformat_close_input(&pFormatCtx);  

		return -1;  

	}  

	//open the codec  

	if(avcodec_open(g_play_info.pVideoCodecCtx,pVideoCodec)<0){  

		printf("can't open the video decoder!\n");  

		avformat_close_input(&pFormatCtx);  

		return -1;  

	}  

	if(avcodec_open(g_play_info.pAudioCodecCtx,pAudioCodec)<0){  

		printf("can't open the audio decoder!\n");  

		avcodec_close(g_play_info.pVideoCodecCtx);  

		avformat_close_input(&pFormatCtx);  

		return -1;  

	}  



	//setup SDL  

	screen = SDL_SetVideoMode(g_play_info.pVideoCodecCtx->width, g_play_info.pVideoCodecCtx->height, 0, 0);//设置视频模式参数

	picture_queque_init(&g_play_info);  

	packet_queue_init(&video_queue);  

	packet_queue_init(&audio_queue);  



	rect.x=0;  

	rect.y=0;  

	rect.w = g_play_info.pVideoCodecCtx->width;  

	rect.h = g_play_info.pVideoCodecCtx->height;  





	//setup the sdl audio  

	SDL_AudioSpec sdl_audio;  

	int64_t wanted_channel_layout = 0;  

	int wanted_nb_channels;  

	wanted_channel_layout =   

		(g_play_info.pAudioCodecCtx->channel_layout &&   

		g_play_info.pAudioCodecCtx->channels == av_get_channel_layout_nb_channels(g_play_info.pAudioCodecCtx->channel_layout)) ? g_play_info.pAudioCodecCtx->channel_layout : av_get_default_channel_layout(g_play_info.pAudioCodecCtx->channels);  

	wanted_channel_layout &= ~AV_CH_LAYOUT_STEREO_DOWNMIX;  

	wanted_nb_channels = av_get_channel_layout_nb_channels(wanted_channel_layout);  

	/* SDL only supports 1, 2, 4 or 6 channels at the moment, so we have to make sure not to request anything else. */  

	while (wanted_nb_channels > 0 && (wanted_nb_channels == 3 || wanted_nb_channels == 5 || wanted_nb_channels > 6)) {  

		wanted_nb_channels--;  

		wanted_channel_layout = av_get_default_channel_layout(wanted_nb_channels);  

	}  

	sdl_audio.channels=av_get_channel_layout_nb_channels(wanted_channel_layout);  

	g_play_info.pAudioCodecCtx->channels=sdl_audio.channels;  

	g_play_info.pAudioCodecCtx->channel_layout=wanted_channel_layout;  



	g_play_info.audio_conv=swr_alloc_set_opts(NULL,wanted_channel_layout,AV_SAMPLE_FMT_S16,g_play_info.pAudioCodecCtx->sample_rate,  

		wanted_channel_layout,g_play_info.pAudioCodecCtx->sample_fmt,  

		g_play_info.pAudioCodecCtx->sample_rate,0,NULL);  

	swr_init(g_play_info.audio_conv);  



	sdl_audio.freq=g_play_info.pAudioCodecCtx->sample_rate;  

	sdl_audio.format=AUDIO_S16SYS;  

	sdl_audio.channels=g_play_info.pAudioCodecCtx->channels;  

	sdl_audio.silence=0;  

	sdl_audio.samples=1024;  

	sdl_audio.callback=audio_callback;//calls when the audio device need more data  

	sdl_audio.userdata=&g_play_info;  

	if(SDL_OpenAudio(&sdl_audio,NULL)<0){  

		printf("can't open audio device!\n");  

		goto err_alloc_frame1;  

	}  

	g_play_info.vedio_clock=0;  

	g_play_info.audio_clock=0;  

	g_play_info.audio_current_pts=0;  

	g_play_info.last_frame_pts=0;  

	g_play_info.last_frame_delay=0;  

	g_play_info.frame_timer=av_gettime()/1000000.0;  

	g_play_info.pVideoCodecCtx->get_buffer=our_get_buffer;  

	g_play_info.pVideoCodecCtx->release_buffer=our_release_buffer;  



	SDL_PauseAudio(0); 
	g_play_info.video_conv=sws_getContext(g_play_info.pVideoCodecCtx->width,g_play_info.pVideoCodecCtx->height,  

	g_play_info.pVideoCodecCtx->pix_fmt,  

	g_play_info.pVideoCodecCtx->width,g_play_info.pVideoCodecCtx->height,PIX_FMT_YUYV422,SWS_POINT,NULL,NULL,NULL);  

	SDL_Thread * video_decode_thread=SDL_CreateThread(video_decode_callback,(void*)&g_play_info);  
	SDL_Thread * video_show_thread=SDL_CreateThread(video_show_callback,(void*)&g_play_info);   

	SDL_Event sdl_event;  

	AVPacket packet;  







	while(!quit){  

		SDL_PollEvent(&sdl_event);  

		if(sdl_event.type==SDL_QUIT){  

			SDL_CondSignal(video_queue.cond);  

			SDL_CondSignal(audio_queue.cond);  

			quit=1;  

			break;  

		}  

			if(av_read_frame(pFormatCtx,&packet)<0){  

			quit=1;  

			continue;  

		}  

		if(packet.stream_ndex==video_stream){  

			packet_queue_put(&video_queue,&packet);  

			//change

                  Sleep(25);//change

		}else if(packet.stream_index==audio_stream){  

			packet_queue_put(&audio_queue,&packet);  

			//change

		}else{  

			av_free_packet(&packet);  

		}  



		//usleep(5000);  

	}  

	SDL_CloseAudio();  

	SDL_CondSignal(g_play_info.pictq_cond);  

	SDL_WaitThread(video_decode_thread,NULL);  

	SDL_WaitThread(video_show_thread,NULL);  

	picture_queque_destroy(&g_play_info);  



	swr_free(&g_play_info.audio_conv);  

	sws_freeContext(g_play_info.video_conv);  



	SDL_FreeSurface(screen);  

	avcodec_close(g_play_info.pVideoCodecCtx);  

	avcodec_close(g_play_info.pAudioCodecCtx);  

	avformat_close_input(&pFormatCtx);  

	return 0;  



err_alloc_frame1:  

	avcodec_close(g_play_info.pAudioCodecCtx);  

	avcodec_close(g_play_info.pVideoCodecCtx);  

	avformat_close_input(&pFormatCtx);  

	return -1;  

}