嵌入式 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完整的代码：

头文件:

[cpp] view plain copy

/********************************************************************
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;
};

源文件：

[cpp] view plain copy

/********************************************************************
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;
}

嵌入式 RTSP流媒体播放器实现

热门文章

最新文章

相关电子书