Cocos2d-x Win32 集成 libVLC，在 Sprite 中播放视频｜默然的博客

1. 更新记录

1. 修复销毁VideoSprite 闪退

2. 适用范围与结论

本文使用 libVLC 3.0.21，并针对仍保留 CCSprite、CCTexture2D、sharedDirector() 等旧式 API 的 Cocos2d-x Win32 工程。较新的 Cocos2d-x 版本需要把纹理、渲染命令和 Lua 绑定部分迁移到对应接口，不能直接复制代码。

实现思路是让 libVLC 把视频解码为 RGBA 内存，随后在 Cocos2d-x 渲染阶段通过 glTexSubImage2D 更新 Sprite 纹理。这样可以复用现有场景树和 Lua 调用方式，但需要特别处理解码线程、像素缓冲生命周期和每帧纹理上传成本。

3. 前言

cocos2dx本身带有VideoPlayer组件，但是只能在Android/iOS下播放视频，并不支持win32应用。官方不提供解决方案，so，自己实现吧。

4. 关于 libVLC

一个支持大多数平台的开源多媒体核心引擎。支持win/mac/android/ios等。官方提供C++/OC(Swift)/Java(Kolin)/.NET(Mono)的绑定。

5. SDK 准备

这里当然使用C嘎嘎的。前往：vlc官网 或者 –>这里<–下载自己需要的vlc的SDK。

PS:要下载对应平台的 *.7z格式的包体，ZIP包中不包含SDK,不知道官方在搞什么灰机。这里是win32。

6. Visual Studio 工程配置

6.1 添加链接库

1. 把下载的vlc-3.0.21\sdk中的include与lib文件夹复制到cocos工程的”frameworks\cocos2d-x\external\vlc”目录下，文件夹自行创建。(当然也可以放其他目录，这里只是为了和其他库保持一致)。
2. 把sdk中的plugin文件夹 和 libvlc.dll,libvlccore.dll 复制到 exe同级目录。

6.2 配置头文件与静态链接库

7. 在 Cocos2d-x Sprite 上渲染视频

7.1 VideoSprite 组件

// VideoSprite.h

#ifndef __VIDEOSPRITE_H__
#define __VIDEOSPRITE_H__

#include <vlc\vlc.h>
#include "2d/CCSprite.h"

NS_CC_BEGIN

class CC_DLL VideoSprite : public Sprite
{
public:
	std::string _videoURL;
	bool m_isLoop = false;

	VideoSprite();
	~VideoSprite();

	static VideoSprite* create();
	bool init(void);
	void play();
	void stop(void);
	void pause(void);
	void draw(Renderer *renderer, const Mat4 &transform, uint32_t flags);
	void setLooping(bool looping);
	const std::string& getFileName();
	void setFileName(const std::string& path);

private:
	libvlc_instance_t *vlc;
	libvlc_media_player_t *vlc_player;
	libvlc_event_manager_t *vlc_eventManager;

	unsigned int width;
	unsigned int height;

	static void vlcEvents(const libvlc_event_t *p_event, void *p_data);
};

NS_CC_END

#endif

// VideoSprite.cpp

#include "cocos2d.h"
#include "VideoSprite.h"
#include "base/CCDirector.h"


NS_CC_BEGIN
#if CC_TARGET_PLATFORM == CC_PLATFORM_WIN32

static std::unique_ptr<char[]> videobuf;

static void *lock(void *data, void **p_pixels)
{
	*p_pixels = videobuf.get();
	return NULL;
}

static void unlock(void *data, void *id, void *const *p_pixels) { }

static void display(void *data, void *id){ }


VideoSprite* VideoSprite::create()
{
	VideoSprite *video = new VideoSprite();
	if (video && video->init())
	{
		video->autorelease();
		return video;
	}
	CC_SAFE_DELETE(video);
	return nullptr;
}

bool VideoSprite::init(void)
{
	vlc = libvlc_new(0, NULL);
	vlc_player = libvlc_media_player_new(vlc);
	vlc_eventManager = libvlc_media_player_event_manager(vlc_player);

	const CCSize size = Director::sharedDirector()->getWinSize();
	width = size.width;
	height = size.height;
	videobuf = std::make_unique<char[]>((width * height) << 2);
	memset(videobuf.get(), 0, (width * height) << 2);
	libvlc_video_set_callbacks(vlc_player, lock, unlock, display, NULL);
	libvlc_video_set_format(vlc_player, "RGBA", width, height, width << 2);
	
	libvlc_event_attach(vlc_eventManager, libvlc_MediaPlayerEndReached, &VideoSprite::vlcEvents, this);

	CCTexture2D *texture = new CCTexture2D();
	texture->initWithData(videobuf.get(), (width * height) << 2, kCCTexture2DPixelFormat_RGBA8888, width, height, size);
	return initWithTexture(texture);
}

void VideoSprite::vlcEvents(const libvlc_event_t* p_event, void* p_data)
{
	if (!p_event) return;

	if (libvlc_MediaPlayerEndReached == p_event->type)
	{
		VideoSprite *self = static_cast<VideoSprite*>(p_data);
		if (self->m_isLoop)
		{
			libvlc_media_player_stop(self->vlc_player);
			libvlc_media_player_play(self->vlc_player);
		}
	}
}

VideoSprite::VideoSprite() : vlc(0), vlc_player(0), width(0), height(0)
{
#if CC_SPRITE_DEBUG_DRAW
	_debugDrawNode = DrawNode::create();
	addChild(_debugDrawNode);
#endif //CC_SPRITE_DEBUG_DRAW
}

VideoSprite::~VideoSprite()
{
	if (vlc_eventManager)
	{
		libvlc_event_detach(vlc_eventManager, libvlc_MediaPlayerEndReached, &VideoSprite::vlcEvents, this);
		vlc_eventManager = nullptr;
	}
	if (vlc_player)
	{
		// 先把回调清空，避免正在 stop/release 时仍有解码线程回调进来
		libvlc_video_set_callbacks(vlc_player, nullptr, nullptr, nullptr, nullptr);

		// 如果在播，先停
		libvlc_media_player_stop(vlc_player);

		libvlc_media_player_release(vlc_player);
		vlc_player = nullptr;
	}
	if (vlc)
	{
		libvlc_release(vlc);
		vlc = nullptr;
	}
}

const std::string& VideoSprite::getFileName()
{
	return _videoURL;
}
void VideoSprite::setFileName(const std::string& path)
{
	_videoURL = path;
}



void VideoSprite::play()
{
	if (!vlc || !vlc_player || _videoURL.empty()) return;

	libvlc_media_t *media = libvlc_media_new_path(vlc, _videoURL.c_str());
	if (!media) return;

	libvlc_media_player_set_media(vlc_player, media);
	libvlc_media_release(media);
	libvlc_media_player_play(vlc_player);
}

void VideoSprite::stop()
{
	if (vlc_player != nullptr)
	{
		libvlc_media_player_stop(vlc_player);
	}
}

void VideoSprite::pause()
{
	if (vlc_player != nullptr)
	{
		libvlc_media_player_pause(vlc_player);
	}
}

void VideoSprite::draw(Renderer *renderer, const Mat4 &transform, uint32_t flags)
{

	CC_PROFILER_START_CATEGORY(kCCProfilerCategorySprite, "CCSprite - draw");
	CC_NODE_DRAW_SETUP();

	ccGLBlendFunc(_blendFunc.src, _blendFunc.dst);

	if (_texture != NULL)
	{
		ccGLBindTexture2D(_texture->getName());
		// 确保像素对齐（RGBA -> 4 字节对齐）
		glPixelStorei(GL_UNPACK_ALIGNMENT, 4);

		glTexSubImage2D(GL_TEXTURE_2D,
			0,
			0, 0,
			width, height,
			GL_RGBA, GL_UNSIGNED_BYTE,
			videobuf.get());
	}
	else
	{
		ccGLBindTexture2D(0);
	}

	ccGLEnableVertexAttribs(kCCVertexAttribFlag_PosColorTex);

#define kQuadSize sizeof(_quad.bl)
	const size_t offset = reinterpret_cast<uintptr_t>(&_quad);

	// vertex
	int diff = offsetof(ccV3F_C4B_T2F, vertices);
	glVertexAttribPointer(kCCVertexAttrib_Position, 3, GL_FLOAT, GL_FALSE, kQuadSize, reinterpret_cast<void*>(offset + diff));

	// texCoods
	diff = offsetof(ccV3F_C4B_T2F, texCoords);
	glVertexAttribPointer(kCCVertexAttrib_TexCoords, 2, GL_FLOAT, GL_FALSE, kQuadSize, reinterpret_cast<void*>(offset + diff));

	// color
	diff = offsetof(ccV3F_C4B_T2F, colors);
	glVertexAttribPointer(kCCVertexAttrib_Color, 4, GL_UNSIGNED_BYTE, GL_TRUE, kQuadSize, reinterpret_cast<void*>(offset + diff));

	glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

	CHECK_GL_ERROR_DEBUG();

	CC_INCREMENT_GL_DRAWS(1);

	CC_PROFILER_STOP_CATEGORY(kCCProfilerCategorySprite, "CCSprite - draw");
}

void VideoSprite::setLooping(bool looping)
{
	m_isLoop = looping;
}
#endif
NS_CC_END

7.2 Lua 绑定

绑定内容有点多，放文件里了，需要自取：

1. lib_cocos2dx_auto.cpp
2. lua_cocos2dx_manual.cpp

8. Lua 中的使用方式

if cc.VideoSprite then
    local videoSprite = cc.VideoSprite:create()
    videoSprite:setContentSize(1136, 640)
    videoSprite:setPosition(display.ui_offset_x, 0)
    videoSprite:addTo(self)
    videoSprite:setFileName(cc.FileUtils:getInstance():getWritablePath().."res/game_assets/video/xxx.mp4")
	videoSprite:setLooping(true)
    videoSprite:play()
end

9. 验证重点与限制

1. 示例把纹理尺寸直接设为窗口尺寸，实际项目应在拿到媒体尺寸后重新分配缓冲，避免视频比例失真和无效内存占用。
2. libVLC 的解码回调可能运行在非渲染线程，而 draw() 会同时读取 videobuf。正式项目需要双缓冲、互斥或帧交换标记，避免上传到一半更新的像素数据。
3. glTexSubImage2D 每帧上传整张 RGBA 纹理，分辨率较高时会产生明显的 CPU、内存带宽和 GPU 上传开销，需要用目标视频尺寸和帧率实测。
4. 销毁时不仅要清空回调并停止播放器，还要确认没有回调继续访问已经释放的 VideoSprite 和像素缓冲。
5. 部署时必须同时携带 libvlc.dll、libvlccore.dll 和 plugins，并检查目标程序与 libVLC 的 x86/x64 架构一致。

建议至少验证：连续播放、暂停恢复、循环播放、切换场景后销毁、重复创建销毁，以及窗口尺寸和视频分辨率不一致的情况。

10. 相关阅读

• Cocos2d-x 分帧加载
• Win32 窗体尺寸自适应
• Cocos2d-x Lua 与 C++ 交互