From c2f23223a237ad2cfeb8dbaca35efe503e37aa92 Mon Sep 17 00:00:00 2001 From: Guillaume Meunier Date: Thu, 14 Aug 2025 21:03:25 +0200 Subject: [PATCH] Don't trust the file extension when loading icons Fixes #439 --- common/utils/load_icon.cpp | 656 +++++++++++++++----------------- common/utils/load_icon.h | 12 +- server/driver/wivrn_session.cpp | 15 +- 3 files changed, 337 insertions(+), 346 deletions(-) diff --git a/common/utils/load_icon.cpp b/common/utils/load_icon.cpp index 5a3aaffa..390e848f 100644 --- a/common/utils/load_icon.cpp +++ b/common/utils/load_icon.cpp @@ -75,7 +75,7 @@ std::span read(std::span & buffer, size_t count) return value; } -std::vector load_svg(const std::filesystem::path & filename, int size) +std::vector try_load_svg(const std::filesystem::path & filename, int size) { // TODO check if aspect ratio needs to be handled, dpi @@ -111,6 +111,8 @@ std::vector load_svg(const std::filesystem::path & filename, int size GFile_ptr file{g_file_new_for_path(filename.c_str())}; RsvgHandle_ptr handle{rsvg_handle_new_from_gfile_sync(file.get(), RSVG_HANDLE_FLAGS_NONE, nullptr, &error)}; + if (!handle) + throw std::runtime_error{std::string{"Could not open: "} + error->message}; // Create a Cairo image surface and a rendering context for it cairo_surface_t_ptr surface{cairo_image_surface_create(CAIRO_FORMAT_ARGB32, size, size)}; @@ -145,58 +147,49 @@ std::vector load_svg(const std::filesystem::path & filename, int size if (auto status = cairo_surface_write_to_png_stream(surface.get(), cb, &png); status != CAIRO_STATUS_SUCCESS) throw std::runtime_error{std::string{"Could not write output: "} + cairo_status_to_string(status)}; - return png; + return {{size, size, 32, std::move(png)}}; } -// See https://gitlab.gnome.org/GNOME/gimp/-/tree/master/plug-ins/file-ico?ref_type=heads - -struct ico_file_entry -{ - int width; // Width of icon in pixels - int height; // Height of icon in pixels - int bpp; // 1, 4, 8, 16, 24 or 32 bits per pixel - std::span data; -}; - -constexpr int rowstride(int width, int bpp) -{ - int words_per_line = (width * bpp + 31) / 32; - return words_per_line * 4; -} -static_assert(rowstride(1, 1) == 4); -static_assert(rowstride(8, 1) == 4); -static_assert(rowstride(16, 1) == 4); -static_assert(rowstride(32, 1) == 4); -static_assert(rowstride(33, 1) == 8); - -static_assert(rowstride(1, 4) == 4); -static_assert(rowstride(8, 4) == 4); -static_assert(rowstride(16, 4) == 8); -static_assert(rowstride(32, 4) == 16); -static_assert(rowstride(33, 4) == 20); - -static_assert(rowstride(1, 8) == 4); -static_assert(rowstride(8, 8) == 8); -static_assert(rowstride(16, 8) == 16); -static_assert(rowstride(32, 8) == 32); -static_assert(rowstride(33, 8) == 36); - -static_assert(rowstride(1, 24) == 4); -static_assert(rowstride(8, 24) == 24); -static_assert(rowstride(16, 24) == 48); -static_assert(rowstride(32, 24) == 96); -static_assert(rowstride(33, 24) == 100); - -static_assert(rowstride(1, 32) == 4); -static_assert(rowstride(8, 32) == 32); -static_assert(rowstride(16, 32) == 64); -static_assert(rowstride(32, 32) == 128); -static_assert(rowstride(33, 32) == 132); - -std::vector load_ico(const std::filesystem::path & filename, int size, int index = -1) +std::vector try_load_ico(const std::filesystem::path & filename) { const uint32_t ICO_PNG_MAGIC = 0x474e5089; + // See https://gitlab.gnome.org/GNOME/gimp/-/tree/master/plug-ins/file-ico?ref_type=heads + auto rowstride = [](int width, int bpp) { + int words_per_line = (width * bpp + 31) / 32; + return words_per_line * 4; + }; + + static_assert(rowstride(1, 1) == 4); + static_assert(rowstride(8, 1) == 4); + static_assert(rowstride(16, 1) == 4); + static_assert(rowstride(32, 1) == 4); + static_assert(rowstride(33, 1) == 8); + + static_assert(rowstride(1, 4) == 4); + static_assert(rowstride(8, 4) == 4); + static_assert(rowstride(16, 4) == 8); + static_assert(rowstride(32, 4) == 16); + static_assert(rowstride(33, 4) == 20); + + static_assert(rowstride(1, 8) == 4); + static_assert(rowstride(8, 8) == 8); + static_assert(rowstride(16, 8) == 16); + static_assert(rowstride(32, 8) == 32); + static_assert(rowstride(33, 8) == 36); + + static_assert(rowstride(1, 24) == 4); + static_assert(rowstride(8, 24) == 24); + static_assert(rowstride(16, 24) == 48); + static_assert(rowstride(32, 24) == 96); + static_assert(rowstride(33, 24) == 100); + + static_assert(rowstride(1, 32) == 4); + static_assert(rowstride(8, 32) == 32); + static_assert(rowstride(16, 32) == 64); + static_assert(rowstride(32, 32) == 128); + static_assert(rowstride(33, 32) == 132); + auto ico = load_file(filename); std::span header{ico}; @@ -208,338 +201,287 @@ std::vector load_ico(const std::filesystem::path & filename, int size if (reserved != 0 or resource_type != 1) throw std::runtime_error{"Cannot read icon: " + filename.native()}; - std::vector entries; - int max_bpp = 0; + std::vector icons; for (int i = 0; i < icon_count; i++) { - ico_file_entry entry; - entry.width = read(header); - entry.height = read(header); + auto width = read(header); + auto height = read(header); auto num_colors = read(header); auto reserved = read(header); // reserved auto planes = read(header); - entry.bpp = read(header); + auto bpp = read(header); auto size = read(header); auto offset = read(header); if (offset + size > ico.size()) throw std::runtime_error{"Cannot read icon: " + filename.native()}; - entry.data = std::span{ico}.subspan(offset, size); - if (entry.width == 0) - entry.width = 256; - if (entry.height == 0) - entry.height = 256; + auto data = std::span{ico}.subspan(offset, size); if (reserved != 0) throw std::runtime_error{"Cannot read icon: " + filename.native()}; if (planes != 0 and planes != 1) throw std::runtime_error{"Cannot read icon: " + filename.native()}; - entries.push_back(entry); + auto magic = read(data); - max_bpp = std::max(max_bpp, entry.bpp); - } - - const ico_file_entry * best_entry = index >= 0 ? &entries.at(index) : [&]() { - const ico_file_entry * best_entry = nullptr; - - // Look for the smallest multiple of the requested size - int criterion = std::numeric_limits::max(); - - for (const auto & entry: entries) + if (magic == ICO_PNG_MAGIC) { - if (entry.bpp != max_bpp) - continue; + // PNG file + std::vector png_data; - if (entry.width % size != 0 or entry.height % size != 0) - continue; + // The PNG magic has already been consumed, put it back + png_data.insert(png_data.end(), data.begin() - 4, data.end()); - if (std::min(entry.width, entry.height) / size < criterion) + // Check if the PNG is valid + std::vector pixels; + png_image png_ref{ + .version = PNG_IMAGE_VERSION, + .format = PNG_FORMAT_BGRA, + }; + if (not png_image_begin_read_from_memory(&png_ref, png_data.data(), png_data.size())) + continue; + // throw std::runtime_error{"Cannot read icon: " + filename.native()}; + + pixels.resize(PNG_IMAGE_SIZE(png_ref)); + + if (!png_image_finish_read(&png_ref, nullptr, pixels.data(), 0, nullptr)) { - criterion = std::min(entry.width, entry.height); - best_entry = &entry; - } - } - if (best_entry) - return best_entry; - - // No multiple found: pick the largest icon - criterion = 0; - - for (const auto & entry: entries) - { - if (entry.bpp != max_bpp) + png_image_free(&png_ref); continue; - - if (entry.width * entry.height > criterion) - { - criterion = entry.width * entry.height; - best_entry = &entry; + // throw std::runtime_error{"Cannot read icon: " + filename.native()}; } - } - return best_entry; - }(); - if (not best_entry) - return {}; - - auto data = best_entry->data; - auto magic = read(data); - - if (magic == ICO_PNG_MAGIC) - { - // PNG file - std::vector png_data; - - // The PNG magic has already been consumed, put it back - png_data.insert(png_data.end(), data.begin() - 4, data.end()); - - // Check if the PNG is valid - std::vector pixels; - png_image png_ref{ - .version = PNG_IMAGE_VERSION, - .format = PNG_FORMAT_BGRA, - }; - if (not png_image_begin_read_from_memory(&png_ref, png_data.data(), png_data.size())) - throw std::runtime_error{"Cannot read icon: " + filename.native()}; - - pixels.resize(PNG_IMAGE_SIZE(png_ref)); - - if (!png_image_finish_read(&png_ref, nullptr, pixels.data(), 0, nullptr)) - { + // TODO: get bit depth from PNG instead of trusting the ico header + icons.emplace_back(png_ref.width, png_ref.height, bpp, std::move(png_data)); png_image_free(&png_ref); - throw std::runtime_error{"Cannot read icon: " + filename.native()}; } - png_image_free(&png_ref); - - return png_data; - } - else if (magic == 40) - { - auto width = read(data); // Width of image in pixels - auto height = read(data); // Height of image in pixels - auto planes = read(data); // Must be 1 - auto bpp = read(data); // 1, 4, 8, 16, 24, 32 - auto compression = read(data); // Must be 0 for icons - auto image_size = read(data); // Size of image (without this header) - auto x_res = read(data); - auto y_res = read(data); - auto used_colors = read(data); - auto important_colors = read(data); - - if (planes != 1 or compression != 0) - return {}; - - if (bpp != 1 and - bpp != 4 and - bpp != 8 and - bpp != 16 and - bpp != 24 and - bpp != 32) - return {}; - - auto w = width; - auto h = height / 2; - - std::span palette; // BGRX - - if (bpp <= 16) + else if (magic == 40) { - // Load the palette - if (used_colors == 0) - used_colors = 1 << bpp; + auto width = read(data); // Width of image in pixels + auto height = read(data); // Height of image in pixels + auto planes = read(data); // Must be 1 + auto bpp = read(data); // 1, 4, 8, 16, 24, 32 + auto compression = read(data); // Must be 0 for icons + auto image_size = read(data); // Size of image (without this header) + auto x_res = read(data); + auto y_res = read(data); + auto used_colors = read(data); + auto important_colors = read(data); - palette = read(data, used_colors * 4); - } + if (planes != 1 or compression != 0) + return {}; - size_t xor_stride = rowstride(w, bpp); - size_t and_stride = rowstride(w, 1); - size_t dst_stride = 4 * w; + if (bpp != 1 and + bpp != 4 and + bpp != 8 and + bpp != 16 and + bpp != 24 and + bpp != 32) + return {}; - std::span xor_map = read(data, xor_stride * h); - std::span and_map = read(data, and_stride * h); + auto w = width; + auto h = height / 2; - std::vector dest_buffer; - dest_buffer.resize(h * dst_stride); + std::span palette; // BGRX - switch (bpp) - { - case 1: - for (int y = 0; y < h; y++) - { - uint8_t * src_xor_row = xor_map.data() + xor_stride * y; - uint8_t * src_and_row = and_map.data() + and_stride * y; - uint8_t * dst_row = dest_buffer.data() + dst_stride * (h - 1 - y); + if (bpp <= 16) + { + // Load the palette + if (used_colors == 0) + used_colors = 1 << bpp; - for (int x = 0, i = 0; x < w; x++) + palette = read(data, used_colors * 4); + } + + size_t xor_stride = rowstride(w, bpp); + size_t and_stride = rowstride(w, 1); + size_t dst_stride = 4 * w; + + std::span xor_map = read(data, xor_stride * h); + std::span and_map = read(data, and_stride * h); + + std::vector dest_buffer; + dest_buffer.resize(h * dst_stride); + + switch (bpp) + { + case 1: + for (int y = 0; y < h; y++) { - int colour = (src_xor_row[x / 8] >> (7 - (x % 8))) & 0x1; - if (colour >= used_colors) - return {}; + uint8_t * src_xor_row = xor_map.data() + xor_stride * y; + uint8_t * src_and_row = and_map.data() + and_stride * y; + uint8_t * dst_row = dest_buffer.data() + dst_stride * (h - 1 - y); - uint8_t b = palette[4 * colour + 0]; // Blue - uint8_t g = palette[4 * colour + 1]; // Green - uint8_t r = palette[4 * colour + 2]; // Red + for (int x = 0, i = 0; x < w; x++) + { + int colour = (src_xor_row[x / 8] >> (7 - (x % 8))) & 0x1; + if (colour >= used_colors) + return {}; - // Get alpha from AND mask (0: opaque => 0xff, 1: transparent => 0) - uint8_t a = src_and_row[x / 8] & (1 << (7 - x % 8)) ? 0 : 0xff; + uint8_t b = palette[4 * colour + 0]; // Blue + uint8_t g = palette[4 * colour + 1]; // Green + uint8_t r = palette[4 * colour + 2]; // Red - *dst_row++ = b; - *dst_row++ = g; - *dst_row++ = r; - *dst_row++ = a; + // Get alpha from AND mask (0: opaque => 0xff, 1: transparent => 0) + uint8_t a = src_and_row[x / 8] & (1 << (7 - x % 8)) ? 0 : 0xff; + + *dst_row++ = b; + *dst_row++ = g; + *dst_row++ = r; + *dst_row++ = a; + } } - } - break; + break; - case 4: - for (int y = 0; y < h; y++) - { - uint8_t * src_xor_row = xor_map.data() + xor_stride * y; - uint8_t * src_and_row = and_map.data() + and_stride * y; - uint8_t * dst_row = dest_buffer.data() + dst_stride * (h - 1 - y); - - for (int x = 0, i = 0; x < w; x++) + case 4: + for (int y = 0; y < h; y++) { - int colour = (src_xor_row[x / 2] >> (4 - 4 * (x % 2))) & 0xf; - if (colour >= used_colors) - return {}; + uint8_t * src_xor_row = xor_map.data() + xor_stride * y; + uint8_t * src_and_row = and_map.data() + and_stride * y; + uint8_t * dst_row = dest_buffer.data() + dst_stride * (h - 1 - y); - uint8_t b = palette[4 * colour + 0]; // Blue - uint8_t g = palette[4 * colour + 1]; // Green - uint8_t r = palette[4 * colour + 2]; // Red + for (int x = 0, i = 0; x < w; x++) + { + int colour = (src_xor_row[x / 2] >> (4 - 4 * (x % 2))) & 0xf; + if (colour >= used_colors) + return {}; - // Get alpha from AND mask (0: opaque => 0xff, 1: transparent => 0) - uint8_t a = src_and_row[x / 8] & (1 << (7 - x % 8)) ? 0 : 0xff; + uint8_t b = palette[4 * colour + 0]; // Blue + uint8_t g = palette[4 * colour + 1]; // Green + uint8_t r = palette[4 * colour + 2]; // Red - *dst_row++ = b; - *dst_row++ = g; - *dst_row++ = r; - *dst_row++ = a; + // Get alpha from AND mask (0: opaque => 0xff, 1: transparent => 0) + uint8_t a = src_and_row[x / 8] & (1 << (7 - x % 8)) ? 0 : 0xff; + + *dst_row++ = b; + *dst_row++ = g; + *dst_row++ = r; + *dst_row++ = a; + } } - } - break; + break; - case 8: - for (int y = 0; y < h; y++) - { - uint8_t * src_xor_row = xor_map.data() + xor_stride * y; - uint8_t * src_and_row = and_map.data() + and_stride * y; - uint8_t * dst_row = dest_buffer.data() + dst_stride * (h - 1 - y); - - for (int x = 0, i = 0; x < w; x++) + case 8: + for (int y = 0; y < h; y++) { - int colour = *src_xor_row++; - if (colour >= used_colors) - return {}; + uint8_t * src_xor_row = xor_map.data() + xor_stride * y; + uint8_t * src_and_row = and_map.data() + and_stride * y; + uint8_t * dst_row = dest_buffer.data() + dst_stride * (h - 1 - y); - uint8_t b = palette[4 * colour + 0]; // Blue - uint8_t g = palette[4 * colour + 1]; // Green - uint8_t r = palette[4 * colour + 2]; // Red + for (int x = 0, i = 0; x < w; x++) + { + int colour = *src_xor_row++; + if (colour >= used_colors) + return {}; - // Get alpha from AND mask (0: opaque => 0xff, 1: transparent => 0) - uint8_t a = src_and_row[x / 8] & (1 << (7 - x % 8)) ? 0 : 0xff; + uint8_t b = palette[4 * colour + 0]; // Blue + uint8_t g = palette[4 * colour + 1]; // Green + uint8_t r = palette[4 * colour + 2]; // Red - *dst_row++ = b; - *dst_row++ = g; - *dst_row++ = r; - *dst_row++ = a; + // Get alpha from AND mask (0: opaque => 0xff, 1: transparent => 0) + uint8_t a = src_and_row[x / 8] & (1 << (7 - x % 8)) ? 0 : 0xff; + + *dst_row++ = b; + *dst_row++ = g; + *dst_row++ = r; + *dst_row++ = a; + } } - } - break; + break; - case 16: - for (int y = 0; y < h; y++) - { - uint8_t * src_xor_row = xor_map.data() + xor_stride * y; - uint8_t * src_and_row = and_map.data() + and_stride * y; - uint8_t * dst_row = dest_buffer.data() + dst_stride * (h - 1 - y); - - for (int x = 0, i = 0; x < w; x++) + case 16: + for (int y = 0; y < h; y++) { - int colour = (src_xor_row[1] << 8) | src_xor_row[0]; - src_xor_row += 2; + uint8_t * src_xor_row = xor_map.data() + xor_stride * y; + uint8_t * src_and_row = and_map.data() + and_stride * y; + uint8_t * dst_row = dest_buffer.data() + dst_stride * (h - 1 - y); - if (colour >= used_colors) - return {}; + for (int x = 0, i = 0; x < w; x++) + { + int colour = (src_xor_row[1] << 8) | src_xor_row[0]; + src_xor_row += 2; - uint8_t b = palette[4 * colour + 0]; // Blue - uint8_t g = palette[4 * colour + 1]; // Green - uint8_t r = palette[4 * colour + 2]; // Red + if (colour >= used_colors) + return {}; - // Get alpha from AND mask (0: opaque => 0xff, 1: transparent => 0) - uint8_t a = src_and_row[x / 8] & (1 << (7 - x % 8)) ? 0 : 0xff; + uint8_t b = palette[4 * colour + 0]; // Blue + uint8_t g = palette[4 * colour + 1]; // Green + uint8_t r = palette[4 * colour + 2]; // Red - *dst_row++ = b; - *dst_row++ = g; - *dst_row++ = r; - *dst_row++ = a; + // Get alpha from AND mask (0: opaque => 0xff, 1: transparent => 0) + uint8_t a = src_and_row[x / 8] & (1 << (7 - x % 8)) ? 0 : 0xff; + + *dst_row++ = b; + *dst_row++ = g; + *dst_row++ = r; + *dst_row++ = a; + } } - } - break; + break; - case 24: - for (int y = 0; y < h; y++) - { - uint8_t * src_xor_row = xor_map.data() + xor_stride * y; - uint8_t * src_and_row = and_map.data() + and_stride * y; - uint8_t * dst_row = dest_buffer.data() + dst_stride * (h - 1 - y); - - for (int x = 0, i = 0; x < w; x++) + case 24: + for (int y = 0; y < h; y++) { - uint8_t b = *src_xor_row++; // Blue - uint8_t g = *src_xor_row++; // Green - uint8_t r = *src_xor_row++; // Red + uint8_t * src_xor_row = xor_map.data() + xor_stride * y; + uint8_t * src_and_row = and_map.data() + and_stride * y; + uint8_t * dst_row = dest_buffer.data() + dst_stride * (h - 1 - y); - // Get alpha from AND mask (0: opaque => 0xff, 1: transparent => 0) - uint8_t a = src_and_row[x / 8] & (1 << (7 - x % 8)) ? 0 : 0xff; + for (int x = 0, i = 0; x < w; x++) + { + uint8_t b = *src_xor_row++; // Blue + uint8_t g = *src_xor_row++; // Green + uint8_t r = *src_xor_row++; // Red - *dst_row++ = b; - *dst_row++ = g; - *dst_row++ = r; - *dst_row++ = a; + // Get alpha from AND mask (0: opaque => 0xff, 1: transparent => 0) + uint8_t a = src_and_row[x / 8] & (1 << (7 - x % 8)) ? 0 : 0xff; + + *dst_row++ = b; + *dst_row++ = g; + *dst_row++ = r; + *dst_row++ = a; + } } - } - break; + break; - case 32: - for (int y = 0; y < h; y++) - { - uint8_t * src_xor_row = (uint8_t *)xor_map.data() + xor_stride * y; - uint8_t * dst_row = dest_buffer.data() + dst_stride * (h - 1 - y); + case 32: + for (int y = 0; y < h; y++) + { + uint8_t * src_xor_row = (uint8_t *)xor_map.data() + xor_stride * y; + uint8_t * dst_row = dest_buffer.data() + dst_stride * (h - 1 - y); - memcpy(dst_row, src_xor_row, dst_stride); - } - break; - } + memcpy(dst_row, src_xor_row, dst_stride); + } + break; + } - png_image png{ - .version = PNG_IMAGE_VERSION, - .width = w, - .height = h, - .format = PNG_FORMAT_BGRA, - }; + png_image png{ + .version = PNG_IMAGE_VERSION, + .width = w, + .height = h, + .format = PNG_FORMAT_BGRA, + }; - std::vector png_data{65536}; - png_alloc_size_t png_size = png_data.size(); - png_image_write_to_memory(&png, png_data.data(), &png_size, false /* convert_to_8_bit*/, dest_buffer.data(), w * 4, nullptr); - - if (png_size > png_data.size()) - { - png_data.resize(png_size); + std::vector png_data{65536}; + png_alloc_size_t png_size = png_data.size(); png_image_write_to_memory(&png, png_data.data(), &png_size, false /* convert_to_8_bit*/, dest_buffer.data(), w * 4, nullptr); - } - else - png_data.resize(png_size); - return png_data; + if (png_size > png_data.size()) + { + png_data.resize(png_size); + png_image_write_to_memory(&png, png_data.data(), &png_size, false /* convert_to_8_bit*/, dest_buffer.data(), w * 4, nullptr); + } + else + png_data.resize(png_size); + + icons.emplace_back(w, h, bpp, std::move(png_data)); + } } - throw std::runtime_error{"Wrong magic number in " + filename.native()}; + return icons; } -std::vector load_zip(const std::filesystem::path & filename, int size) +std::vector try_load_zip(const std::filesystem::path & filename) { std::unique_ptr zip{archive_read_new(), &archive_read_free}; @@ -550,14 +492,10 @@ std::vector load_zip(const std::filesystem::path & filename, int size throw std::runtime_error{"Cannot open " + filename.native() + ": " + archive_error_string(zip.get())}; archive_entry * entry; - int width = 0; - int height = 0; - std::vector png; + std::vector icons; while (archive_read_next_header(zip.get(), &entry) == ARCHIVE_OK) { - printf("%s\n", archive_entry_pathname(entry)); - std::vector buffer; buffer.resize(archive_entry_size(entry)); @@ -577,10 +515,6 @@ std::vector load_zip(const std::filesystem::path & filename, int size continue; } - // Keep the largest icon only - if (png_ref.width * png_ref.height < width * height) - continue; - pixels.resize(PNG_IMAGE_SIZE(png_ref)); if (!png_image_finish_read(&png_ref, nullptr, pixels.data(), 0, nullptr)) @@ -589,48 +523,86 @@ std::vector load_zip(const std::filesystem::path & filename, int size continue; } - // PNG read successfully: keep it until we find a better one - width = png_ref.width; - height = png_ref.height; - png = std::move(buffer); + // PNG read successfully + icons.emplace_back(png_ref.width, png_ref.height, 32, std::move(buffer)); // TODO: check how to get bit depth png_image_free(&png_ref); } - return png; + return icons; } -std::unordered_map> icon_cache; +std::vector try_load_png(const std::filesystem::path & filename) +{ + auto png_data = load_file(filename); + std::vector icons; + + // Try reading the PNG + std::vector pixels; + png_image png_ref{ + .version = PNG_IMAGE_VERSION, + .format = PNG_FORMAT_BGRA, + }; + + if (not png_image_begin_read_from_memory(&png_ref, png_data.data(), png_data.size())) + { + png_image_free(&png_ref); + throw std::runtime_error(""); + } + + pixels.resize(PNG_IMAGE_SIZE(png_ref)); + + if (!png_image_finish_read(&png_ref, nullptr, pixels.data(), 0, nullptr)) + { + png_image_free(&png_ref); + throw std::runtime_error(""); + } + + // PNG read successfully + icons.emplace_back(png_ref.width, png_ref.height, 32, std::move(png_data)); // TODO: check how to get bit depth + + png_image_free(&png_ref); + + return icons; +} + +std::unordered_map> icon_cache; } // namespace -const std::vector & wivrn::load_icon(const std::filesystem::path & filename, int size) +const std::vector & wivrn::load_icon(const std::filesystem::path & filename) { auto it = icon_cache.find(filename); if (it != icon_cache.end() and not it->second.empty()) return it->second; - std::vector icon; + try + { + return icon_cache.emplace(filename, try_load_svg(filename, 256)).first->second; + } + catch (...) + {} - if (filename.extension() == ".svg") + try { - icon = load_svg(filename, size); - } - else if (filename.extension() == ".ico") - { - // Steam icon (Windows) - icon = load_ico(filename, size); - } - else if (filename.extension() == ".zip") - { - // Steam icon (Linux) - icon = load_zip(filename, size); - } - else - { - // TODO read arbitrary format / rewrite as png - icon = load_file(filename); + return icon_cache.emplace(filename, try_load_ico(filename)).first->second; } + catch (...) + {} - return icon_cache.emplace(filename, std::move(icon)).first->second; + try + { + return icon_cache.emplace(filename, try_load_zip(filename)).first->second; + } + catch (...) + {} + + try + { + return icon_cache.emplace(filename, try_load_png(filename)).first->second; + } + catch (...) + {} + + throw std::runtime_error{"Cannot load icon: " + filename.native()}; } diff --git a/common/utils/load_icon.h b/common/utils/load_icon.h index d89d8fdc..fa93e576 100644 --- a/common/utils/load_icon.h +++ b/common/utils/load_icon.h @@ -23,5 +23,13 @@ namespace wivrn { -const std::vector & load_icon(const std::filesystem::path & filename, int size); -} +struct icon +{ + int width; + int height; + int bpp; + std::vector png_data; +}; + +const std::vector & load_icon(const std::filesystem::path & filename); +} // namespace wivrn diff --git a/server/driver/wivrn_session.cpp b/server/driver/wivrn_session.cpp index dc61dbd4..4652567b 100644 --- a/server/driver/wivrn_session.cpp +++ b/server/driver/wivrn_session.cpp @@ -759,11 +759,22 @@ void wivrn_session::operator()(from_headset::get_application_list && request) { try { - auto icon = load_icon(*app.icon_path, 256); + const auto & icons = load_icon(*app.icon_path); + + if (icons.empty()) + continue; + + const auto & largest_icon = std::ranges::max(icons, [](const wivrn::icon & a, const wivrn::icon & b) { + if (a.bpp < b.bpp) + return true; + if (a.bpp > b.bpp) + return false; + return a.width * a.height < b.width * b.height; + }); send_control(to_headset::application_icon{ .id = id, - .image = std::move(icon), + .image = largest_icon.png_data, }); } catch (std::exception & e)