1
struct jpeg_decompress_struct cinfo; //记录着 jpeg 数据的详细信息，也保存着解码之后输出数据的详细信息。
2
struct jpeg_error_mgr jerr; //用于处理错误的对象。

1
#include <stdio.h>
2
#include <stdlib.h>
3
#include <sys/types.h>
4
#include <sys/stat.h>
5
#include <fcntl.h>
6
#include <unistd.h>
7
#include <sys/ioctl.h>
8
#include <string.h>
9
#include <linux/fb.h>
10
#include <sys/mman.h>
11

12
#include <jpeglib.h>
13

14
typedef struct bgr888_color {
15
 unsigned char red;
16
 unsigned char green;
17
 unsigned char blue;
18
} __attribute__ ((packed)) bgr888_t;
19

20
static int width; //LCD X 分辨率
21
static int height; //LCD Y 分辨率
22
static unsigned short *screen_base = NULL; //映射后的显存基地址
23
static unsigned long line_length; //LCD 一行的长度（字节为单位）
24
static unsigned int bpp; //像素深度 bpp
25

26
static int show_jpeg_image(const char *path)
27
{
28
 struct jpeg_decompress_struct cinfo;
29
 struct jpeg_error_mgr jerr;
30
 FILE *jpeg_file = NULL;
31
 bgr888_t *jpeg_line_buf = NULL; //行缓冲区:用于存储从 jpeg 文件中解压出来的一行图像数据
32
 unsigned short *fb_line_buf = NULL; //行缓冲区:用于存储写入到 LCD 显存的一行数据
33
 unsigned int min_h, min_w;
34
 unsigned int valid_bytes;
35
 int i;
36

37
 //绑定默认错误处理函数
38
 cinfo.err = jpeg_std_error(&jerr);
39

40
 //打开.jpeg/.jpg 图像文件
41
 jpeg_file = fopen(path, "r"); //只读方式打开
42
 if (NULL == jpeg_file) {
43
 perror("fopen error");
44
 return -1;
45
 }
46

47
 //创建 JPEG 解码对象
48
 jpeg_create_decompress(&cinfo);
49

50
 //指定图像文件
51
 jpeg_stdio_src(&cinfo, jpeg_file);
52

53
 //读取图像信息
54
 jpeg_read_header(&cinfo, TRUE);
55

56

57
 printf("jpeg 图像大小: %d*%d\n", cinfo.image_width, cinfo.image_height);
58

59
 //设置解码参数
60
 cinfo.out_color_space = JCS_RGB;//默认就是 JCS_RGB
61
 //cinfo.scale_num = 1;
62
 //cinfo.scale_denom = 2;
63

64
 //开始解码图像
65
 jpeg_start_decompress(&cinfo);
66

67
 //为缓冲区分配内存空间
68
 jpeg_line_buf = malloc(cinfo.output_components * cinfo.output_width);
69
 fb_line_buf = malloc(line_length);
70

71
 //判断图像和 LCD 屏那个的分辨率更低
72
 if (cinfo.output_width > width)
73
 min_w = width;
74
 else
75
 min_w = cinfo.output_width;
76

77
 if (cinfo.output_height > height)
78
 min_h = height;
79
 else
80
 min_h = cinfo.output_height;
81

82
 //读取数据
83
 valid_bytes = min_w * bpp / 8;//一行的有效字节数 表示真正写入到 LCD 显存的一行数据的大小
84
 while (cinfo.output_scanline < min_h) {
85

86
 jpeg_read_scanlines(&cinfo, (unsigned char **)&jpeg_line_buf, 1);//每次读取一行数据
87

88
 //将读取到的 BGR888 数据转为 RGB565
89
 for (i = 0; i < min_w; i++)
90
 fb_line_buf[i] = ((jpeg_line_buf[i].red & 0xF8) << 8) |
91
 ((jpeg_line_buf[i].green & 0xFC) << 3) |
92
 ((jpeg_line_buf[i].blue & 0xF8) >> 3);
93

94
 memcpy(screen_base, fb_line_buf, valid_bytes);
95
 screen_base += width;//+width 定位到 LCD 下一行显存地址的起点
96
 }
97

98
 //解码完成
99
 jpeg_finish_decompress(&cinfo); //完成解码
100

101
 jpeg_destroy_decompress(&cinfo);//销毁 JPEG 解码对象、释放资源
102

103
 //关闭文件、释放内存
104
 fclose(jpeg_file);
105
 free(fb_line_buf);
106
 free(jpeg_line_buf);
107
 return 0;
108
}
109

110
int main(int argc, char *argv[])
111
{
112
 struct fb_fix_screeninfo fb_fix;
113
 struct fb_var_screeninfo fb_var;
114
 unsigned int screen_size;
115
 int fd;
116

117
 /* 传参校验 */
118
 if (2 != argc) {
119
 fprintf(stderr, "usage: %s <jpeg_file>\n", argv[0]);
120
 exit(-1);
121
 }
122

123
 /* 打开 framebuffer 设备 */
124
 if (0 > (fd = open("/dev/fb0", O_RDWR))) {
125
 perror("open error");
126
 exit(EXIT_FAILURE);
127
 }
128

129
 /* 获取参数信息 */
130
 ioctl(fd, FBIOGET_VSCREENINFO, &fb_var);
131
 ioctl(fd, FBIOGET_FSCREENINFO, &fb_fix);
132

133
 line_length = fb_fix.line_length;
134
 bpp = fb_var.bits_per_pixel;
135
 screen_size = line_length * fb_var.yres;
136
 width = fb_var.xres;
137
 height = fb_var.yres;
138

139
 /* 将显示缓冲区映射到进程地址空间 */
140
 screen_base = mmap(NULL, screen_size, PROT_WRITE, MAP_SHARED, fd, 0);
141
 if (MAP_FAILED == (void *)screen_base) {
142
 perror("mmap error");
143
 close(fd);
144

145
 exit(EXIT_FAILURE);
146
 }
147

148
 /* 显示 BMP 图片 */
149
 memset(screen_base, 0xFF, screen_size);
150
 show_jpeg_image(argv[1]);
151

152
 /* 退出 */
153
 munmap(screen_base, screen_size); //取消映射
154
 close(fd); //关闭文件
155
 exit(EXIT_SUCCESS); //退出进程
156
}

1
#include <stdio.h>
2
#include <stdlib.h>
3
#include <sys/types.h>
4
#include <sys/stat.h>
5
#include <fcntl.h>
6
#include <unistd.h>
7
#include <sys/ioctl.h>
8
#include <string.h>
9
#include <linux/fb.h>
10
#include <sys/mman.h>
11
#include <png.h>
12

13
static int width; //LCD X 分辨率
14
static int height; //LCD Y 分辨率
15
static unsigned short *screen_base = NULL; //映射后的显存基地址
16
static unsigned long line_length; //LCD 一行的长度（字节为单位）
17
static unsigned int bpp; //像素深度 bpp
18

19
static int show_png_image(const char *path)
20
{
21
 png_structp png_ptr = NULL;
22
 png_infop info_ptr = NULL;
23
 FILE *png_file = NULL;
24
 unsigned short *fb_line_buf = NULL; //行缓冲区:用于存储写入到 LCD 显存的一行数据
25
 unsigned int min_h, min_w;
26
 unsigned int valid_bytes;
27
 unsigned int image_h, image_w;
28
 png_bytepp row_pointers = NULL;
29
 int i, j, k;
30

31
 /* 打开 png 文件 */
32
 png_file = fopen(path, "r"); //以只读方式打开
33
 if (NULL == png_file) {
34
 perror("fopen error");
35
 return -1;
36
 }
37

38
 /* 分配和初始化 png_ptr、info_ptr */
39
 png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
40
 if (!png_ptr) {
41
 fclose(png_file);
42
 return -1;
43
 }
44

45
 info_ptr = png_create_info_struct(png_ptr);
46
 if (!info_ptr) {
47
 png_destroy_read_struct(&png_ptr, NULL, NULL);
48
 fclose(png_file);
49
 return -1;
50
 }
51

52
 /* 设置错误返回点 */
53
 if (setjmp(png_jmpbuf(png_ptr))) {
54
 png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
55
 fclose(png_file);
56
 return -1;
57
 }
58

59
 /* 指定数据源 */
60
 png_init_io(png_ptr, png_file);
61

62
 /* 读取 png 文件 */
63
 png_read_png(png_ptr, info_ptr, PNG_TRANSFORM_STRIP_ALPHA, NULL);
64
 image_h = png_get_image_height(png_ptr, info_ptr);
65
 image_w = png_get_image_width(png_ptr, info_ptr);
66
 printf("分辨率: %d*%d\n", image_w, image_h);
67

68
 /* 判断是不是 RGB888 */
69
 if ((8 != png_get_bit_depth(png_ptr, info_ptr)) &&
70
 (PNG_COLOR_TYPE_RGB != png_get_color_type(png_ptr, info_ptr))) {
71
 printf("Error: Not 8bit depth or not RGB color");
72
 png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
73
 fclose(png_file);
74
 return -1;
75
 }
76

77
 /* 判断图像和 LCD 屏那个的分辨率更低 */
78
 if (image_w > width)
79
 min_w = width;
80
 else
81

82
 min_w = image_w;
83

84
 if (image_h > height)
85
 min_h = height;
86
 else
87
 min_h = image_h;
88

89
 valid_bytes = min_w * bpp / 8;
90

91
 /* 读取解码后的数据 */
92
 fb_line_buf = malloc(valid_bytes);
93
 row_pointers = png_get_rows(png_ptr, info_ptr);//获取数据
94

95
 unsigned int temp = min_w * 3; //RGB888 一个像素 3 个 bit 位
96
 for(i = 0; i < min_h; i++) {
97

98
 // RGB888 转为 RGB565
99
 for(j = k = 0; j < temp; j += 3, k++)
100
 fb_line_buf[k] = ((row_pointers[i][j] & 0xF8) << 8) |
101
 ((row_pointers[i][j+1] & 0xFC) << 3) |
102
 ((row_pointers[i][j+2] & 0xF8) >> 3);
103

104
 memcpy(screen_base, fb_line_buf, valid_bytes);//将一行数据刷入显存
105
 screen_base += width; //定位到显存下一行
106
 }
107

108
 /* 结束、销毁/释放内存 */
109
 png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
110
 free(fb_line_buf);
111
 fclose(png_file);
112
 return 0;
113
}
114

115
int main(int argc, char *argv[])
116
{
117
 struct fb_fix_screeninfo fb_fix;
118
 struct fb_var_screeninfo fb_var;
119
 unsigned int screen_size;
120
 int fd;
121

122
 /* 传参校验 */
123
 if (2 != argc) {
124
 fprintf(stderr, "usage: %s <png_file>\n", argv[0]);
125

126
 exit(-1);
127
 }
128

129
 /* 打开 framebuffer 设备 */
130
 if (0 > (fd = open("/dev/fb0", O_RDWR))) {
131
 perror("open error");
132
 exit(EXIT_FAILURE);
133
 }
134

135
 /* 获取参数信息 */
136
 ioctl(fd, FBIOGET_VSCREENINFO, &fb_var);
137
 ioctl(fd, FBIOGET_FSCREENINFO, &fb_fix);
138

139
 line_length = fb_fix.line_length;
140
 bpp = fb_var.bits_per_pixel;
141
 screen_size = line_length * fb_var.yres;
142
 width = fb_var.xres;
143
 height = fb_var.yres;
144

145
 /* 将显示缓冲区映射到进程地址空间 */
146
 screen_base = mmap(NULL, screen_size, PROT_WRITE, MAP_SHARED, fd, 0);
147
 if (MAP_FAILED == (void *)screen_base) {
148
 perror("mmap error");
149
 close(fd);
150
 exit(EXIT_FAILURE);
151
 }
152

153
 /* 显示 BMP 图片 */
154
 memset(screen_base, 0xFF, screen_size);//屏幕刷白
155
 show_png_image(argv[1]);
156

157
 /* 退出 */
158
 munmap(screen_base, screen_size); //取消映射
159
 close(fd); //关闭文件
160
 exit(EXIT_SUCCESS); //退出进程
161
}

1
#include <stdio.h>
2
#include <stdlib.h>
3
#include <sys/types.h>
4
#include <sys/stat.h>
5
#include <fcntl.h>
6
#include <unistd.h>
7
#include <sys/ioctl.h>
8
#include <string.h>
9
#include <errno.h>
10
#include <sys/mman.h>
11
#include <linux/fb.h>
12
#include <math.h> //数学库函数头文件
13

14
#include <wchar.h>
15
#include <ft2build.h>
16
#include FT_FREETYPE_H
17

18
#define FB_DEV "/dev/fb0" //LCD 设备节点
19

20
#define argb8888_to_rgb565(color) ({ \
21
 unsigned int temp = (color); \
22
 ((temp & 0xF80000UL) >> 8) | \
23
 ((temp & 0xFC00UL) >> 5) | \
24
 ((temp & 0xF8UL) >> 3); \
25
 })
26

27
static unsigned int width; //LCD 宽度
28
static unsigned int height; //LCD 高度
29
static unsigned short *screen_base = NULL;//LCD 显存基地址 RGB565
30
static unsigned long screen_size;
31
static int fd = -1;
32

33
static FT_Library library;
34
static FT_Face face;
35

36
static int fb_dev_init(void)
37

38
{
39
 struct fb_var_screeninfo fb_var = {0};
40
 struct fb_fix_screeninfo fb_fix = {0};
41

42
 /* 打开 framebuffer 设备 */
43
 fd = open(FB_DEV, O_RDWR);
44
 if (0 > fd) {
45
 fprintf(stderr, "open error: %s: %s\n", FB_DEV, strerror(errno));
46
 return -1;
47
 }
48

49
 /* 获取 framebuffer 设备信息 */
50
 ioctl(fd, FBIOGET_VSCREENINFO, &fb_var);
51
 ioctl(fd, FBIOGET_FSCREENINFO, &fb_fix);
52

53
 screen_size = fb_fix.line_length * fb_var.yres;
54
 width = fb_var.xres;
55
 height = fb_var.yres;
56

57
 /* 内存映射 */
58
 screen_base = mmap(NULL, screen_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
59
 if (MAP_FAILED == (void *)screen_base) {
60
 perror("mmap error");
61
 close(fd);
62
 return -1;
63
 }
64

65
 /* LCD 背景刷成黑色 */
66
 memset(screen_base, 0xFF, screen_size);
67
 return 0;
68
}
69

70
static int freetype_init(const char *font, int angle)
71
{
72
 FT_Error error;
73
 FT_Vector pen;
74
 FT_Matrix matrix;
75
 float rad; //旋转角度
76

77
 /* FreeType 初始化 */
78
 FT_Init_FreeType(&library);
79

80
 /* 加载 face 对象 */
81

82
 error = FT_New_Face(library, font, 0, &face);
83
 if (error) {
84
 fprintf(stderr, "FT_New_Face error: %d\n", error);
85
 exit(EXIT_FAILURE);
86
 }
87

88
 /* 原点坐标 */
89
 pen.x = 0 * 64;
90
 pen.y = 0 * 64; //原点设置为(0, 0)
91

92
 /* 2x2 矩阵初始化 */
93
 rad = (1.0 * angle / 180) * M_PI; //（角度转换为弧度）M_PI 是圆周率
94
#if 0 //非水平方向
95
 matrix.xx = (FT_Fixed)( cos(rad) * 0x10000L);
96
 matrix.xy = (FT_Fixed)(-sin(rad) * 0x10000L);
97
 matrix.yx = (FT_Fixed)( sin(rad) * 0x10000L);
98
 matrix.yy = (FT_Fixed)( cos(rad) * 0x10000L);
99
#endif
100

101
#if 1 //斜体 水平方向显示的
102
 matrix.xx = (FT_Fixed)( cos(rad) * 0x10000L);
103
 matrix.xy = (FT_Fixed)( sin(rad) * 0x10000L);
104
 matrix.yx = (FT_Fixed)( 0 * 0x10000L);
105
 matrix.yy = (FT_Fixed)( 1 * 0x10000L);
106
#endif
107

108
 /* 设置 */
109
 FT_Set_Transform(face, &matrix, &pen);
110
 FT_Set_Pixel_Sizes(face, 40, 0); //设置字体大小
111

112
 return 0;
113
}
114

115
static void lcd_draw_character(int x, int y,
116
 const wchar_t *str, unsigned int color)
117
{
118
 unsigned short rgb565_color = argb8888_to_rgb565(color);//得到 RGB565 颜色值
119
 FT_GlyphSlot slot = face->glyph;
120
 size_t len = wcslen(str); //计算字符的个数
121
 long int temp;
122
 int n;
123
 int i, j, p, q;
124
 int max_x, max_y, start_y, start_x;
125

126
 // 循环加载各个字符
127
 for (n = 0; n < len; n++) {
128

129
 // 加载字形、转换得到位图数据
130
 if (FT_Load_Char(face, str[n], FT_LOAD_RENDER))
131
 continue;
132

133
 start_y = y - slot->bitmap_top; //计算字形轮廓上边 y 坐标起点位置 注意是减去 bitmap_top
134
 if (0 > start_y) {//如果为负数 如何处理？？
135
 q = -start_y;
136
 temp = 0;
137
 j = 0;
138
 }
139
 else { // 正数又该如何处理??
140
 q = 0;
141
 temp = width * start_y;
142
 j = start_y;
143
 }
144

145
 max_y = start_y + slot->bitmap.rows;//计算字形轮廓下边 y 坐标结束位置
146
 if (max_y > (int)height)
147
 max_y = height;
148

149
 for (; j < max_y; j++, q++, temp += width) {
150

151
 start_x = x + slot->bitmap_left; //起点位置要加上左边空余部分长度
152
 if (0 > start_x) {
153
 p = -start_x;
154
 i = 0;
155
 }
156
 else {
157
 p = 0;
158
 i = start_x;
159
 }
160

161
 max_x = start_x + slot->bitmap.width;
162
 if (max_x > (int)width)
163
 max_x = width;
164

165
 for (; i < max_x; i++, p++) {
166

167
 // 如果数据不为 0，则表示需要填充颜色
168
 if (slot->bitmap.buffer[q * slot->bitmap.width + p])
169
 screen_base[temp + i] = rgb565_color;
170
 }
171
 }
172

173
 //调整到下一个字形的原点
174
 x += slot->advance.x / 64; //26.6 固定浮点格式
175
 y -= slot->advance.y / 64;
176
 }
177
}
178

179
int main(int argc, char *argv[])
180
{
181

182

183
 /* LCD 初始化 */
184
 if (fb_dev_init())
185
 exit(EXIT_FAILURE);
186

187
 /* freetype 初始化 */
188
 if (freetype_init(argv[1], atoi(argv[2])))
189
 exit(EXIT_FAILURE);
190

191
 /* 在 LCD 上显示中文 */
192
 int y = height * 0.25;
193
 lcd_draw_character(30, 80, L"路漫漫其修远兮，吾将上下而求索", 0x000000);
194
 lcd_draw_character(30, y+80, L"莫愁前路无知己，天下谁人不识君", 0x9900FF);
195
 lcd_draw_character(30, 2*y+80, L"君不见黄河之水天上来，奔流到海不复回", 0xFF0099);
196
 lcd_draw_character(30, 3*y+80, L"君不见高堂明镜悲白发，朝如青丝暮成雪", 0x9932CC);
197

198
 /* 退出程序 */
199
 FT_Done_Face(face);
200
 FT_Done_FreeType(library);
201
 munmap(screen_base, screen_size);
202
 close(fd);
203
 exit(EXIT_SUCCESS);
204
}