【C++】使用 libass，完成 Direct3D 11 下的字幕渲染

前言

前段时间曾经写过一个视频播放器：https://www.cnblogs.com/judgeou/p/14746051.html 。

然而这个播放器却无法显示出外挂或者内封的字幕，这里要稍微解释一下，字幕存在的三种形式：

内嵌：字幕是画面的一部分
内封：把字幕文件，例如ass文件放入了视频文件。
外挂：字幕单独是一个文件。

在内嵌的情况下不需要特殊处理，而内封和外挂的时候，就需要进行额外的工作才能看到字幕。

在 DX 11.1 之前，往 D3D 表面渲染文字的主要方式，是通过把字体文件变成图片的形式载入到纹理，然后再利用文字编码映射到纹理UV的方式来渲染文字，当我们使用 Imgui 的时候他就是这么处理文字的。

优点：可以高速切换文字，渲染效率高。缺点：如果遇上中文字体等字符数量庞大的字体，那么开头载入字体到纹理这个阶段需要耗费大量CPU时间，之后也需要占据大量显存。如果需要显示比较大而且又清晰的字体，那么这种负面情况会加剧，如果大到一定程度，一张纹理都塞不下，情况会变得相当复杂。（除非你不介意糊的话可以用小纹理渲染大字体）。以及，一些字体排版、特效等难以实现。

DX 11.1 之后，Direct2D 可以和 Direct3D 互操作了，d2d 的文字渲染功能全都可以利用起来，渲染高质量字体不再是问题。

不过今天要说的 libass 这个库（https://github.com/libass/libass）使得我们不需要关心上面说的问题，基本帮我们把所有字体特效全部搞定了。

编译 libass

当一个库宣称自己跨平台的时候，就说明在 Windows 上可能要折腾一番了。这个库使用了典型的 GNU Build System，在 MinGW64 上可以非常流畅的编译成功，如果你不介意使用DLL文件进行动态链接，可以尝试自己在 MinGW64 上编译源代码试试。但是如果你想静态链接到自己的项目，那么 MinGW64 上编译出来的库文件在 Visual Studio 中多半会不能用。。。

通过一番折腾，我已经把 libass 代码以及其依赖项整理好了，弄成了 vs 的项目：https://gitee.com/judgeou/libass-msvc，拿来直接编译就行。

初始化 libass

libass 的函数全都是以 ass_ 开头，很好辨认。

初始化操作没有太多要注意的：

ASS_Library* libass = ass_library_init();
ASS_Renderer* ass_renderer = ass_renderer_init(libass);
ASS_Track* ass_track = ass_read_file(libass, (char*)"subtitle.ass", (char*)"UTF-8");
ass_set_fonts(ass_renderer, NULL, "Arial", ASS_FONTPROVIDER_AUTODETECT, NULL, 0);
ass_set_frame_size(ass_renderer, bgWidth, bgHeight);

subtitle.ass 就是你字幕文件的路径，ass_set_fonts 第二、三个参数可以选择你想要的默认字体（当找不到对应字体的时候会使用）。

ass_set_frame_size 设置视频画面的分辨率，注意，这里是视频渲染时的分辨率，而不是原画分辨率，这样 libass 才会返回正确大小的位图。

渲染字幕

libass 渲染字幕的函数只有一个：ass_render_frame：

long long currentms = 6000; // 生成哪一时刻的字幕，单位是毫秒
int isChange = 0; // 与上一次生成比较，0：没有变化，1：位置变了，2: 内容变了
ASS_Image* assimg = ass_render_frame(ass_renderer, ass_track, currentms, &isChange);

ASS_Image 结构体是我们重点关注的东西：

/*
 * A linked list of images produced by an ass renderer.
 *
 * These images have to be rendered in-order for the correct screen
 * composition.  The libass renderer clips these bitmaps to the frame size.
 * w/h can be zero, in this case the bitmap should not be rendered at all.
 * The last bitmap row is not guaranteed to be padded up to stride size,
 * e.g. in the worst case a bitmap has the size stride * (h - 1) + w.
 */
typedef struct ass_image {
    int w, h;                   // Bitmap width/height
    int stride;                 // Bitmap stride 位图每一行有多少字节
    unsigned char *bitmap;      // 1bpp stride*h alpha buffer 仅含 alpha 通道的位图，大小是 stride * h
                                // Note: the last row may not be padded to
                                // bitmap stride! 注意，最后一行可能不会填充满，意思是读取最后一行的时候，读够 w 字节就行了
    uint32_t color;             // Bitmap color and alpha, RGBA 位图使用的 RGBA 颜色
    int dst_x, dst_y;           // Bitmap placement inside the video frame 该位图应该显示在视频画面中的哪个位置
    struct ass_image *next;   // Next image, or NULL 下一个 image
    enum {
        IMAGE_TYPE_CHARACTER,
        IMAGE_TYPE_OUTLINE,
        IMAGE_TYPE_SHADOW
    } type;
} ASS_Image;

很明显这是一个链表，libass 实际会生成多层的图像，我们需要一层一层的逐一渲染才能看到正确的字幕。

按照一般思维，我们猜测 libass 应该要返回一个 RGBA 位图，这样我们只要使用常规的手段可以简单的把位图显示在画面的某处，但 libass 返回的位图竟然只有 alpha 通道，外加一个单一的颜色值，这就有点棘手了。

首先我们单独创建一个和画面大小相同的 RGBA 格式纹理 subTexture，把字幕写入到这个纹理，然后先渲染视频画面，再渲染字幕纹理，这样字幕就居于视频之上了。这里必须要注意渲染字幕的纹理前一定要调用 OMSetBlendState 告诉 DIrect3D 接下来要进行 alpha 混合，否则透明的像素会渲染为黑色而不是它后面的视频纹理像素。

实现关键代码：

int isChange = 0;
auto assimg = ass_render_frame(ass_renderer, ass_track, currentms, &isChange);
if (isChange != 0) {
	int count = 0;
	D3D11_MAPPED_SUBRESOURCE mapped;
	d3dctx->Map(subTexture.Get(), 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped);
	memset(mapped.pData, 0, mapped.DepthPitch);
	if (assimg) {
		while (assimg) {
			auto src = assimg->bitmap;
			auto dst = (UCHAR*)mapped.pData;
			// 正确计算字幕的起始位置
			dst = dst + assimg->dst_y * mapped.RowPitch + assimg->dst_x * 4;
			for (int y = 0; y < assimg->h; ++y) {
				for (int x = 0; x < assimg->w; ++x) {
					auto i = assimg;
					auto pixel = dst + x * 4;
					auto srcA = (src[x] * (0xff - (assimg->color & 0x000000ff))) >> 8;
					auto compA = 0xff - srcA;
					double alpha = (255 - src[x]) / 255.0;
					UCHAR rb = (assimg->color & 0xff000000) >> 24;
					UCHAR gb = (assimg->color & 0x00ff0000) >> 16;
					UCHAR bb = (assimg->color & 0x0000ff00) >> 8;
					UCHAR ra = pixel[0];
					UCHAR ga = pixel[1];
					UCHAR ba = pixel[2];
					UCHAR aa = pixel[3];
					pixel[0] = (1 - alpha) * rb + alpha * ra;
					pixel[1] = (1 - alpha) * gb + alpha * ga;
					pixel[2] = (1 - alpha) * bb + alpha * ba;
					pixel[3] = (1 - alpha) * src[x] + alpha * aa;
				}
				// 指针移动到下一行
				src += assimg->stride;
				dst += mapped.RowPitch;
			}
			assimg = assimg->next;
		}
		d3dctx->Unmap(subTexture.Get(), 0);
	}
}
ctx->DrawIndexed(indicesSize, 0, 0);

主要就是循环每个像素写入正确的颜色值，渲染每一层的时候，注意要和上一层的像素手动进行alpha混合。所有层写入完毕后再调用 DrawIndexed 渲染到 D3D 表面。

这种方法的一个问题在于，效率太低了，中间的混合过程运算并不轻松，而且迭代次数过多，经常动不动就一个图层接近一万次的迭代，如果用来渲染数量庞大的弹幕比PPT还卡。

想要提升效率，一是要减少迭代，二是要尽可能把运算交给 GPU 处理，为此，需要做不少工作：

不使用之前的全屏覆盖的纹理，改为每个图层独立创建小纹理
直接把 assimg->bitmap 原封不动复制到字幕纹理中
把 assimg->color 作为常量缓冲，和纹理归为一组资源，放入 pipeline
通过 assimg->dst_x 和 assimg->dst_y 计算顶点坐标，和纹理归为一组资源，放入pipeline，让字幕渲染到正确的位置
通过着色器来对像素颜色进行处理，充分利用GPU。
把这些资源放到一个数组中保存起来，当字幕没有变化时（isChange == 0），直接开始 D3D 的渲染流程，跳过写入数据到纹理等资源的过程
因为我们没法预测字幕位图的大小，以及 D3D 纹理大小是固定的，所以每次字幕变化时，都需要重新创建纹理，之前的纹理无法重复使用，必须要销毁。

// 创建字幕图层的只读的纹理
void CreateOneTimeTexture(ID3D11Device* d3ddevice, int width, int height, ID3D11Texture2D** subTexture, ID3D11ShaderResourceView** srv, const UCHAR* data, int pitch) {
	D3D11_TEXTURE2D_DESC subDesc = {};
	subDesc.Format = DXGI_FORMAT_R8_UNORM;
	subDesc.ArraySize = 1;
	subDesc.MipLevels = 1;
	subDesc.SampleDesc = { 1, 0 };
	subDesc.Width = width;
	subDesc.Height = height;
	subDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
	subDesc.Usage = D3D11_USAGE_IMMUTABLE;
	D3D11_SUBRESOURCE_DATA sd = {};
	sd.pSysMem = &data[0];
	sd.SysMemPitch = pitch;
	ComPtr<ID3D11Texture2D> tempTexture;
	if (subTexture == NULL) {
		subTexture = &tempTexture;
	}
	d3ddevice->CreateTexture2D(&subDesc, &sd, subTexture);
	if (srv) {
		// 创建着色器资源
		D3D11_SHADER_RESOURCE_VIEW_DESC const srvDesc = CD3D11_SHADER_RESOURCE_VIEW_DESC(
			*subTexture,
			D3D11_SRV_DIMENSION_TEXTURE2D,
			subDesc.Format
		);
		d3ddevice->CreateShaderResourceView(
			*subTexture,
			&srvDesc,
			srv
		);
	}
}
// 每一个字幕图层需要的 D3D 资源
struct SubtitleD3DResource {
	ComPtr<ID3D11Texture2D> tex;
	ComPtr<ID3D11ShaderResourceView> srv;
	ComPtr<ID3D11Buffer> cb_color;
	ComPtr<ID3D11Buffer> vertex;
	SubtitleD3DResource(ID3D11Device* device, int w, int h, const UCHAR* texdata, int pitch, uint32_t color, const vector<Vertex>& vertices) {
		// ... 在这里创建好这个结构体的 D3D 资源。
		CreateOneTimeTexture(device, w, h, &tex, &srv, texdata, pitch);
		D3D11_BUFFER_DESC bd = {};
		bd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
		bd.Usage = D3D11_USAGE_IMMUTABLE;
		bd.ByteWidth = vertices.size() * sizeof(Vertex);
		bd.StructureByteStride = sizeof(Vertex);
		D3D11_SUBRESOURCE_DATA sd = {};
		sd.pSysMem = &vertices[0];
		device->CreateBuffer(&bd, &sd, &vertex);
		D3D11_BUFFER_DESC cbd = {};
		cbd.Usage = D3D11_USAGE_IMMUTABLE;
		cbd.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
		cbd.ByteWidth = 16;
		cbd.StructureByteStride = sizeof(uint32_t);
		D3D11_SUBRESOURCE_DATA csd = {};
		csd.pSysMem = &color;
		device->CreateBuffer(&cbd, &csd, &cb_color);
	}
};
void Draw () {
// ...
	int isChange = 0;
	auto assimg = ass_render_frame(ass_renderer, ass_track, currentms + 6300, &isChange);
	if (isChange) {
		subsD3DResource.clear(); // SubtitleD3DResource的数组，重新写入字幕位图时需要清空，回收资源
		if (assimg) {
			while (assimg) {
				// 计算UV，这里要进行归一化，转换为 [0.0, 1.0]
				float u1 = (float)assimg->dst_x / sub_frame_width;
				float v1 = (float)assimg->dst_y / sub_frame_height;
				float u2 = ((float)assimg->dst_x + assimg->w) / sub_frame_width;
				float v2 = ((float)assimg->dst_y + assimg->h) / sub_frame_height;
				// 计算顶点坐标，这里把上面的结果变为 [-1.0, +1.0]
				float x1 = u1 * 2 - 1;
				float y1 = 1 - v1 * 2;
				float x2 = u2 * 2 - 1;
				float y2 = 1 - v2 * 2;
				vector<Vertex> vertices = {
					{x1,	y1,	0,	0,	0},
					{x2,	y1,	0,	1,	0},
					{x2,	y2,	0,	1,	1},
					{x1,	y2,	0,	0,	1},
				};
				// 直接把 bitmap 复制到纹理，没有任何多余的循环
				SubtitleD3DResource subRes(d3ddevice.Get(), assimg->w, assimg->h, assimg->bitmap, assimg->stride, assimg->color, vertices);
				subsD3DResource.push_back(subRes);
				assimg = assimg->next;
			}
		}
	}
	// 按顺序渲染每一个图层
	for (auto& subRes : subsD3DResource) {
		ID3D11Buffer* vertexBuffers2[] = { subRes.vertex.Get() };
		ctx->IASetVertexBuffers(0, 1, vertexBuffers2, &stride, &offset);
		ID3D11Buffer* cbs2[] = { subRes.cb_color.Get() };
		ctx->PSSetConstantBuffers(0, 1, cbs2);
		ID3D11ShaderResourceView* srvs2[] = { subRes.srv.Get() };
		ctx->PSSetShaderResources(0, 1, srvs2);
		ctx->DrawIndexed(indicesSize, 0, 0);
	}
// ...
}

渲染字幕纹理时，使用下面这个着色器：

Texture2D<float> tex : register(t0);
SamplerState splr;
cbuffer CBuf
{
    uint color;
};
float4 main_PS_ass(float2 tc : TEXCOORD) : SV_TARGET
{
    float alpha = tex.Sample(splr, tc); // 从纹理中取得 alpha 值
    // 从常量缓冲取得 rgb 值
    float r = ((color & 0xff000000) >> 24) / 255.0;
    float g = ((color & 0x00ff0000) >> 16) / 255.0;
    float b = ((color & 0x0000ff00) >> 8) / 255.0;
    return float4(r, g, b, alpha);
}

结果截图：

即使是数量较多的弹幕，CPU占用也不算太高了。但是如果再多一些还是会卡顿，如果还要优化，就需要抛弃 libass 的渲染代码，自己用 Direct2D 进行文字渲染，避免我这样每次都创建新的纹理，事实上大多数CPU都花费在了创建新纹理上。又或者想出一种办法可以用一张纹理通过着色器程序一次搞定，反正我是想不出来了。如果大家有什么好办法，请务必在评论区告诉我。

内封字幕

对于内封字幕，其实处理方法大同小异。ASS_Track 的获得方式不再是 ass_read_file，而是使用 ass_new_track 创建一个空的 track，在打开视频字幕流的时候（AVCodec.type == AVMEDIA_TYPE_SUBTITLE），从 AVCodecContext.extradata 可以取得 ASS 的文件头，类似这样的内容（注意它是UTF-8编码的）：

[Script Info]
Title: 侦探已死：1下_番剧_bilibili_哔哩哔哩
Original Script: Generated by tiansh/ass-danmaku (embedded in liqi0816/bilitwin) based on https://www.bilibili.com/bangumi/play/ep409795?spm_id_from=333.851.b_62696c695f7265706f72745f616e696d65.53
ScriptType: v4.00+
Collisions: Normal
PlayResX: 560
PlayResY: 420
Timer: 100.0000
[V4+ Styles]
Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
Style: Fix,SimHei,25,&H00FFFFFF,&H00FFFFFF,&H00000000,&H00000000,0,0,0,0,100,100,0,0,1,2,0,2,20,20,2,0
Style: Rtl,SimHei,25,&H00FFFFFF,&H00FFFFFF,&H00000000,&H00000000,0,0,0,0,100,100,0,0,1,2,0,2,20,20,2,0

随后调用 ass_process_codec_private：

ass_process_codec_private(ass_track, (char*)subcodecCtx->extradata, subcodecCtx->extradata_size);

在循环解码的阶段，判断 AVPacket 的解码器类型是 AVMEDIA_TYPE_SUBTITLE 时，则可从 packet 中的 pts 和 duration 得到该字幕应当出现的时刻与时长（注意要根据 timebase 转换成毫秒）。调用 avcodec_decode_subtitle2 可取得 AVSubtitle 对象，从 AVSubtitle.rects 取得 AVSubtitleRect**，因为同一时刻可能存在多个字幕。AVSubtitleRect.ass 就是我们要的东西，它通常是一行 ass event，总之调用 ass_process_chunk 把这行字符串交给 libass 即可。

AVPacket* packet;
// ... 读取 packet
// 这里得到的是秒
double duration = packet->duration * subtitleTimeBase;
double pts = packet->pts * subtitleTimeBase;
AVSubtitle sub = {};
int got_sub_ptr = 0;
avcodec_decode_subtitle2(codecCtx, &sub, &got_sub_ptr, packet);
if (got_sub_ptr) {
	int num = sub.num_rects;
	for (int i = 0; i < num; i++) {
		auto rect = sub.rects[i];
		ass_process_chunk(ass_track, rect->ass, strlen(rect->ass), pts * 1000, duration * 1000); // 乘以 1000 转换成毫秒
	}
}

之后的处理就和上面一样了，依然是调用 ass_render_frame 来获得图层。

结尾

libass 的 bitmap 通常 stride 会大于 w，多出来的部分是用来填充的空白数据，为什么要多此一举呢，简单的来说就是要对齐字节，加速 CPU 处理。比如现在 64 位 CPU 少说一次读取也能读取 64bit，也就是一个 long long 或者两个 int，通过恰当的安排可以减少 CPU 读取次数。

为了兼容各平台，libass 没有使用和平台密切相关的技术，例如 Direct2D（最多也是用来获取字体），字体的绘制都是使用例如 freetype 这样跨平台的库来实现，这就导致其几乎没有硬件加速能力，如果要完全硬件加速，恐怕得自己写渲染代码了。