文字的编码

从入门到捕蛇者说

已于 2023-11-06 19:32:13 修改

阅读量118

点赞数 1

分类专栏： Linux系统应用文章标签： linux

于 2023-10-30 21:57:16 首次发布

本文链接：https://blog.csdn.net/weixin_48856218/article/details/134128340

版权

Linux系统应用专栏收录该内容

9 篇文章 0 订阅

订阅专栏

1 字符的编码方式

1.1 ASCII

是“American Standard Code for Information Interchange”的缩写，美国信息交换标准代码。电脑毕竟是西方人发明的，他们常用字母就 26 个，区分大小写、加上标点符号也没超过 127 个，每个字符用一个字节来表示就足够了。**一个字节的 7 位就可以表示 128 个数值，在 ASCII 码中最高位永远是 0**。

1.2 ANSI

        ASNI 是 ASCII 的扩展，向下包含 ASCII。对于 ASCII 字符仍以一个字节来表示，对于非 ASCII 字符则使用 2 字节来表示，对于一个字符 bit7 是0则为ASCII， bit7 是1则为非ASCII，会用两个字节来表示一个非ASCII字符。并没有固定的 ASNI 编码，它跟“本地化”(locale)密切相关。比如在中国大陆地区，ANSI 的默认编码是 GB2312；在港澳台地区默认编码是 BIG5。以数值“0xd0d6”为例，对于 GB2312 编码它表示“中”；对于 BIG5 编码它表示“笢”。所以对于 ANSI 编码的 TXT 文件，如果你打开它发现乱码，那么还得再次细分它的具体编码。
        使用 Notepad 打开后，选择不同的编码(或称为字符集)，有不一样的显示，如下：

        这仅仅是在中国地区就出现这些不兼容的问题。对于不同国家，它们默认的ANSI 编码各不相同，所以同一个 TXT 文件在不同国家就很有可能出现乱码。根本的原理在于没有“统一的编码”，那解决方法自然就是使用“统一的编码”：UNICODE。

1.3 UNICODAE

        在 ANSI 标准中，很多种文字都有自己的编码标准，汉字简体字有 GB2312、繁体字BIG5，这难免同一个数值对应不同字符。比如数值“0xd0d6”，对于GB2312 编码它表示“中”；对于 BIG5 编码它表示“笢”。这造成了使用 ANSI 编码保存的文件，不适合跨地区交流。
        UNICODE 编码就是解决这类问题：对于地球上任意一个字符，都给它一个唯一的数值。
        UNICODE 仍然向下兼容 ASCII，但是对于其他字符会有对应的数值，比如对于“中”、“笢”，它们的数值分别是：0x4e2d、0x7b22UNICODE 中的数值范围是 0x0000 至 0x10FFFF，有 1,114,111 即 100 多万个数值，可以表示 100 多万个字符，足够地球人使用了。

2 UNICODAE编码实现

所谓编码实现，就是对于一个数值，怎么表示它。这很奇怪，数值还能怎么表示？比如“中”的 UNICODE 值是 0x4e2d，在 TXT 文件中怎么表示 0x4e2d ？直接写入 0x4e2d ？不行！

比如在 TXT 文件中写入 2 字节数据“ 0x2d 0x4e” ，它可以用来表示“中” 字吗？不能！它们对应 ASCII 字符“ -N ”。

问题的关键在于：怎么断字。在 TXT 文件中， 2 字节数据“ 0x2d 0x4e” 是作为一个整体看待，还是拆成 2 部分看待？

所以，需要用一定的技巧来表示数值，这就对应不同的编码实现。

怎么表示一个 UNICODE 数值？

2.1使用 3 个字节表示一个 UNICODE

不，太浪费。UNICODE 的最大值是 0x10FFFF，那使用 3 个字节来表示一个 UNICODE 数值？这当然是很省事的方法，但是会造成浪费，比如字符 A 的 UNICOCDE 值是0x41，难道也用“0x41 0x00 0x00”这 3 个字节来表示？

2.2 UCS-2 Little endian/UTF-16 LE

每个 UNICODE 值用 3 字节来表示有点浪费，那只用 2 字节呢？它可以表示 2^16=65536 个字符，全世界常用的字符都可以表示了。

Little endian 表示小字节序，数值中权重低的字节放在前面，比如字符 “A 中”在 TXT 文件中的数值如下，其中的“ A ”使用“ 0x41 0x00 ”两字节表示；“中”使用“0x2d 0x4e ”两字节表示。文件开头的“ 0xff 0xfe ”表示“ UTF- 16 LE”。

2.3UCS-2 Big endian/UTF-16 BE

Big endian 表示大字节序，数值中权重低的字节放在后面，比如字符“ ab 中”在 TXT 文件中的数值如下，其中的“ A ”使用“ 0x00 0x41 ”两字节表示； “中”使用“0x4e 0x2d ”两字节表示。文件开头的“ 0xfe 0xff ”表示“ UTF- 16 BE”。

2.4UTF8

在上面 2 种方法中，每一个 UNICODE 使用 2 字节来表示，这有 3 个缺点： 表示的字符数量有限、对于 ASCII 字符有空间浪费、如果文件中有某个字节丢失，这会使得后面所有字符都因为错位而无法显示。使用 UTF8 可以解决上述所有问题。 UTF8 是变长的编码方法，有 2 种 UTF8格式的文件：带有头部、不带头部。先举例，

对于其中的 ASCII 字符，在 UTF8 文件中直接用其 ASCII 码来表示，比如上图中的 0x61 表示字符 a 、 0x62 表示字符 b 。上图中的 3 个字节“ 0xe4 0xb8 0xad”表示的数值是 0x4e2d ，对应“中”的 UNICODE 码。

对于非 ASCII 字符，使用变长的编码：每一个字节的高位都自带长度信息。请看图

上图中，0xe4 的二进制是“ 11100100 ”，高位有 3 个 1 ，表示从当前字节起有 3 字节参与表示 UNICODE ；

0xb8 的二进制是“ 10111000 ”，高位有 1 个 1 ，表示从当前字节起有 1 字节参与表示 UNICODE ；

0xad 的二进制是“ 10101101 ”，高位有 1 个 1 ，表示从当前字节起有 1 字节参与表示 UNICODE ；

除去高位的“1110 ”、“ 10 ”、“ 10 ”后，剩下的二进制数组合起来得到 “01001110001101 ”，它就是 0x4e2d ，即“中”的 UNICODE 值。

使用 UTF8 编码时，即使 TXT 文件中丢失了某些数据，也只会影响到当前字符的显示，后面的字符不受影响。

3 点阵字符的显示

3.1 ASCII 字符的显示

要在 LCD 中显示一个 ASCII 字符，即英文字母这些字符，首先是要找到字符对应的点阵。在 Linux 内核源码中有这个文件： lib\fonts\font_8x16.c ，里面以数组形式保存各个字符的点阵，比如：

数组里的数字是如何表示点阵的？以字符 A 为例，如图：

上图左侧有 16 行数值，每行 1 个字节。每一个节对应右侧一行中 8 个像素：像素从右边数起，bit0 对应第 0 个像素， bit1 对应第 1 个像素，……， bit7 对应第 7 个像素。某位的值为 1 时，表示对应的像素要被点亮；值为 0 时表示对应的像素要熄灭。

所以要显示某个字符时，根据它的 ASCII 码在 fontdata_8x16 数组中找到它的点阵，然后取出这 16 个字节去描画 16 行像素。

比如字符 A 的 ASCII 值是 0x41 ，那么从 fontdata_8x16[0x41*16] 开始取其点阵数据。

核心函数是 void lcd_put_ascii(int x, int y, unsigned char c) ，它在 LCD 的 (x,y) 位置处显示字符 c

void lcd_put_ascii(int x, int y, unsigned char c)
{
	unsigned char *dots = (unsigned char *)&fontdata_8x16[c*16];  //找到该ASCII的点阵
	int i, b;
	unsigned char byte;

	for (i = 0; i < 16; i++)//16行 一行8个bit=1个字节
	{
		byte = dots[i];//取每一行的数据
		for (b = 7; b >= 0; b--)//8列 bit顺序：7 6 5 4 3 2 1 0
		{
			if (byte & (1<<b)) //判断该位置的led灯亮或不亮
			{
				/* show */
				lcd_put_pixel(x+7-b, y+i, 0xffffff); /* 白 */
			}
			else
			{
				/* hide */
				lcd_put_pixel(x+7-b, y+i, 0); /* 黑 */
			}
		}
	}
}

3.1.1 获取点阵

对于字符 c，char c，它的点阵获取方法如下：

unsigned char *dots = (unsigned char *)&fontdata_8x16[c*16];

3.1.2 描点

根据“图 6.11 字符 A 的点阵”，我们分析下如何利用点阵在 LCD 上显示一个英文字母。

因为有十六行，所以首先要有一个循环 16 次的大循环，然后每一行里有 8 位，那么在每一个大循环里也需要一个循环 8 次的小循环。小循环里的判断单行的描点情况，如果是 1 ，就填充白色，如果是 0 就填充黑色，如此一来，就可以显示出黑色底，白色轮廓的英文字母。

for (i = 0; i < 16; i++)//16行 一行8个bit=1个字节
{
	byte = dots[i];//取每一行的数据
	for (b = 7; b >= 0; b--)//8列 bit顺序：7 6 5 4 3 2 1 0
	{
		if (byte & (1<<b)) //判断该位置的led灯亮或不亮
		{
			/* show */
			lcd_put_pixel(x+7-b, y+i, 0xffffff); /* 白 */
		}
		else
		{
			/* hide */
			lcd_put_pixel(x+7-b, y+i, 0); /* 黑 */
		}
	}
}

3.1.3 main 函数

main 函数中首先要打开 LCD 设备，获取 Framebuffer 参数，实现 lcd_put_pixel 函数；然后调用 lcd_put_ascii 即可绘制字符。代码如下：

int main(int argc, char **argv)
{
	fd_fb = open("/dev/fb0", O_RDWR); //打开Framebuffer
	if (fd_fb < 0)
	{
		printf("can't open /dev/fb0\n");
		return -1;
	}
	if (ioctl(fd_fb, FBIOGET_VSCREENINFO, &var))
	{
		printf("can't get var\n");
		return -1;
	}

	line_width  = var.xres * var.bits_per_pixel / 8;
	pixel_width = var.bits_per_pixel / 8;
	screen_size = var.xres * var.yres * var.bits_per_pixel / 8;
	fbmem = (unsigned char *)mmap(NULL , screen_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd_fb, 0);
	if (fbmem == (unsigned char *)-1)
	{
		printf("can't mmap\n");
		return -1;
	}

	/* 清屏: 全部设为黑色 */
	memset(fbmem, 0, screen_size);

	lcd_put_ascii(var.xres/2, var.yres/2, 'A'); /*在屏幕中间显示8*16的字母A*/
	
	munmap(fbmem , screen_size);
	close(fd_fb);
	
	return 0;	
}

3.2 中文字符的点阵显示

3.2.1 指定编码格式

使用点阵字库时，中文字符的显示原理跟 ASCII 字符是一样的。要注意的地方在于中文的编码：在 C 源文件中它的编码方式是 GB2312 还是 UTF-8 ？编译出的可执行程序，其中的汉字编码方式是 GB2312 还是 UTF-8 ？

注意：一般不会使用 UTF-16 的编码方式，在这种方式下 ASCII 字符也是用 2 字节来表示，而其中一个字节是 0 ，但是在 C 语言中 0 表示字符串的结束符，会引起误会。

我们编写 C 程序时，可以使用 ANSI 编码，或是 UTF-8 编码；在编译程序时，可以使用以下的选项告诉编译器：

-finput-charset=GB2312
-finput-charset=UTF-8

如果不指定“ -finput-charset ”， GCC 就会默认 C 程序的编码方式为 UTF-8 ，即使你是以 ANSI 格式保存，也会被当作 UTF-8 来对待。

对于编译出来的可执行程序，可以指定它里面的字符是以什么方式编码，可以使用以下的选项编译器：

-fexec-charset=GB2312
-fexec-charset=UTF-8

如果不指定“-fexec-charset ”， GCC 就会默认编译出的可执行程序中字符的编码方式为 UTF-8 。

如果“-finput-charset ”与“ -fexec-charset ”不一样，编译器会进行格式转换。

3.2.2编码格式实验

test_charset_ansi.c、 test_charset_utf8.c 的编码格式分别为 ANSI 、UTF-8，它们的程序代码是一样的，如下：

#include <stdio.h>
#include <string.h>

int main(int argc, char **argv)
{
	char *str = "A中";
	int i;
	
	printf("str's len = %d\n", (int)strlen(str));
	printf("Hex code: ");
	for (i = 0; i < strlen(str); i++)
	{
		printf("%02x ", (unsigned char)str[i]);
	}
	printf("\n");
	return 0;
}

3.2.2.1 默认编码

book@100ask:~/09_show_chinese$ gcc -o test_charset_ansi test_charset_ansi.c
book@100ask:~/09_show_chinese$ ./test_charset_ansi
str's len = 3
Hex code: 41 d6 d0
book@100ask:~/09_show_chinese$ gcc -o test_charset_utf8 test_charset_utf8.c
book@100ask:~/09_show_chinese$ ./test_charset_utf8
str's len = 4
Hex code: 41 e4 b8 ad

不指定“-finput-charset ”与“ -fexec-charset ”时， input-charset和 exec-charset 默认都是 UTF-8 ，不会进行编码转换。即使 C 文件是 ANSI ，也会被认为是 UTF-8 ，所以不会导致编码转换。

3.2.2.2 GB2312 转为 UTF-8

book@100ask:~/09_show_chinese$ gcc -finput-charset=GB2312 -fexec-charset=UTF-8 -o test_charset_ansi test_charset_ansi.c
book@100ask:~/09_show_chinese$ ./test_charset_ansi str's len = 4 Hex code: 41 e4 b8 ad
book@100ask:~/09_show_chinese$ gcc -finput-charset=GB2312 -fexec-charset=UTF-8 -o test_charset_utf8 test_charset_utf8.c 
cc1: error: failure to convert GB2312 to UTF-8

从上面的输出信息可以看出来，GB2312 的“ 0xd6 0xd0” 可以转换为 UTF-8的“0xe4 0xb8 0xad ”。而如果把原本就是 UTF-8 格式的 test_charset_utf8.c当作 GB2312 格式，会引起错误。

3.2.2.3 UTF-8 转为 GB2312

book@100ask:~/09_show_chinese$ gcc -finput-charset=UTF-8 -fexec-charset=GB2312 -o test_charset_ansi test_charset_ansi.c
test_charset_ansi.c: In function ‘main’:
test_charset_ansi.c:6:14: error: converting to execution character set: Invalid or in complete multibyte or wide character
 char *str = "A▒▒";
 ^~~~~
book@100ask:~/09_show_chinese$ gcc -finput-charset=UTF-8 -fexec-charset=GB2312 -o test_charset_utf8 test_charset_utf8.c
book@100ask:~/09_show_chinese$ ./test_charset_utf8
str's len = 3
Hex code: 41 d6 d0

从上面的输出信息可以看出来，如果把原本就是 GB2312 格式的 test_charset_ansi.c 当作 UTF-8 格式，会引起错误。而 UTF-8 格式的 “ 中 ” 编码值为“0xe4 0xb8 0xad ”，可以转换为 GB2312 的“ 0xd6 0xd0 ”。

在代码中使用汉字这类非 ASCII 码时，要特别留意编码格式。

3.2.3 汉字区位码

我们从网上搜到 HZK16 这个文件，它是常用汉字的 16*16 点阵字库。 HZK16里每个汉字使用 32 字节来描述，如图所示：

跟 ASCII 字库一样，每个字节中每一位用来表示一个像素，位值等于 1 时表示对应像素被点亮，位值等于 0 时表示对应像素被熄灭。

HZK16 中是以 GB2312 编码值来查找点阵的，以“中”字为例，它的编码值是“0xd6 0xd0 ”，其中的 0xd6 表示“区码”，表示在哪一个区：第“0xd6 - 0xa1”区；其中的 0xd0 表示“位码”，表示它是这个区里的哪一个字符：第“ 0xd0 - 0xa1”个。 每一个区有 94 个汉字。区位码从 0xa1 而不是从 0 开始，是为了兼容 ASCII 码。

所以，我们要显示的“中”字，它的 GB2312 编码是 d6d0 ，它是 HZK16 里第“(0xd6-0xa1)*94+(0xd0-0xa1) ”个字符。

3.2.4 汉字点阵显示实现

3.2.4.1 打开汉字库文件

	fd_hzk16 = open("HZK16", O_RDONLY);//打开当前目录的字库文件：HZK16
	if (fd_hzk16 < 0)
	{
		printf("can't open HZK16\n");
		return -1;
	}
	if(fstat(fd_hzk16, &hzk_stat)) //获得文件的状态信息，里面含有文件长度，这在后面的 mmap 中用到
	{
		printf("can't get fstat\n");
		return -1;
	}
    //使用 mmap 映射文件，以后就可以像访问内存一样读取文件内容；mmap 的返回结果保存在 hzkmem 中，它将作为字库的基地址。
	hzkmem = (unsigned char *)mmap(NULL , hzk_stat.st_size, PROT_READ, MAP_SHARED, fd_hzk16, 0);
	if (hzkmem == (unsigned char *)-1)
	{
		printf("can't mmap for hzk16\n");
		return -1;
	}

3.2.4.2 编写显示汉字的函数

核心函数是 void lcd_put_chinese(int x, int y, unsigned char *str)，它在 LCD 的 (x,y) 位置处显示汉字字符 str ， str[0] 中保存区码、 str[1] 中保存位码。

void lcd_put_chinese(int x, int y, unsigned char *str)
{
	unsigned int area  = str[0] - 0xA1; //保存区码：确定该汉字属于哪个区
	unsigned int where = str[1] - 0xA1; //保存位码：确定它是该区中哪一个汉字
    //得到该汉字的点阵起始地址。每个区中有 94 个汉字，每个汉字在字库中占据 32 字节
	unsigned char *dots = hzkmem + (area * 94 + where)*32;
	unsigned char byte;

	int i, j, b;
	for (i = 0; i < 16; i++)//16 行
		for (j = 0; j < 2; j++) //一行有2个字节
		{
			byte = dots[i*2 + j];
            //处理一个字节中的8位,对于每一位它等于 1 时对应的像素被设置为白色，它等于 0 时对应的像素被设置为黑色。
			for (b = 7; b >=0; b--)
			{
				if (byte & (1<<b))
				{
					/* show */
					lcd_put_pixel(x+j*8+7-b, y+i, 0xffffff); /* 白 */
				}
				else
				{
					/* hide */
					lcd_put_pixel(x+j*8+7-b, y+i, 0); /* 黑 */
				}	
			}
		}
}

3.2.4.3 使用 lcd_put_chinese 函数

unsigned char str[] = "中";
printf("chinese code: %02x %02x\n", str[0], str[1]);
lcd_put_chinese(var.xres/2 + 8, var.yres/2, str);

3.2.4.4 使用lcd_put_str 函数显示字符串

void  lcd_put_str(int x, int y, unsigned char *str, int colour)
{
	int i;
	unsigned char str2[2];
	for(i=0; *str != '\0'; i++)
	{
		if(*str >= 0xa1){
			str2[0] = *str;
			str++;
			str2[1] = *str;
			lcd_put_chinese(x+i*8, y, str2, 0xff00ff);
			i++;
		}else{
			lcd_put_ascii(x+i*8, y, *str);
		}
		str++;
	}
}

4. 使用 freetype 显示单个文字

4.1 矢量字体引入

使用点阵字库显示英文字母、汉字时，大小固定，如果放大缩小则会模糊甚至有锯齿出现，为了解决这个问题，引用矢量字体。

矢量字体形成分三步：

第1步确定关键点，

第2步使用数学曲线（贝塞尔曲线）连接头键点，

第3步填充闭合区线内部空间。

什么是关键点？以字母“A”为例，它的的关键点如图中的黄色所示。

再用数学曲线(比如贝塞尔曲线)将关键点都连接起来，得到一系列的封闭的曲线,如图所示：

最后把封闭空间填满颜色，就显示出一个 A 字母，如图所示

如果需要放大或者缩小字体，关键点的相对位置是不变的，只要数学曲线平滑，字体就不会变形。

4.2 Freetype 介绍

Freetype 是开源的字体引擎库，它提供统一的接口来访问多种字体格式文件，从而实现矢量字体显示。我们只需要移植这个字体引擎，调用对应的 API 接口，提供字体文件，就可以让 freetype 库帮我们取出关键点、实现闭合曲线，填充颜色，达到显示矢量字体的目的。

关键点 (glyph) 存在字体文件中， Windows 使用的字体文件在 c:\Windows\Fonts 目录下，扩展名为 TTF 的都是矢量字库，本次使用实验使用的是新宋字体 simsun.ttc。

给定一个字符，怎么在字体文件中找到它的关键点？

首先要确定该字符的编码值：比如 ASCII 码、GB2312 码、UNICODE 码。如果字体文件支持某种编码格式(charset)，就可以使用这类编码值去找到该字符的关键点(glyph)。有些字体文件支持多种编码格式(charset)，这在文件中被称为 charmaps(注意：这个单词是复数，意味着可能支持多种 charset)。

以 simsun.ttc 为例，该字体文件的格如下：头部含有 charmaps，可以使用某种编码值去 charmaps 中找到它对应的关键点。下图中的“A、B、中、国、韦”等只是 glyph 的示意图，表示关键点。

Charmaps 表示字符映射表，字体文件可能支持哪一些编码，GB2312、UNICODE、BIG5 或其他。如果字体文件支持该编码，使用编码值通过 charmap 就可以找到对应的 glyph，一般而言都支持 UNICODE 码。

有了以上基础，一个文字的显示过程可以概括如下：

1.给定一个字符可以确定它的编码值(ASCII、UNICODE、GB2312)；

2.设置字体大小；

3.根据编码值，从文件头部中通过 charmap 找到对应的关键点(glyph)，它会根据字体大小调整关键点；

4.把关键点转换为位图点阵；

5.在 LCD 上显示出来

如何使用 freetype 库，总结出下列步骤：

1.初始化：FT_InitFreetype

2.加载(打开)字体 Face：FT_New_Face

3.设置字体大小：FT_Set_Char_Sizes 或 FT_Set_Pixel_Sizes

4.选择 charmap：FT_Select_Charmap

5.根据编码值 charcode 找到 glyph_index：glyph_index = FT_Get_Char_Index（face，charcode）

6.根据 glyph_index 取出 glyph：FT_Load_Glyph（face，glyph_index）

7.转为位图：FT_Render_Glyph

8.移动或旋转:FT_Set_Transform

9.最后显示出来。

上面的5、6、7可以使用一个函数代替：FT_Load_Char(face, charcode, FT_LOAD_RENDER)，它就可以得到位图。

4.3 在 LCD 上显示一个矢量字体

4.3.1 使用 wchar_t 获得字符的 UNICODE 值

要显示一个字符，首先要确定它的编码值。常用的是 UNICODE 编码，在程序里使用这样的语句定义字符串时，str 中保存的要么是 GB2312 编码值，要么是UTF-8 格式的编码值，即使编译时使用“ -fexec-charset=UTF-8 ”， str 中保存的也不是直接能使用的 UNICODE 值：

char *str = “中”;

如果想在代码中能直接使用 UNICODE 值，需要使用 wchar_t ，宽字符，示例代码如下：

#include <stdio.h>
#include <string.h>
#include <wchar.h>

int main( int argc, char** argv)
{
	wchar_t *chinese_str = L"中gif";
	unsigned int *p = (wchar_t *)chinese_str;
	int i;

	printf("sizeof(wchar_t) = %d, str's Uniocde: \n", (int)sizeof(wchar_t));
	for (i = 0; i < wcslen(chinese_str); i++)
	{
		printf("0x%x ", p[i]);
	}
	printf("\n");

	return 0;
}

UTF-8 格式保存 test_wchar.c ，编译、测试命令如下：

book@100ask:~/10_freetype/01_wchar$ gcc -o test_wchar test_wchar.c
book@100ask:~/10_freetype/01_wchar$ ./test_wchar
sizeof(wchar_t) = 4, str's Uniocde:
0x4e2d 0x67 0x69 0x66

每个 wchar_t 占据 4 字节，可执行程序里 wchar_t 中保存的就是字符的 UNICODE 值。

注意：如果 test_wchar.c 是以 ANSI(GB2312) 格式保存，那么需要使用以下命令来编译：

gcc -finput-charset=GB2312 -fexec-charset=UTF-8 -o test_wchar test_wchar.c

4.3.2 使用 freetype 得到位图

要使用 freetype 得到一个字符的位图，只需要 4 个步骤，代码先贴出来再分析：

	/* 显示矢量字体 */
	error = FT_Init_FreeType( &library );	//初始化 freetype 库 /* initialize library */
	/* error handling omitted */
    //加载字体文件，argv[1]保存字体文件的路径，字体保存在&face 中
	error = FT_New_Face( library, argv[1], 0, &face ); /* create face object */
	/* error handling omitted */	
	slot = face->glyph;//从 face 中获得 FT_GlyphSlot，后面的代码中文字的位图就是保存在 FT_GlyphSlot 里
    //设置字体大小有2个函数，FT_Set_Char_Sizes以1/64个point为单位，FT_Set_Pixel_Sizes以像素为单位
	FT_Set_Pixel_Sizes(face, font_size, 0);//设置字体大小

	/* 确定座标:
	 */
	//pen.x = 0;
	//pen.y = 0;

    /* set transformation *///因为不涉及旋转，不涉及多个文字一起显示，所以不需要调用FT_Set_Transform
    //FT_Set_Transform( face, 0, &pen);

    /* load glyph image into the slot (erase previous one) */
    error = FT_Load_Char( face, chinese_str[0], FT_LOAD_RENDER );//根据编码值得到位图
	if (error)
	{
		printf("FT_Load_Char error\n");
		return -1;
	}

4.3.3 在屏幕上显示位图

draw_bitmap( &slot->bitmap,
                 var.xres/2,
                 var.yres/2);//在屏幕上显示位图

draw_bitmap 函数代码如下，由于位图中每一个像素用一个字节来表示，在0x00RRGGBB 的颜色格式中它只能表示蓝色，所以在 LCD 上显示出来的文字是蓝色的：

draw_bitmap( FT_Bitmap*  bitmap,
             FT_Int      x,
             FT_Int      y)
{
	FT_Int  i, j, p, q;
	FT_Int  x_max = x + bitmap->width;
	FT_Int  y_max = y + bitmap->rows;

	//printf("x = %d, y = %d\n", x, y);

	for ( j = y, q = 0; j < y_max; j++, q++ ) //位图行数
	{
		for ( i = x, p = 0; i < x_max; i++, p++ ) //位图列数
		{
			if ( i < 0      || j < 0       ||
				i >= var.xres || j >= var.yres )
			continue;
            //对于i，j坐标上的像素，在位图找到对应数据作为颜色传给lcd_put_pixel描绘像素颜色
			//image[j][i] |= bitmap->buffer[q * bitmap->width + p];
			lcd_put_pixel(i, j, bitmap->buffer[q * bitmap->width + p]);
		}
	}
}

编译：

arm-buildroot-linux-gnueabihf-gcc -o freetype_show_font freetype_show_font.c -lfreetype

运行：

 ./freetype_show_font ./simsun.ttc 300

./freetype_show_font ./simsun.ttc

4.3.4 在 LCD 上令矢量字体旋转某个角度

关键代码：

1.定义2个变量：角度、矩阵

	FT_Library	  library;
	double		  angle;

2.设置角度值：

angle  = ( 1.0* strtoul(argv[2], NULL, 0) / 360 ) * 3.14159 * 2;	   /* use 25 degrees	 */

3.设置矩阵、变形、加载位图：

	/* set up matrix *///设置矩阵
	matrix.xx = (FT_Fixed)( cos( angle ) * 0x10000L );
	matrix.xy = (FT_Fixed)(-sin( angle ) * 0x10000L );
	matrix.yx = (FT_Fixed)( sin( angle ) * 0x10000L );
	matrix.yy = (FT_Fixed)( cos( angle ) * 0x10000L );

    /* set transformation *///变形
    FT_Set_Transform( face, &matrix, &pen);

    /* load glyph image into the slot (erase previous one) */
    error = FT_Load_Char( face, chinese_str[0], FT_LOAD_RENDER );//得到位图
	if (error)
	{
		printf("FT_Load_Char error\n");
		return -1;
	}

编译：

arm-buildroot-linux-gnueabihf-gcc -o freetype_show_font_angle freetype_show_font_angle.c -lfreetype -lm

运行：

 ./freetype_show_font_angle ./simsun.ttc 90 200

4.4 使用freetype 显示一行文字

4.4.1 笛卡尔坐标系

在 LCD 的坐标系中，原点在屏幕的左上角。对于笛卡尔坐标系，原点在左下角。freetype 使用笛卡尔坐标系，在显示时需要转换为 LCD 坐标系。

从图可知， X 方向坐标值是一样的。

在 Y 方向坐标值需要换算，假设 LCD 的高度是 V 。

在 LCD 坐标系中坐标是 (x, y) ，那么它在笛卡尔坐标系中的坐标值为 (x,V-y)。

反过来也是一样的，在笛卡尔坐标系中坐标是(x, y) ，那么它在 LCD 坐标系中坐标值为(x, V-y) 。

4.4.2 每个字符的大小可能不同

在使用 FT_Set_Pixel_Sizes 函数设置字体大小时，这只是“期望值”。比如“百问网 www.100ask.net ”，如果把“ . ”显示得跟其他汉字一样大，不好看。所以在显示一行文字时，后面文字的位置会受到前面文字的影响。

幸好，freetype 帮我们考虑到了这些影响。

对于 freetype 字体的尺寸 (freetype Metrics) ，需要参考图：

在显示一行文字时，这些文字会基于同一个基线来绘制位图：baseline 。

在 baseline 上，每一个字符都有它的原点 (origin) ，比如上图中 baseline 左边的黑色圆点就是字母“g ”的原点。当前 origin 加上 advance 就可以得到下一个字符的 origin ，比如上图中 baseline 右边的黑色圆点。在显示一行中多个文件字时，后一个文字的原点依赖于前一个文字的原点及 advance 。

字符的位图是有可能越过 baseline 的，比如上图中字母“ g ”在 baseline下方还有图像。

上图中红色方框内就是字母“g ”所点据的位图，它的四个角落不一定与原点重合。

上图中那些 xMin 、 xMax 、 yMin 、 yMax 如何获得？可以使用 FT_Glyph_Get_CBox 函数获得一个字体的这些参数，将会保存在一个 FT_BBox结构体中，以后想计算一行文字的外框时要用到图这些信息：

4.4.3 怎么在指定位置显示一行文字

要显示一行文字时，每一个字符都有自己外框：xMin 、 xMax 、 yMin 、 yMax 。把这些字符的 xMin 、 yMin 中的最小值取出来，把这些字符的 xMax 、 yMax 中的最大值取出来，就可以确定这行文字的外框了。

要想在指定位置(x, y) 显示一行文字，步骤如图所示：

第 1 步先指定第 1 个字符的原点 pen 坐标为 (0, 0) ，计算出它的外框

第 2 步再计算右边字符的原点，也计算出它的外框

把所有字符都处理完后就可以得到一行文字的整体外框：假设外框左上角坐标为(x', y') 。

第 3 步想在 (x, y) 处显示这行文字，调整一下 pen 坐标即可。怎么调整？

pen 为 (0, 0) 时对应左上角 (x', y') ；那么左上角为 (x, y)时就可以算出 pen 为 (x-x', y-y')。

（x',y'）-（0，0）=  (x,y) - (x-x',y-y')
 左上角     pen      左上角    pen

4.4.4 freetype 的几个重要数据结构

要想形象地理解程序，需要先介绍一下 freetype 中几个数据结构：

1 FT_Library

对应 freetype 库，使用 freetype 之前要先调用以下代码：

FT_Library library; /* 对应 freetype 库 */
error = FT_Init_FreeType( &library ); /* 初始化 freetype 库 */

2 FT_Face

它对应一个矢量字体文件，在源码中使用 FT_New_Face 函数打开字体文件后，就可以得到一个 face 。

为什么称之为 face ？

估计是文字都是写在二维平面上的吧，正对着人脸？不用管原因了，总之认为它对应一个字体文件就可以。

代码如下：

error = FT_New_Face(library, font_file, 0, &face ); /* 加载字体文件 */

3 FT_GlyphSlot

插槽？用来保存字符的处理结果：比如转换后的 glyph 、位图，如图

一个 face 中有很多字符，生成一个字符的点阵位图时，位图保存在哪里？

保存在插槽中： face->glyph 。

生成第 1 个字符位图时，它保存在 face->glyph 中；生成第 2 个字符位图时，也会保存在 face->glyph 中，会覆盖第 1 个字符的位图。

代码如下：

FT_GlyphSlot slot = face->glyph; /* 插槽: 字体的处理结果保存在这里 */

4 FT_Glyph

字体文件中保存有字符的原始关键点信息，使用 freetype 的函数可以放大、缩小、旋转，这些新的关键点保存在插槽中( 注意：位图也是保存在插槽中 ) 。

新的关键点使用 FT_Glyph 来表示，可以使用这样的代码从 slot 中获得glyph ：

error = FT_Get_Glyph(slot , &glyph);

5 FT_BBox

FT_BBox 结构体定义如下，它表示一个字符的外框，即新 glyph 的外框：

可以使用以下代码从 glyph 中获得这些信息：

FT_Glyph_Get_CBox(glyph, FT_GLYPH_BBOX_TRUNCATE, &bbox );

针对上述流程，示例代码如下：

    FT_Library	  library; /* 对应freetype库 */
	FT_Face 	  face;    /* 对应字体文件 */
	FT_GlyphSlot  slot;    /* 对应字符的处理结果: 含glyph和位图 */
	FT_Glyph      glyph;   /* 对应字符经过处理后的glyph即外形、轮廓 */
	FT_BBox       bbox;    /* 字符的外框 */
    FT_Vector     pen;     /* 字符的原点 */

	error = FT_Init_FreeType( &library ); /* 初始化freetype库 */
	
	error = FT_New_Face(library, font_file, 0, &face ); /* 加载字体文件 */

	slot = face->glyph; /* 插槽: 字体的处理结果保存在这里 */

	FT_Set_Pixel_Sizes(face, 24, 0); /* 设置大小 */

	/* 确定坐标 */
	pen.x = 0; /* 单位: 1/64 像素 */
	pen.y = 0; /* 单位: 1/64 像素 */

    FT_Set_Transform( face, 0, &pen); /* 变形 */

	/* 根据font_code加载字符, 得到新的glyph和位图, 结果保存在slot中 */
    error = FT_Load_Char(face, font_code, FT_LOAD_RENDER); 

	error = FT_Get_Glyph(slot, &glyph); /* 从slot中得到新的glyph */
		
	FT_Glyph_Get_CBox(glyph, FT_GLYPH_BBOX_TRUNCATE, &bbox ); /* 从glyph中得到字符外框 */
		
    draw_bitmap(&slot->bitmap, lcd_x, lcd_y);  /* 位图也保存在slot->bitmap中 */

4.4.5 计算一行文字的外框

前面提到过，一行文字中：后一个字符的原点= 前一个字符的原点 +advance 。所以要计算一行文字的外框，需要按照排列顺序处理其中的每一个字符。代码如下，注释写得很清楚了：

int compute_string_bbox(FT_Face face, wchar_t *wstr, FT_BBox  *abbox)
{
    int i;
    int error;
    FT_BBox bbox;
    FT_BBox glyph_bbox;
    FT_Vector pen;
    FT_Glyph  glyph;
    FT_GlyphSlot slot = face->glyph;

    /* 初始化 */
    bbox.xMin = bbox.yMin = 32000;
    bbox.xMax = bbox.yMax = -32000;

    /* 指定原点为(0, 0) */
    pen.x = 0;
    pen.y = 0;

    /* 计算每个字符的bounding box */
    /* 先translate, 再load char, 就可以得到它的外框了 */
    for (i = 0; i < wcslen(wstr); i++)
    {
        /* 转换：transformation */
        FT_Set_Transform(face, 0, &pen);

        /* 加载位图: load glyph image into the slot (erase previous one) */
        error = FT_Load_Char(face, wstr[i], FT_LOAD_RENDER);
        if (error)
        {
            printf("FT_Load_Char error\n");
            return -1;
        }

        /* 取出glyph */
        error = FT_Get_Glyph(face->glyph, &glyph);
        if (error)
        {
            printf("FT_Get_Glyph error!\n");
            return -1;
        }
        
        /* 从glyph得到外框: bbox */
        FT_Glyph_Get_CBox(glyph, FT_GLYPH_BBOX_TRUNCATE, &glyph_bbox);

        /* 更新外框 */
        if ( glyph_bbox.xMin < bbox.xMin )
            bbox.xMin = glyph_bbox.xMin;

        if ( glyph_bbox.yMin < bbox.yMin )
            bbox.yMin = glyph_bbox.yMin;

        if ( glyph_bbox.xMax > bbox.xMax )
            bbox.xMax = glyph_bbox.xMax;

        if ( glyph_bbox.yMax > bbox.yMax )
            bbox.yMax = glyph_bbox.yMax;
        
        /* 计算下一个字符的原点: increment pen position */
        pen.x += slot->advance.x;
        pen.y += slot->advance.y;
    }

    /* return string bbox */
    *abbox = bbox;
}

4.4.6 调整原点并绘制

int display_string(FT_Face     face, wchar_t *wstr, int lcd_x, int lcd_y)
{
    int i;
    int error;
    FT_BBox bbox;
    FT_Vector pen;
    FT_Glyph  glyph;
    FT_GlyphSlot slot = face->glyph;

    /* 把LCD坐标转换为笛卡尔坐标 */
    int x = lcd_x;
    int y = var.yres - lcd_y;

    /* 计算外框 */
    compute_string_bbox(face, wstr, &bbox);

    /* 反推原点：外框左上角坐标是（xMin，yMax）所以新origin坐标是（x-xMin， y-yMax） */
    pen.x = (x - bbox.xMin) * 64; /* 单位: 1/64像素 */
    pen.y = (y - bbox.yMax) * 64; /* 单位: 1/64像素 */

    /* 处理每个字符 */
    for (i = 0; i < wcslen(wstr); i++)
    {
        /* 转换：transformation */
        FT_Set_Transform(face, 0, &pen);

        /* 加载位图: load glyph image into the slot (erase previous one) */
        error = FT_Load_Char(face, wstr[i], FT_LOAD_RENDER);
        if (error)
        {
            printf("FT_Load_Char error\n");
            return -1;
        }

        /* 在LCD上绘制: 使用LCD坐标 */
        draw_bitmap( &slot->bitmap,
                        slot->bitmap_left,
                        var.yres - slot->bitmap_top);

        /* 计算下一个字符的原点: increment pen position */
        pen.x += slot->advance.x;
        pen.y += slot->advance.y;
    }

    return 0;
}

编译：

arm-buildroot-linux-gnueabihf-gcc -o show_line show_line.c -lfreetype

运行：

./show_line ./simsun.ttc 10 200 80

4.4.7 main函数

int main(int argc, char **argv)
{
    wchar_t *wstr = L"百问网www.100ask.net";

    FT_Library    library;
    FT_Face       face;
    int error;
    FT_BBox bbox;
    int font_size = 24;
    int lcd_x, lcd_y;

    if (argc < 4)
    {
        printf("Usage : %s <font_file> <lcd_x> <lcd_y> [font_size]\n", argv[0]);
        return -1;
    }

    lcd_x = strtoul(argv[2], NULL, 0);      
    lcd_y = strtoul(argv[3], NULL, 0);      
    
    if (argc == 5)
        font_size = strtoul(argv[4], NULL, 0);      

    fd_fb = open("/dev/fb0", O_RDWR);
    if (fd_fb < 0)
    {
        printf("can't open /dev/fb0\n");
        return -1;
    }

    if (ioctl(fd_fb, FBIOGET_VSCREENINFO, &var))
    {
        printf("can't get var\n");
        return -1;
    }

    if (ioctl(fd_fb, FBIOGET_FSCREENINFO, &fix))
    {
        printf("can't get fix\n");
        return -1;
    }

    line_width  = var.xres * var.bits_per_pixel / 8;
    pixel_width = var.bits_per_pixel / 8;
    screen_size = var.xres * var.yres * var.bits_per_pixel / 8;
    fbmem = (unsigned char *)mmap(NULL , screen_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd_fb, 0);
    if (fbmem == (unsigned char *)-1)
    {
        printf("can't mmap\n");
        return -1;
    }

    /* 清屏: 全部设为黑色 */
    memset(fbmem, 0, screen_size);

    error = FT_Init_FreeType( &library );              /* initialize library */
    
    error = FT_New_Face( library, argv[1], 0, &face ); /* create face object */

    FT_Set_Pixel_Sizes(face, font_size, 0);

    display_string(face, wstr, lcd_x, lcd_y);
    
    return 0;   
}

从入门到捕蛇者说

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
文字的编码

是“American Standard Code for Information Interchange”的缩写，美国信息交换标准代码。电脑毕竟是西方人发明的，他们常用字母就 26 个，区分大小写、加上标点符号也没超过 127 个，每个字符用一个字节来表示就足够了。**一个字节的 7 位就可以表示 128 个数值，在 ASCII 码中最高位永远是 0**。
复制链接

扫一扫