RTSP流媒体播放器实现

        最近需要做一个RTSP流媒体播放器，研究了一下，封装了一个RTSP播放类CRTSPPlayer，解码库采用ffmpeg。由于需求比较简单，时间也有限，目前只实现了播放、停止、暂停几个基本的接口。下面是基于CRTSPPlayer类实现的简单RTSP播放器。

                                   

       目前视频只测试了H264格式，其它格式的视频还未做测试。播放器也支持直接打开本地视频播放，但播放的帧率和原始视频的码率不同步。目前还不清楚如何处理这个问题，希望懂这方面的大侠指教。

       另外，还有一个开源的库VLC也可以用来开发流媒体播放器，它支持多种流媒体协议，如RTP、RTSP等，CodeProject上已经有牛人在VLCLib的基础上封装可更易使用的库VLCWrapper（地址：http://www.codeproject.com/Articles/38952/VLCWrapper-A-Little-C-wrapper-Around-libvlc）。用它可以很方便的开发视频播放器。

        以下是CRTSPPlayer完整的代码：

头文件:

/******************************************************************** 
filename:   CRTSPPlayer.h 
created:    2013-03-25 
author:     firehood 
purpose:    ffmpeg库实现的RTSP视频播放器
*********************************************************************/ 
#pragma once
#include "windows.h"

extern "C"
{
#include "libavformat\avformat.h"
#include "libavcodec\avcodec.h"
#include "libswscale\swscale.h"
};

// 播放状态
enum RTSP_PLAYSTATUS
{
	RTSP_PLAYSTATUS_NONE,       // 未知状态（未播放）
	RTSP_PLAYSTATUS_PLAYING,    // 正在播放
    RTSP_PLAYSTATUS_PAUSE,      // 已暂停
	RTSP_PLAYSTATUS_STOP,       // 已停止
};

class CRTSPPlayer
{
public:
	CRTSPPlayer(HWND hWnd, LPRECT lpRect);
	~CRTSPPlayer(void);
public:
	// 打开媒体文件
	BOOL OpenMedia(LPCTSTR pFileName);
	// 播放
	void Play();
	// 暂停
	void Pause();
	// 停止
	void Stop();
	// 获取播放状态
	RTSP_PLAYSTATUS GetPlayStatus(void);
private:
	// 解码初始化
	int DecodeInit(LPCTSTR pFileName);
	// 卸载
	void DecodeUninit();
	// 开始解码线程
    BOOL StartDecodeThread();
    // 停止解码线程
	void StopDecodeThread();
    // 解码线程
	static int WINAPI ThreadDecodeVideo(LPVOID lpParam);
    // 开始解码任务
	int BeginDecode();
    // 显示
	void Display();
    // 图像转换
	int ImgConvert(AVPicture * dst, PixelFormat dstFormt, const AVPicture * src, PixelFormat srcFormt, int src_width, int src_height);
    // 设置播放状态
    void SetPlayStatus(RTSP_PLAYSTATUS playStatus);
private:
    HANDLE  m_hDecodeThread;
	BOOL    m_bExitDecodeThread;
    TCHAR   m_strFilePath[MAX_PATH];

	AVFormatContext* m_pFormatContext;
	AVCodecContext*  m_pCodecContext;
	AVCodec* m_pCodec;
	AVPacket m_struPacket;
	int m_nStreamIndex;
	AVFrame* m_pFrameYUV;
	AVFrame* m_pFrameRGB;
	int     m_nFrameWidth; 
	int	    m_nFrameHeight;
	BYTE*   m_pBufRGB;        // 解码后的RGB数据

	RTSP_PLAYSTATUS  m_nPlayStatus;
	HWND    m_hWnd;
	RECT    m_rcWnd;
};

源文件：

/******************************************************************** 
filename:   CRTSPPlayer.cpp 
created:    2013-03-25 
author:     firehood 
purpose:    ffmpeg库实现的RTSP视频播放器
*********************************************************************/ 
#include "StdAfx.h"
#include "RTSPPlayer.h"

#pragma comment(lib, "avformat.lib")
#pragma comment(lib, "avcodec.lib")
#pragma comment(lib, "swscale.lib")
#pragma comment(lib, "avutil.lib")

#define SHOW_TITLE

const char* WcharToUtf8(const wchar_t *pwStr)  
{  
	if (pwStr == NULL)  
	{  
		return NULL;  
	}  

	int len = WideCharToMultiByte(CP_UTF8, 0, pwStr, -1, NULL, 0, NULL, NULL);  
	if (len <= 0)  
	{  
		return NULL;  
	}  
	char *pStr = new char[len];  
	WideCharToMultiByte(CP_UTF8, 0, pwStr, -1, pStr, len, NULL, NULL);  
	return pStr;  
}  

CRTSPPlayer::CRTSPPlayer(HWND hWnd, LPRECT lpRect):
m_hWnd(hWnd),
m_rcWnd(*lpRect),
m_hDecodeThread(NULL),
m_bExitDecodeThread(FALSE),
m_nFrameWidth(0),
m_nFrameHeight(0),
m_pFormatContext(NULL),
m_pCodecContext(NULL),
m_pCodec(NULL),
m_nStreamIndex(-1),
m_pFrameYUV(NULL),
m_pFrameRGB(NULL),
m_pBufRGB(NULL),
m_nPlayStatus(RTSP_PLAYSTATUS_NONE)
{
	memset(m_strFilePath,0,sizeof(m_strFilePath));
}

CRTSPPlayer::~CRTSPPlayer(void)
{
	DecodeUninit();
}

// 打开媒体文件
BOOL CRTSPPlayer::OpenMedia(LPCTSTR pFileName)
{
	if(pFileName == NULL)
		return FALSE;
	DecodeUninit();
	memcpy(m_strFilePath,pFileName,sizeof(m_strFilePath));
	DecodeInit(m_strFilePath);
	return TRUE;
}

// 播放
void CRTSPPlayer::Play()
{ 
	if(GetPlayStatus() == RTSP_PLAYSTATUS_STOP)
	{
		DecodeInit(m_strFilePath);
	}
	BOOL bRet = StartDecodeThread();
	if(bRet)
	{
		SetPlayStatus(RTSP_PLAYSTATUS_PLAYING);
	}
}

// 暂停
void CRTSPPlayer::Pause()
{
	StopDecodeThread();
	SetPlayStatus(RTSP_PLAYSTATUS_PAUSE);
}

// 停止
void CRTSPPlayer::Stop()
{
	StopDecodeThread();
	DecodeUninit();
	SetPlayStatus(RTSP_PLAYSTATUS_STOP);
}

BOOL CRTSPPlayer::StartDecodeThread()
{
	if(m_hDecodeThread == NULL)
	{
		m_hDecodeThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ThreadDecodeVideo, this, 0, NULL);
	}
	return m_hDecodeThread ? TRUE : FALSE;
}

void CRTSPPlayer::StopDecodeThread()
{
	if(m_hDecodeThread)
	{
		m_bExitDecodeThread = TRUE;
		WaitForSingleObject(m_hDecodeThread,INFINITE);
		CloseHandle(m_hDecodeThread);
		m_hDecodeThread = NULL;
	}
}

int CRTSPPlayer::ImgConvert(AVPicture * dst, PixelFormat dst_pix_fmt, const AVPicture * src, PixelFormat src_pix_fmt, int src_width, int src_height)
{

	unsigned char * srcSlice[4];
	int srcStride[4] = {0};

	unsigned char * dstSlice[4];
	int dstStride[4] = {0};


	for (int i=0; i<4; i++)
	{
		srcSlice[i] = src->data[i];
		srcStride[i] = src->linesize[i];

		dstSlice[i] = dst->data[i];
		dstStride[i] = dst->linesize[i];
	}

	SwsContext *pSwsContext = sws_getContext(src_width, src_height, src_pix_fmt, src_width, src_height, dst_pix_fmt, SWS_BICUBIC, NULL, NULL, NULL);

	int nRet = sws_scale(pSwsContext, srcSlice, srcStride, 0, src_height, dstSlice, dstStride);

	if (pSwsContext != NULL)
	{
		sws_freeContext(pSwsContext);
	}

	return nRet;
}

int WINAPI CRTSPPlayer::ThreadDecodeVideo(LPVOID lpParam)
{
	CRTSPPlayer *pPlayer = (CRTSPPlayer*)lpParam;

	pPlayer->BeginDecode();

	return 0;
}

int CRTSPPlayer::DecodeInit(LPCTSTR pFileName)
{
    if(pFileName == NULL)
	{
		return -1;
	}

	av_register_all();

#ifdef  UNICODE   
	const char *filePath = WcharToUtf8(pFileName); 
	// Open video
	if (av_open_input_file(&m_pFormatContext, filePath, NULL, 0, NULL) != 0)
	{
		return -2; // Couldn't open file
	}
	delete[] filePath;
#else
	// Open video
	if (av_open_input_file(&m_pFormatContext, pFileName, NULL, 0, NULL) != 0)
	{
		return -2; // Couldn't open file
	}
#endif
	// Retrieve stream information
	if (av_find_stream_info(m_pFormatContext) < 0)
	{
		return -3; // Couldn't find stream information
	}

	// Find the first video stream
	for (UINT i=0; i<m_pFormatContext->nb_streams; i++)
	{
		if (m_pFormatContext->streams[i]->codec->codec_type == CODEC_TYPE_VIDEO)
		{
			m_nStreamIndex = i;
			break;
		}
	}
	if (m_nStreamIndex == -1)
	{
		return -4; // Didn't find a video stream
	}

	// Get a pointer to the codec context for the video stream
	m_pCodecContext = m_pFormatContext->streams[m_nStreamIndex]->codec;

	// Find the decoder for the video stream
	m_pCodec = avcodec_find_decoder(m_pCodecContext->codec_id);
	if (m_pCodec == NULL)
	{
		return -5 ; // Codec not found
	}

	// Inform the codec that we can handle truncated bitstreams -- i.e.,
	// bitstreams where frame boundaries can fall in the middle of packets
	if (m_pCodec->capabilities & CODEC_CAP_TRUNCATED)
	{
		m_pCodecContext->flags |= CODEC_FLAG_TRUNCATED;  // we do not send complete frames
	}

	// Open codec
	if (avcodec_open(m_pCodecContext, m_pCodec) < 0)
	{
		return -6; // Could not open codec
	}

	// Allocate video frame
	m_pFrameYUV = avcodec_alloc_frame();

	// Allocate an AVFrame structure
	m_pFrameRGB = avcodec_alloc_frame();

	// Determine required buffer size and allocate buffer
	int numBytes = avpicture_get_size(PIX_FMT_BGR24, m_pCodecContext->width, m_pCodecContext->height);
	m_pBufRGB = new BYTE [numBytes];
	memset(m_pBufRGB,0,numBytes);
	// Assign appropriate parts of buffer to image planes in m_pFrameRGB
	avpicture_fill((AVPicture *)m_pFrameRGB, m_pBufRGB, PIX_FMT_BGR24, m_pCodecContext->width, m_pCodecContext->height);

	m_nFrameWidth  = m_pCodecContext->width;
	m_nFrameHeight = m_pCodecContext->height;

	return 0;
}

void CRTSPPlayer::DecodeUninit()
{
	// Close the codec
	if (m_pCodecContext)
	{
		avcodec_close(m_pCodecContext);
		//av_free(m_pCodec);
		m_pCodecContext = NULL;
		m_pCodec = NULL;
	}

	// Close the video file
	if (m_pFormatContext)
	{
		av_close_input_file(m_pFormatContext);
		m_pFormatContext = NULL;
	}

	if (m_pFrameYUV)
	{
		av_free(m_pFrameYUV);
		m_pFrameYUV = NULL;
	}

	if (m_pFrameRGB)
	{
		av_free(m_pFrameRGB);
		m_pFrameRGB = NULL;
	}

	if (m_pBufRGB)
	{
		delete [] m_pBufRGB;
		m_pBufRGB = NULL;
	}
}

int CRTSPPlayer::BeginDecode()
{
	int bytesRemaining = 0, bytesDecoded;
	BYTE * rawData = NULL;

	int frameFinished = 0;

	m_struPacket.data = NULL;
	m_struPacket.size = 0;

	m_bExitDecodeThread = FALSE;

	while (!m_bExitDecodeThread && m_pFormatContext)
	{
		// Read the next packet, skipping all packets that aren't for this stream
		do
		{
			// Read new packet
			if (av_read_frame(m_pFormatContext, &m_struPacket) < 0)
			{

				return -2;
			}
		} while (m_struPacket.stream_index != m_nStreamIndex);

		bytesRemaining = m_struPacket.size;
		rawData = m_struPacket.data;

		// Work on the current packet until we have decoded all of it
		while (bytesRemaining > 0)
		{
			// Decode the next chunk of data
			bytesDecoded = avcodec_decode_video(m_pCodecContext, m_pFrameYUV, &frameFinished, rawData, bytesRemaining);

			// Was there an error?
			if (bytesDecoded < 0)
			{
				return -1;
			}

			bytesRemaining -= bytesDecoded;
			rawData += bytesDecoded;

			// Did we finish the current frame? Then we can return
			if (frameFinished)
			{
				ImgConvert(
					(AVPicture *)m_pFrameRGB,
					PIX_FMT_BGR24,
					(AVPicture *)m_pFrameYUV,
					m_pCodecContext->pix_fmt,
					m_pCodecContext->width,
					m_pCodecContext->height);

				Display();
			}
		}
	}
	m_hDecodeThread = NULL;
	return 0;
}

void CRTSPPlayer::Display()
{
	HDC hdc = GetDC(m_hWnd);
	// 创建内存DC
    HDC hMemDc = CreateCompatibleDC(hdc);     

	// 创建位图
	BITMAPINFOHEADER bmpHdr = {0};  
	bmpHdr.biSize = sizeof (BITMAPINFOHEADER);  
	bmpHdr.biWidth = m_nFrameWidth;  
	bmpHdr.biHeight = -m_nFrameHeight;  
	bmpHdr.biPlanes = 1;  
	bmpHdr.biBitCount = 24;  
	bmpHdr.biCompression = BI_RGB;  

	BYTE *pData = NULL;   
	HBITMAP hBitmap = CreateDIBSection (NULL, (BITMAPINFO *)&bmpHdr, DIB_RGB_COLORS, (void**)&pData, NULL, 0);  

	try
	{
		memcpy(pData, m_pBufRGB, m_nFrameWidth * m_nFrameHeight * 3);
	}
	catch (CMemoryException* e)
	{
		
	}

	HBITMAP hOldBitmap = (HBITMAP)SelectObject(hMemDc, hBitmap);

#ifdef SHOW_TITLE
	// 设置字体参数
	LOGFONT logfont;
	memset(&logfont, 0, sizeof(LOGFONT));
	logfont.lfHeight = 40;
	logfont.lfWidth = 0;	
	logfont.lfEscapement = 0;
	logfont.lfOrientation = 0;
	logfont.lfWeight = 30;
	logfont.lfItalic = 0;
	logfont.lfUnderline = 0;
	logfont.lfStrikeOut = 0;
	logfont.lfCharSet = DEFAULT_CHARSET;   
	logfont.lfOutPrecision= OUT_DEFAULT_PRECIS;   
	logfont.lfClipPrecision= OUT_DEFAULT_PRECIS;   
	logfont.lfQuality = DEFAULT_QUALITY;   
	logfont.lfPitchAndFamily= DEFAULT_PITCH;  

	// 创建字体并选入环境
	HFONT hFont = CreateFontIndirect(&logfont);
	HFONT hOldFont = (HFONT)SelectObject(hMemDc, hFont);

	// 设置绘图环境
	SetBkMode(hMemDc, TRANSPARENT);  
    SetTextColor(hMemDc, RGB(255, 255, 0));

	// 绘制文字
	TextOut(hMemDc,0,0,m_strFilePath,_tcslen(m_strFilePath));

	// 恢复环境释放字体
	SelectObject(hMemDc, hOldFont);
#endif
	StretchBlt(  
		hdc,  
		m_rcWnd.left,   
		m_rcWnd.top,   
		m_rcWnd.right-m_rcWnd.left,   
		m_rcWnd.bottom-m_rcWnd.top,   
		hMemDc,  
		0,   
		0,   
		m_nFrameWidth,   
		m_nFrameHeight,   
		SRCCOPY);  

	// 恢复并释放环境    
	SelectObject(hMemDc,hOldBitmap);  
	DeleteObject(hBitmap);  
	DeleteDC(hMemDc);  
}

// 获取播放状态
RTSP_PLAYSTATUS CRTSPPlayer::GetPlayStatus(void)
{
	return m_nPlayStatus;
}

// 设置播放状态
void CRTSPPlayer::SetPlayStatus(RTSP_PLAYSTATUS playStatus)
{
	m_nPlayStatus = playStatus;
}