blob: d74d1c9cba915b2c1bf9d4196c9135997641796d [file] [log] [blame]
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -08001/*
2 * Copyright (C) 2007 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Tao Bao3d0cd1d2018-04-13 13:41:58 -070017#include "private/resources.h"
18
Tao Bao0b1118d2017-01-14 07:46:10 -080019#include <fcntl.h>
20#include <linux/fb.h>
21#include <linux/kd.h>
22#include <stdio.h>
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -080023#include <stdlib.h>
Elliott Hughescd3c55a2015-01-29 20:50:08 -080024#include <string.h>
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -080025#include <sys/ioctl.h>
26#include <sys/mman.h>
27#include <sys/types.h>
Tao Bao0b1118d2017-01-14 07:46:10 -080028#include <unistd.h>
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -080029
Tao Baodd789822018-11-26 16:28:07 -080030#include <limits>
Tianjie Xuacba38c2017-09-27 17:53:34 -070031#include <memory>
Tianjie Xu2078b222017-03-22 12:27:26 -070032#include <regex>
33#include <string>
Yabin Cui4425c1d2016-02-10 13:47:32 -080034#include <vector>
Tao Bao0b1118d2017-01-14 07:46:10 -080035
Tianjie Xu2078b222017-03-22 12:27:26 -070036#include <android-base/strings.h>
Doug Zongker19faefa2009-03-27 17:06:24 -070037#include <png.h>
38
Tao Bao0ecbd762017-01-16 21:16:58 -080039#include "minui/minui.h"
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -080040
Tao Bao6cd81682018-05-03 21:53:11 -070041static std::string g_resource_dir{ "/res/images" };
42
Tao Baodd789822018-11-26 16:28:07 -080043std::unique_ptr<GRSurface> GRSurface::Create(size_t width, size_t height, size_t row_bytes,
44 size_t pixel_bytes) {
45 if (width == 0 || row_bytes == 0 || height == 0 || pixel_bytes == 0) return nullptr;
46 if (std::numeric_limits<size_t>::max() / row_bytes < height) return nullptr;
47
Tao Bao44820ac2018-10-30 23:34:50 -070048 // Cannot use std::make_unique to access non-public ctor.
49 auto result = std::unique_ptr<GRSurface>(new GRSurface(width, height, row_bytes, pixel_bytes));
Tao Baodd789822018-11-26 16:28:07 -080050 size_t data_size = row_bytes * height;
Tao Bao63b59dc2018-10-31 15:23:04 -070051 result->data_size_ =
Tao Bao92bdb5a2018-10-21 12:12:37 -070052 (data_size + kSurfaceDataAlignment - 1) / kSurfaceDataAlignment * kSurfaceDataAlignment;
Tao Bao9cf163e2018-11-07 10:15:50 -080053 result->data_.reset(
54 static_cast<uint8_t*>(aligned_alloc(kSurfaceDataAlignment, result->data_size_)));
55 if (!result->data_) return nullptr;
Tao Bao92bdb5a2018-10-21 12:12:37 -070056 return result;
57}
58
Tao Bao63b59dc2018-10-31 15:23:04 -070059std::unique_ptr<GRSurface> GRSurface::Clone() const {
Tao Baodd789822018-11-26 16:28:07 -080060 auto result = GRSurface::Create(width, height, row_bytes, pixel_bytes);
Tao Bao9cf163e2018-11-07 10:15:50 -080061 if (!result) return nullptr;
62 memcpy(result->data(), data(), data_size_);
Tao Bao63b59dc2018-10-31 15:23:04 -070063 return result;
64}
65
Tao Bao3d0cd1d2018-04-13 13:41:58 -070066PngHandler::PngHandler(const std::string& name) {
Tao Bao6cd81682018-05-03 21:53:11 -070067 std::string res_path = g_resource_dir + "/" + name + ".png";
Tianjie Xuacba38c2017-09-27 17:53:34 -070068 png_fp_.reset(fopen(res_path.c_str(), "rbe"));
Tao Bao3d0cd1d2018-04-13 13:41:58 -070069 // Try to read from |name| if the resource path does not work.
70 if (!png_fp_) {
71 png_fp_.reset(fopen(name.c_str(), "rbe"));
72 }
Tianjie Xuacba38c2017-09-27 17:53:34 -070073 if (!png_fp_) {
74 error_code_ = -1;
75 return;
76 }
Doug Zongker55a36ac2013-03-04 15:49:02 -080077
Tao Bao44820ac2018-10-30 23:34:50 -070078 uint8_t header[8];
Tianjie Xuacba38c2017-09-27 17:53:34 -070079 size_t bytesRead = fread(header, 1, sizeof(header), png_fp_.get());
80 if (bytesRead != sizeof(header)) {
81 error_code_ = -2;
82 return;
83 }
Doug Zongkera418aa72014-03-17 12:10:02 -070084
Tianjie Xuacba38c2017-09-27 17:53:34 -070085 if (png_sig_cmp(header, 0, sizeof(header))) {
86 error_code_ = -3;
87 return;
88 }
89
90 png_ptr_ = png_create_read_struct(PNG_LIBPNG_VER_STRING, nullptr, nullptr, nullptr);
91 if (!png_ptr_) {
92 error_code_ = -4;
93 return;
94 }
95
96 info_ptr_ = png_create_info_struct(png_ptr_);
97 if (!info_ptr_) {
98 error_code_ = -5;
99 return;
100 }
101
102 if (setjmp(png_jmpbuf(png_ptr_))) {
103 error_code_ = -6;
104 return;
105 }
106
107 png_init_io(png_ptr_, png_fp_.get());
108 png_set_sig_bytes(png_ptr_, sizeof(header));
109 png_read_info(png_ptr_, info_ptr_);
110
Tao Bao3d0cd1d2018-04-13 13:41:58 -0700111 png_get_IHDR(png_ptr_, info_ptr_, &width_, &height_, &bit_depth_, &color_type_, nullptr, nullptr,
Tianjie Xuacba38c2017-09-27 17:53:34 -0700112 nullptr);
113
114 channels_ = png_get_channels(png_ptr_, info_ptr_);
115
Tao Bao3d0cd1d2018-04-13 13:41:58 -0700116 if (bit_depth_ == 8 && channels_ == 3 && color_type_ == PNG_COLOR_TYPE_RGB) {
Tianjie Xuacba38c2017-09-27 17:53:34 -0700117 // 8-bit RGB images: great, nothing to do.
Tao Bao3d0cd1d2018-04-13 13:41:58 -0700118 } else if (bit_depth_ <= 8 && channels_ == 1 && color_type_ == PNG_COLOR_TYPE_GRAY) {
Tianjie Xuacba38c2017-09-27 17:53:34 -0700119 // 1-, 2-, 4-, or 8-bit gray images: expand to 8-bit gray.
120 png_set_expand_gray_1_2_4_to_8(png_ptr_);
Tao Bao3d0cd1d2018-04-13 13:41:58 -0700121 } else if (bit_depth_ <= 8 && channels_ == 1 && color_type_ == PNG_COLOR_TYPE_PALETTE) {
Tianjie Xuacba38c2017-09-27 17:53:34 -0700122 // paletted images: expand to 8-bit RGB. Note that we DON'T
123 // currently expand the tRNS chunk (if any) to an alpha
124 // channel, because minui doesn't support alpha channels in
125 // general.
126 png_set_palette_to_rgb(png_ptr_);
127 channels_ = 3;
128 } else {
Tao Bao3d0cd1d2018-04-13 13:41:58 -0700129 fprintf(stderr, "minui doesn't support PNG depth %d channels %d color_type %d\n", bit_depth_,
130 channels_, color_type_);
Tianjie Xuacba38c2017-09-27 17:53:34 -0700131 error_code_ = -7;
132 }
133}
134
135PngHandler::~PngHandler() {
136 if (png_ptr_) {
137 png_destroy_read_struct(&png_ptr_, &info_ptr_, nullptr);
138 }
Doug Zongkera418aa72014-03-17 12:10:02 -0700139}
140
Tao Bao44820ac2018-10-30 23:34:50 -0700141// "display" surfaces are transformed into the framebuffer's required pixel format (currently only
142// RGBX is supported) at load time, so gr_blit() can be nothing more than a memcpy() for each row.
Doug Zongkera418aa72014-03-17 12:10:02 -0700143
Tao Bao44820ac2018-10-30 23:34:50 -0700144// Copies 'input_row' to 'output_row', transforming it to the framebuffer pixel format. The input
145// format depends on the value of 'channels':
Doug Zongkera418aa72014-03-17 12:10:02 -0700146//
147// 1 - input is 8-bit grayscale
148// 3 - input is 24-bit RGB
149// 4 - input is 32-bit RGBA/RGBX
150//
151// 'width' is the number of pixels in the row.
Tao Bao44820ac2018-10-30 23:34:50 -0700152static void TransformRgbToDraw(const uint8_t* input_row, uint8_t* output_row, int channels,
153 int width) {
154 const uint8_t* ip = input_row;
155 uint8_t* op = output_row;
Patrik Torstensson51433b92021-01-30 18:16:25 -0800156 PixelFormat pixel_format = gr_pixel_format();
Doug Zongkera418aa72014-03-17 12:10:02 -0700157
Tao Bao44820ac2018-10-30 23:34:50 -0700158 switch (channels) {
159 case 1:
160 // expand gray level to RGBX
161 for (int x = 0; x < width; ++x) {
Patrik Torstensson51433b92021-01-30 18:16:25 -0800162 if (pixel_format == PixelFormat::RGBA) {
163 *op++ = 0xff;
164 *op++ = *ip;
165 *op++ = *ip;
166 *op++ = *ip;
167 } else {
168 *op++ = *ip;
169 *op++ = *ip;
170 *op++ = *ip;
171 *op++ = 0xff;
172 }
Tao Bao44820ac2018-10-30 23:34:50 -0700173 ip++;
174 }
175 break;
Doug Zongkera418aa72014-03-17 12:10:02 -0700176
Tao Bao44820ac2018-10-30 23:34:50 -0700177 case 3:
Tao Bao44820ac2018-10-30 23:34:50 -0700178 for (int x = 0; x < width; ++x) {
Patrik Torstensson51433b92021-01-30 18:16:25 -0800179 // expand RGBA to RGBX
180 if (pixel_format == PixelFormat::RGBA) {
181 *op++ = 0xff;
182 *op++ = *ip++;
183 *op++ = *ip++;
184 *op++ = *ip++;
185 } else {
186 *op++ = *ip++;
187 *op++ = *ip++;
188 *op++ = *ip++;
189 *op++ = 0xff;
190 }
Tao Bao44820ac2018-10-30 23:34:50 -0700191 }
192 break;
Doug Zongkera418aa72014-03-17 12:10:02 -0700193
Tao Bao44820ac2018-10-30 23:34:50 -0700194 case 4:
Patrik Torstensson51433b92021-01-30 18:16:25 -0800195 if (pixel_format == PixelFormat::RGBA) {
196 for (int x = 0; x < width; ++x) {
197 *op++ = *(ip + 3);
198 *op++ = *ip++;
199 *op++ = *ip++;
200 *op++ = *ip++;
201 ip++;
202 }
203 } else {
204 // copy RGBA to RGBX
205 memcpy(output_row, input_row, width * 4);
206 }
Tao Bao44820ac2018-10-30 23:34:50 -0700207 break;
208 }
Doug Zongkera418aa72014-03-17 12:10:02 -0700209}
210
Elliott Hughes0a5cb0c2015-04-15 10:58:56 -0700211int res_create_display_surface(const char* name, GRSurface** pSurface) {
Tianjie Xuacba38c2017-09-27 17:53:34 -0700212 *pSurface = nullptr;
Doug Zongkera418aa72014-03-17 12:10:02 -0700213
Tianjie Xuacba38c2017-09-27 17:53:34 -0700214 PngHandler png_handler(name);
215 if (!png_handler) return png_handler.error_code();
Doug Zongkera418aa72014-03-17 12:10:02 -0700216
Tianjie Xuacba38c2017-09-27 17:53:34 -0700217 png_structp png_ptr = png_handler.png_ptr();
218 png_uint_32 width = png_handler.width();
219 png_uint_32 height = png_handler.height();
Doug Zongkera418aa72014-03-17 12:10:02 -0700220
Tao Baodd789822018-11-26 16:28:07 -0800221 auto surface = GRSurface::Create(width, height, width * 4, 4);
Tianjie Xuacba38c2017-09-27 17:53:34 -0700222 if (!surface) {
223 return -8;
224 }
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800225
Tao Baoed876a72018-07-31 21:32:50 -0700226 PixelFormat pixel_format = gr_pixel_format();
Adrian Salidocc7b7eb2019-12-12 20:18:09 -0800227 if (pixel_format == PixelFormat::ARGB || pixel_format == PixelFormat::BGRA) {
Tao Baoed876a72018-07-31 21:32:50 -0700228 png_set_bgr(png_ptr);
Patrik Torstensson51433b92021-01-30 18:16:25 -0800229 } else if (pixel_format == PixelFormat::RGBA) {
230 png_set_swap_alpha(png_ptr);
Tao Baoed876a72018-07-31 21:32:50 -0700231 }
Tony Kuofd778e32015-02-05 21:25:56 +0800232
Tianjie Xuacba38c2017-09-27 17:53:34 -0700233 for (png_uint_32 y = 0; y < height; ++y) {
Tao Bao44820ac2018-10-30 23:34:50 -0700234 std::vector<uint8_t> p_row(width * 4);
Tianjie Xuacba38c2017-09-27 17:53:34 -0700235 png_read_row(png_ptr, p_row.data(), nullptr);
Tao Bao44820ac2018-10-30 23:34:50 -0700236 TransformRgbToDraw(p_row.data(), surface->data() + y * surface->row_bytes,
237 png_handler.channels(), width);
Tianjie Xuacba38c2017-09-27 17:53:34 -0700238 }
Doug Zongker19faefa2009-03-27 17:06:24 -0700239
Tao Bao92bdb5a2018-10-21 12:12:37 -0700240 *pSurface = surface.release();
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800241
Tianjie Xuacba38c2017-09-27 17:53:34 -0700242 return 0;
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800243}
244
Tao Baob723f4f2015-12-11 15:18:51 -0800245int res_create_multi_display_surface(const char* name, int* frames, int* fps,
Tianjie Xuacba38c2017-09-27 17:53:34 -0700246 GRSurface*** pSurface) {
247 *pSurface = nullptr;
248 *frames = -1;
Doug Zongker469954f2014-03-07 09:21:25 -0800249
Tianjie Xuacba38c2017-09-27 17:53:34 -0700250 PngHandler png_handler(name);
251 if (!png_handler) return png_handler.error_code();
Doug Zongker469954f2014-03-07 09:21:25 -0800252
Tianjie Xuacba38c2017-09-27 17:53:34 -0700253 png_structp png_ptr = png_handler.png_ptr();
254 png_uint_32 width = png_handler.width();
255 png_uint_32 height = png_handler.height();
Doug Zongker469954f2014-03-07 09:21:25 -0800256
Tianjie Xuacba38c2017-09-27 17:53:34 -0700257 *frames = 1;
258 *fps = 20;
259 png_textp text;
260 int num_text;
261 if (png_get_text(png_ptr, png_handler.info_ptr(), &text, &num_text)) {
262 for (int i = 0; i < num_text; ++i) {
263 if (text[i].key && strcmp(text[i].key, "Frames") == 0 && text[i].text) {
264 *frames = atoi(text[i].text);
265 } else if (text[i].key && strcmp(text[i].key, "FPS") == 0 && text[i].text) {
266 *fps = atoi(text[i].text);
267 }
Tao Baob723f4f2015-12-11 15:18:51 -0800268 }
Tianjie Xuacba38c2017-09-27 17:53:34 -0700269 printf(" found frames = %d\n", *frames);
270 printf(" found fps = %d\n", *fps);
271 }
Tao Baob723f4f2015-12-11 15:18:51 -0800272
Tianjie Xuacba38c2017-09-27 17:53:34 -0700273 int result = 0;
274 GRSurface** surface = nullptr;
275 if (*frames <= 0 || *fps <= 0) {
276 printf("bad number of frames (%d) and/or FPS (%d)\n", *frames, *fps);
277 result = -10;
278 goto exit;
279 }
Doug Zongker469954f2014-03-07 09:21:25 -0800280
Tianjie Xuacba38c2017-09-27 17:53:34 -0700281 if (height % *frames != 0) {
282 printf("bad height (%d) for frame count (%d)\n", height, *frames);
283 result = -9;
284 goto exit;
285 }
Doug Zongker469954f2014-03-07 09:21:25 -0800286
Tianjie Xuacba38c2017-09-27 17:53:34 -0700287 surface = static_cast<GRSurface**>(calloc(*frames, sizeof(GRSurface*)));
288 if (!surface) {
289 result = -8;
290 goto exit;
291 }
292 for (int i = 0; i < *frames; ++i) {
Tao Baodd789822018-11-26 16:28:07 -0800293 auto created_surface = GRSurface::Create(width, height / *frames, width * 4, 4);
Tao Bao92bdb5a2018-10-21 12:12:37 -0700294 if (!created_surface) {
Tianjie Xuacba38c2017-09-27 17:53:34 -0700295 result = -8;
296 goto exit;
Doug Zongker469954f2014-03-07 09:21:25 -0800297 }
Tao Bao92bdb5a2018-10-21 12:12:37 -0700298 surface[i] = created_surface.release();
Tianjie Xuacba38c2017-09-27 17:53:34 -0700299 }
Doug Zongker469954f2014-03-07 09:21:25 -0800300
Adrian Salidocc7b7eb2019-12-12 20:18:09 -0800301 if (gr_pixel_format() == PixelFormat::ARGB || gr_pixel_format() == PixelFormat::BGRA) {
Tao Baoed876a72018-07-31 21:32:50 -0700302 png_set_bgr(png_ptr);
Patrik Torstensson51433b92021-01-30 18:16:25 -0800303 } else if (gr_pixel_format() == PixelFormat::RGBA) {
304 png_set_swap_alpha(png_ptr);
Tao Baoed876a72018-07-31 21:32:50 -0700305 }
Tony Kuofd778e32015-02-05 21:25:56 +0800306
Tianjie Xuacba38c2017-09-27 17:53:34 -0700307 for (png_uint_32 y = 0; y < height; ++y) {
Tao Bao44820ac2018-10-30 23:34:50 -0700308 std::vector<uint8_t> p_row(width * 4);
Tianjie Xuacba38c2017-09-27 17:53:34 -0700309 png_read_row(png_ptr, p_row.data(), nullptr);
310 int frame = y % *frames;
Tao Bao44820ac2018-10-30 23:34:50 -0700311 uint8_t* out_row = surface[frame]->data() + (y / *frames) * surface[frame]->row_bytes;
312 TransformRgbToDraw(p_row.data(), out_row, png_handler.channels(), width);
Tianjie Xuacba38c2017-09-27 17:53:34 -0700313 }
Doug Zongkera418aa72014-03-17 12:10:02 -0700314
Tianjie Xuacba38c2017-09-27 17:53:34 -0700315 *pSurface = surface;
Doug Zongker469954f2014-03-07 09:21:25 -0800316
317exit:
Tianjie Xuacba38c2017-09-27 17:53:34 -0700318 if (result < 0) {
319 if (surface) {
320 for (int i = 0; i < *frames; ++i) {
321 free(surface[i]);
322 }
323 free(surface);
Doug Zongker469954f2014-03-07 09:21:25 -0800324 }
Tianjie Xuacba38c2017-09-27 17:53:34 -0700325 }
326 return result;
Doug Zongker469954f2014-03-07 09:21:25 -0800327}
328
Ethan Yonker534d4e02016-08-26 10:05:03 -0500329int res_create_multi_display_surface(const char* name, int* frames,
330 GRSurface*** pSurface) {
331 int fps = 0;
332 return res_create_multi_display_surface(name, frames, &fps, pSurface);
333}
334
Elliott Hughes0a5cb0c2015-04-15 10:58:56 -0700335int res_create_alpha_surface(const char* name, GRSurface** pSurface) {
Tianjie Xuacba38c2017-09-27 17:53:34 -0700336 *pSurface = nullptr;
Doug Zongkera418aa72014-03-17 12:10:02 -0700337
Tianjie Xuacba38c2017-09-27 17:53:34 -0700338 PngHandler png_handler(name);
339 if (!png_handler) return png_handler.error_code();
Doug Zongkera418aa72014-03-17 12:10:02 -0700340
Tianjie Xuacba38c2017-09-27 17:53:34 -0700341 if (png_handler.channels() != 1) {
342 return -7;
343 }
Doug Zongkera418aa72014-03-17 12:10:02 -0700344
Tianjie Xuacba38c2017-09-27 17:53:34 -0700345 png_structp png_ptr = png_handler.png_ptr();
346 png_uint_32 width = png_handler.width();
347 png_uint_32 height = png_handler.height();
Doug Zongkera418aa72014-03-17 12:10:02 -0700348
Tao Baodd789822018-11-26 16:28:07 -0800349 auto surface = GRSurface::Create(width, height, width, 1);
Tianjie Xuacba38c2017-09-27 17:53:34 -0700350 if (!surface) {
351 return -8;
352 }
Doug Zongkera418aa72014-03-17 12:10:02 -0700353
Tianjie Xuacba38c2017-09-27 17:53:34 -0700354 for (png_uint_32 y = 0; y < height; ++y) {
Tao Bao44820ac2018-10-30 23:34:50 -0700355 uint8_t* p_row = surface->data() + y * surface->row_bytes;
Tianjie Xuacba38c2017-09-27 17:53:34 -0700356 png_read_row(png_ptr, p_row, nullptr);
357 }
Doug Zongkera418aa72014-03-17 12:10:02 -0700358
Tao Bao92bdb5a2018-10-21 12:12:37 -0700359 *pSurface = surface.release();
Doug Zongkera418aa72014-03-17 12:10:02 -0700360
Tianjie Xuacba38c2017-09-27 17:53:34 -0700361 return 0;
Doug Zongkera418aa72014-03-17 12:10:02 -0700362}
363
Tao Bao6cd81682018-05-03 21:53:11 -0700364void res_set_resource_dir(const std::string& dirname) {
365 g_resource_dir = dirname;
366}
367
Tianjie Xu2430e292016-04-19 15:02:41 -0700368// This function tests if a locale string stored in PNG (prefix) matches
369// the locale string provided by the system (locale).
Tianjie Xu2078b222017-03-22 12:27:26 -0700370bool matches_locale(const std::string& prefix, const std::string& locale) {
371 // According to the BCP 47 format, A locale string may consists of:
372 // language-{extlang}-{script}-{region}-{variant}
373 // The locale headers in PNG mostly consist of language-{region} except for sr-Latn, and some
374 // android's system locale can have the format language-{script}-{region}.
Doug Zongker02ec6b82012-08-22 17:26:40 -0700375
Tianjie Xu2078b222017-03-22 12:27:26 -0700376 // Return true if the whole string of prefix matches the top part of locale. Otherwise try to
377 // match the locale string without the {script} section.
378 // For instance, prefix == "en" matches locale == "en-US", prefix == "sr-Latn" matches locale
379 // == "sr-Latn-BA", and prefix == "zh-CN" matches locale == "zh-Hans-CN".
xunchang34723082019-04-22 15:32:17 -0700380 if (prefix.empty()) {
381 return false;
382 }
383
Elliott Hughes1d65c952017-12-20 12:36:31 -0800384 if (android::base::StartsWith(locale, prefix)) {
Tianjie Xu2078b222017-03-22 12:27:26 -0700385 return true;
386 }
Doug Zongker02ec6b82012-08-22 17:26:40 -0700387
Tianjie Xu2078b222017-03-22 12:27:26 -0700388 size_t separator = prefix.find('-');
389 if (separator == std::string::npos) {
390 return false;
391 }
392 std::regex loc_regex(prefix.substr(0, separator) + "-[A-Za-z]*" + prefix.substr(separator));
393 return std::regex_match(locale, loc_regex);
Doug Zongker02ec6b82012-08-22 17:26:40 -0700394}
395
Tianjie Xu29d55752017-09-20 17:53:46 -0700396std::vector<std::string> get_locales_in_png(const std::string& png_name) {
Tianjie Xuacba38c2017-09-27 17:53:34 -0700397 PngHandler png_handler(png_name);
398 if (!png_handler) {
399 printf("Failed to open %s, error: %d\n", png_name.c_str(), png_handler.error_code());
Tianjie Xu29d55752017-09-20 17:53:46 -0700400 return {};
401 }
Tianjie Xuacba38c2017-09-27 17:53:34 -0700402 if (png_handler.channels() != 1) {
403 printf("Expect input png to have 1 data channel, this file has %d\n", png_handler.channels());
Tianjie Xu29d55752017-09-20 17:53:46 -0700404 return {};
405 }
406
407 std::vector<std::string> result;
Tao Bao44820ac2018-10-30 23:34:50 -0700408 std::vector<uint8_t> row(png_handler.width());
Tianjie Xuacba38c2017-09-27 17:53:34 -0700409 for (png_uint_32 y = 0; y < png_handler.height(); ++y) {
410 png_read_row(png_handler.png_ptr(), row.data(), nullptr);
Tianjie Xu29d55752017-09-20 17:53:46 -0700411 int h = (row[3] << 8) | row[2];
412 std::string loc(reinterpret_cast<char*>(&row[5]));
413 if (!loc.empty()) {
414 result.push_back(loc);
415 }
416 for (int i = 0; i < h; ++i, ++y) {
Tianjie Xuacba38c2017-09-27 17:53:34 -0700417 png_read_row(png_handler.png_ptr(), row.data(), nullptr);
Tianjie Xu29d55752017-09-20 17:53:46 -0700418 }
419 }
420
Tianjie Xu29d55752017-09-20 17:53:46 -0700421 return result;
422}
423
Doug Zongkera418aa72014-03-17 12:10:02 -0700424int res_create_localized_alpha_surface(const char* name,
425 const char* locale,
Elliott Hughes0a5cb0c2015-04-15 10:58:56 -0700426 GRSurface** pSurface) {
Tianjie Xuacba38c2017-09-27 17:53:34 -0700427 *pSurface = nullptr;
428 if (locale == nullptr) {
429 return 0;
430 }
Doug Zongker02ec6b82012-08-22 17:26:40 -0700431
Tianjie Xuacba38c2017-09-27 17:53:34 -0700432 PngHandler png_handler(name);
433 if (!png_handler) return png_handler.error_code();
Doug Zongker02ec6b82012-08-22 17:26:40 -0700434
Tianjie Xuacba38c2017-09-27 17:53:34 -0700435 if (png_handler.channels() != 1) {
436 return -7;
437 }
438
439 png_structp png_ptr = png_handler.png_ptr();
440 png_uint_32 width = png_handler.width();
441 png_uint_32 height = png_handler.height();
442
443 for (png_uint_32 y = 0; y < height; ++y) {
Tao Bao44820ac2018-10-30 23:34:50 -0700444 std::vector<uint8_t> row(width);
Tianjie Xuacba38c2017-09-27 17:53:34 -0700445 png_read_row(png_ptr, row.data(), nullptr);
446 int w = (row[1] << 8) | row[0];
447 int h = (row[3] << 8) | row[2];
448 __unused int len = row[4];
449 char* loc = reinterpret_cast<char*>(&row[5]);
450
xunchang9d05c8a2019-04-16 12:07:42 -0700451 // We need to include one additional line for the metadata of the localized image.
452 if (y + 1 + h > height) {
453 printf("Read exceeds the image boundary, y %u, h %d, height %u\n", y, h, height);
454 return -8;
455 }
456
457 if (matches_locale(loc, locale)) {
Tianjie Xuacba38c2017-09-27 17:53:34 -0700458 printf(" %20s: %s (%d x %d @ %d)\n", name, loc, w, h, y);
459
Tao Baodd789822018-11-26 16:28:07 -0800460 auto surface = GRSurface::Create(w, h, w, 1);
Tianjie Xuacba38c2017-09-27 17:53:34 -0700461 if (!surface) {
xunchang9d05c8a2019-04-16 12:07:42 -0700462 return -9;
Tianjie Xuacba38c2017-09-27 17:53:34 -0700463 }
Tianjie Xuacba38c2017-09-27 17:53:34 -0700464
465 for (int i = 0; i < h; ++i, ++y) {
466 png_read_row(png_ptr, row.data(), nullptr);
Tao Bao92bdb5a2018-10-21 12:12:37 -0700467 memcpy(surface->data() + i * w, row.data(), w);
Tianjie Xuacba38c2017-09-27 17:53:34 -0700468 }
469
Tao Bao92bdb5a2018-10-21 12:12:37 -0700470 *pSurface = surface.release();
xunchang9d05c8a2019-04-16 12:07:42 -0700471 return 0;
Doug Zongker02ec6b82012-08-22 17:26:40 -0700472 }
473
Tianjie Xuacba38c2017-09-27 17:53:34 -0700474 for (int i = 0; i < h; ++i, ++y) {
475 png_read_row(png_ptr, row.data(), nullptr);
Doug Zongker02ec6b82012-08-22 17:26:40 -0700476 }
Tianjie Xuacba38c2017-09-27 17:53:34 -0700477 }
Doug Zongker02ec6b82012-08-22 17:26:40 -0700478
xunchang9d05c8a2019-04-16 12:07:42 -0700479 return -10;
Doug Zongker02ec6b82012-08-22 17:26:40 -0700480}
481
Elliott Hughes0a5cb0c2015-04-15 10:58:56 -0700482void res_free_surface(GRSurface* surface) {
lijiazi7d306fb2020-12-23 19:21:06 +0800483 delete(surface);
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800484}