Bitmap.cpp 19 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610
  1. /*
  2. * Copyright (c) 2018-2021, Andreas Kling <kling@serenityos.org>
  3. *
  4. * SPDX-License-Identifier: BSD-2-Clause
  5. */
  6. #include <AK/Checked.h>
  7. #include <AK/LexicalPath.h>
  8. #include <AK/Memory.h>
  9. #include <AK/MemoryStream.h>
  10. #include <AK/Optional.h>
  11. #include <AK/ScopeGuard.h>
  12. #include <AK/String.h>
  13. #include <LibGfx/BMPLoader.h>
  14. #include <LibGfx/Bitmap.h>
  15. #include <LibGfx/DDSLoader.h>
  16. #include <LibGfx/GIFLoader.h>
  17. #include <LibGfx/ICOLoader.h>
  18. #include <LibGfx/JPGLoader.h>
  19. #include <LibGfx/PBMLoader.h>
  20. #include <LibGfx/PGMLoader.h>
  21. #include <LibGfx/PNGLoader.h>
  22. #include <LibGfx/PPMLoader.h>
  23. #include <LibGfx/ShareableBitmap.h>
  24. #include <errno.h>
  25. #include <stdio.h>
  26. #include <sys/mman.h>
  27. namespace Gfx {
  28. struct BackingStore {
  29. void* data { nullptr };
  30. size_t pitch { 0 };
  31. size_t size_in_bytes { 0 };
  32. };
  33. size_t Bitmap::minimum_pitch(size_t physical_width, BitmapFormat format)
  34. {
  35. size_t element_size;
  36. switch (determine_storage_format(format)) {
  37. case StorageFormat::Indexed8:
  38. element_size = 1;
  39. break;
  40. case StorageFormat::BGRx8888:
  41. case StorageFormat::BGRA8888:
  42. case StorageFormat::RGBA8888:
  43. element_size = 4;
  44. break;
  45. default:
  46. VERIFY_NOT_REACHED();
  47. }
  48. return physical_width * element_size;
  49. }
  50. static bool size_would_overflow(BitmapFormat format, const IntSize& size, int scale_factor)
  51. {
  52. if (size.width() < 0 || size.height() < 0)
  53. return true;
  54. // This check is a bit arbitrary, but should protect us from most shenanigans:
  55. if (size.width() >= INT16_MAX || size.height() >= INT16_MAX || scale_factor < 1 || scale_factor > 4)
  56. return true;
  57. // In contrast, this check is absolutely necessary:
  58. size_t pitch = Bitmap::minimum_pitch(size.width() * scale_factor, format);
  59. return Checked<size_t>::multiplication_would_overflow(pitch, size.height() * scale_factor);
  60. }
  61. RefPtr<Bitmap> Bitmap::try_create(BitmapFormat format, const IntSize& size, int scale_factor)
  62. {
  63. auto backing_store = Bitmap::try_allocate_backing_store(format, size, scale_factor);
  64. if (!backing_store.has_value())
  65. return nullptr;
  66. return adopt_ref(*new Bitmap(format, size, scale_factor, backing_store.value()));
  67. }
  68. RefPtr<Bitmap> Bitmap::try_create_shareable(BitmapFormat format, const IntSize& size, int scale_factor)
  69. {
  70. if (size_would_overflow(format, size, scale_factor))
  71. return nullptr;
  72. const auto pitch = minimum_pitch(size.width() * scale_factor, format);
  73. const auto data_size = size_in_bytes(pitch, size.height() * scale_factor);
  74. auto buffer = Core::AnonymousBuffer::create_with_size(round_up_to_power_of_two(data_size, PAGE_SIZE));
  75. if (!buffer.is_valid())
  76. return nullptr;
  77. return Bitmap::try_create_with_anonymous_buffer(format, buffer, size, scale_factor, {});
  78. }
  79. Bitmap::Bitmap(BitmapFormat format, const IntSize& size, int scale_factor, const BackingStore& backing_store)
  80. : m_size(size)
  81. , m_scale(scale_factor)
  82. , m_data(backing_store.data)
  83. , m_pitch(backing_store.pitch)
  84. , m_format(format)
  85. {
  86. VERIFY(!m_size.is_empty());
  87. VERIFY(!size_would_overflow(format, size, scale_factor));
  88. VERIFY(m_data);
  89. VERIFY(backing_store.size_in_bytes == size_in_bytes());
  90. allocate_palette_from_format(format, {});
  91. m_needs_munmap = true;
  92. }
  93. RefPtr<Bitmap> Bitmap::try_create_wrapper(BitmapFormat format, const IntSize& size, int scale_factor, size_t pitch, void* data)
  94. {
  95. if (size_would_overflow(format, size, scale_factor))
  96. return nullptr;
  97. return adopt_ref(*new Bitmap(format, size, scale_factor, pitch, data));
  98. }
  99. RefPtr<Bitmap> Bitmap::try_load_from_file(String const& path, int scale_factor)
  100. {
  101. if (scale_factor > 1 && path.starts_with("/res/")) {
  102. LexicalPath lexical_path { path };
  103. StringBuilder highdpi_icon_path;
  104. highdpi_icon_path.append(lexical_path.dirname());
  105. highdpi_icon_path.append('/');
  106. highdpi_icon_path.append(lexical_path.title());
  107. highdpi_icon_path.appendff("-{}x.", scale_factor);
  108. highdpi_icon_path.append(lexical_path.extension());
  109. RefPtr<Bitmap> bmp;
  110. #define __ENUMERATE_IMAGE_FORMAT(Name, Ext) \
  111. if (path.ends_with(Ext, CaseSensitivity::CaseInsensitive)) \
  112. bmp = load_##Name(highdpi_icon_path.to_string());
  113. ENUMERATE_IMAGE_FORMATS
  114. #undef __ENUMERATE_IMAGE_FORMAT
  115. if (bmp) {
  116. VERIFY(bmp->width() % scale_factor == 0);
  117. VERIFY(bmp->height() % scale_factor == 0);
  118. bmp->m_size.set_width(bmp->width() / scale_factor);
  119. bmp->m_size.set_height(bmp->height() / scale_factor);
  120. bmp->m_scale = scale_factor;
  121. return bmp;
  122. }
  123. }
  124. #define __ENUMERATE_IMAGE_FORMAT(Name, Ext) \
  125. if (path.ends_with(Ext, CaseSensitivity::CaseInsensitive)) \
  126. return load_##Name(path);
  127. ENUMERATE_IMAGE_FORMATS
  128. #undef __ENUMERATE_IMAGE_FORMAT
  129. return nullptr;
  130. }
  131. Bitmap::Bitmap(BitmapFormat format, const IntSize& size, int scale_factor, size_t pitch, void* data)
  132. : m_size(size)
  133. , m_scale(scale_factor)
  134. , m_data(data)
  135. , m_pitch(pitch)
  136. , m_format(format)
  137. {
  138. VERIFY(pitch >= minimum_pitch(size.width() * scale_factor, format));
  139. VERIFY(!size_would_overflow(format, size, scale_factor));
  140. // FIXME: assert that `data` is actually long enough!
  141. allocate_palette_from_format(format, {});
  142. }
  143. static bool check_size(const IntSize& size, int scale_factor, BitmapFormat format, unsigned actual_size)
  144. {
  145. // FIXME: Code duplication of size_in_bytes() and m_pitch
  146. unsigned expected_size_min = Bitmap::minimum_pitch(size.width() * scale_factor, format) * size.height() * scale_factor;
  147. unsigned expected_size_max = round_up_to_power_of_two(expected_size_min, PAGE_SIZE);
  148. if (expected_size_min > actual_size || actual_size > expected_size_max) {
  149. // Getting here is most likely an error.
  150. dbgln("Constructing a shared bitmap for format {} and size {} @ {}x, which demands {} bytes, which rounds up to at most {}.",
  151. static_cast<int>(format),
  152. size,
  153. scale_factor,
  154. expected_size_min,
  155. expected_size_max);
  156. dbgln("However, we were given {} bytes, which is outside this range?! Refusing cowardly.", actual_size);
  157. return false;
  158. }
  159. return true;
  160. }
  161. RefPtr<Bitmap> Bitmap::try_create_with_anonymous_buffer(BitmapFormat format, Core::AnonymousBuffer buffer, const IntSize& size, int scale_factor, const Vector<RGBA32>& palette)
  162. {
  163. if (size_would_overflow(format, size, scale_factor))
  164. return nullptr;
  165. return adopt_ref(*new Bitmap(format, move(buffer), size, scale_factor, palette));
  166. }
  167. /// Read a bitmap as described by:
  168. /// - actual size
  169. /// - width
  170. /// - height
  171. /// - scale_factor
  172. /// - format
  173. /// - palette count
  174. /// - palette data (= palette count * BGRA8888)
  175. /// - image data (= actual size * u8)
  176. RefPtr<Bitmap> Bitmap::try_create_from_serialized_byte_buffer(ByteBuffer&& buffer)
  177. {
  178. InputMemoryStream stream { buffer };
  179. unsigned actual_size;
  180. unsigned width;
  181. unsigned height;
  182. unsigned scale_factor;
  183. BitmapFormat format;
  184. unsigned palette_size;
  185. Vector<RGBA32> palette;
  186. auto read = [&]<typename T>(T& value) {
  187. if (stream.read({ &value, sizeof(T) }) != sizeof(T))
  188. return false;
  189. return true;
  190. };
  191. if (!read(actual_size) || !read(width) || !read(height) || !read(scale_factor) || !read(format) || !read(palette_size))
  192. return nullptr;
  193. if (format > BitmapFormat::BGRA8888 || format < BitmapFormat::Indexed1)
  194. return nullptr;
  195. if (!check_size({ width, height }, scale_factor, format, actual_size))
  196. return {};
  197. palette.ensure_capacity(palette_size);
  198. for (size_t i = 0; i < palette_size; ++i) {
  199. if (!read(palette[i]))
  200. return {};
  201. }
  202. if (stream.remaining() < actual_size)
  203. return {};
  204. auto data = stream.bytes().slice(stream.offset(), actual_size);
  205. auto bitmap = Bitmap::try_create(format, { width, height }, scale_factor);
  206. if (!bitmap)
  207. return {};
  208. bitmap->m_palette = new RGBA32[palette_size];
  209. memcpy(bitmap->m_palette, palette.data(), palette_size * sizeof(RGBA32));
  210. data.copy_to({ bitmap->scanline(0), bitmap->size_in_bytes() });
  211. return bitmap;
  212. }
  213. ByteBuffer Bitmap::serialize_to_byte_buffer() const
  214. {
  215. auto buffer = ByteBuffer::create_uninitialized(5 * sizeof(unsigned) + sizeof(BitmapFormat) + sizeof(RGBA32) * palette_size(m_format) + size_in_bytes());
  216. OutputMemoryStream stream { buffer };
  217. auto write = [&]<typename T>(T value) {
  218. if (stream.write({ &value, sizeof(T) }) != sizeof(T))
  219. return false;
  220. return true;
  221. };
  222. auto palette = palette_to_vector();
  223. if (!write(size_in_bytes()) || !write((unsigned)size().width()) || !write((unsigned)size().height()) || !write((unsigned)scale()) || !write(m_format) || !write((unsigned)palette.size()))
  224. return {};
  225. for (auto& p : palette) {
  226. if (!write(p))
  227. return {};
  228. }
  229. auto size = size_in_bytes();
  230. VERIFY(stream.remaining() == size);
  231. if (stream.write({ scanline(0), size }) != size)
  232. return {};
  233. return buffer;
  234. }
  235. Bitmap::Bitmap(BitmapFormat format, Core::AnonymousBuffer buffer, const IntSize& size, int scale_factor, const Vector<RGBA32>& palette)
  236. : m_size(size)
  237. , m_scale(scale_factor)
  238. , m_data(buffer.data<void>())
  239. , m_pitch(minimum_pitch(size.width() * scale_factor, format))
  240. , m_format(format)
  241. , m_buffer(move(buffer))
  242. {
  243. VERIFY(!is_indexed() || !palette.is_empty());
  244. VERIFY(!size_would_overflow(format, size, scale_factor));
  245. if (is_indexed(m_format))
  246. allocate_palette_from_format(m_format, palette);
  247. }
  248. RefPtr<Gfx::Bitmap> Bitmap::clone() const
  249. {
  250. auto new_bitmap = Bitmap::try_create(format(), size(), scale());
  251. if (!new_bitmap)
  252. return nullptr;
  253. VERIFY(size_in_bytes() == new_bitmap->size_in_bytes());
  254. memcpy(new_bitmap->scanline(0), scanline(0), size_in_bytes());
  255. return new_bitmap;
  256. }
  257. RefPtr<Gfx::Bitmap> Bitmap::rotated(Gfx::RotationDirection rotation_direction) const
  258. {
  259. auto new_bitmap = Gfx::Bitmap::try_create(this->format(), { height(), width() }, scale());
  260. if (!new_bitmap)
  261. return nullptr;
  262. auto w = this->physical_width();
  263. auto h = this->physical_height();
  264. for (int i = 0; i < w; i++) {
  265. for (int j = 0; j < h; j++) {
  266. Color color;
  267. if (rotation_direction == Gfx::RotationDirection::CounterClockwise)
  268. color = this->get_pixel(w - i - 1, j);
  269. else
  270. color = this->get_pixel(i, h - j - 1);
  271. new_bitmap->set_pixel(j, i, color);
  272. }
  273. }
  274. return new_bitmap;
  275. }
  276. RefPtr<Gfx::Bitmap> Bitmap::flipped(Gfx::Orientation orientation) const
  277. {
  278. auto new_bitmap = Gfx::Bitmap::try_create(this->format(), { width(), height() }, scale());
  279. if (!new_bitmap)
  280. return nullptr;
  281. auto w = this->physical_width();
  282. auto h = this->physical_height();
  283. for (int i = 0; i < w; i++) {
  284. for (int j = 0; j < h; j++) {
  285. Color color = this->get_pixel(i, j);
  286. if (orientation == Orientation::Vertical)
  287. new_bitmap->set_pixel(i, h - j - 1, color);
  288. else
  289. new_bitmap->set_pixel(w - i - 1, j, color);
  290. }
  291. }
  292. return new_bitmap;
  293. }
  294. RefPtr<Gfx::Bitmap> Bitmap::scaled(int sx, int sy) const
  295. {
  296. VERIFY(sx >= 0 && sy >= 0);
  297. if (sx == 1 && sy == 1)
  298. return this;
  299. auto new_bitmap = Gfx::Bitmap::try_create(format(), { width() * sx, height() * sy }, scale());
  300. if (!new_bitmap)
  301. return nullptr;
  302. auto old_width = physical_width();
  303. auto old_height = physical_height();
  304. for (int y = 0; y < old_height; y++) {
  305. for (int x = 0; x < old_width; x++) {
  306. auto color = get_pixel(x, y);
  307. auto base_x = x * sx;
  308. auto base_y = y * sy;
  309. for (int new_y = base_y; new_y < base_y + sy; new_y++) {
  310. for (int new_x = base_x; new_x < base_x + sx; new_x++) {
  311. new_bitmap->set_pixel(new_x, new_y, color);
  312. }
  313. }
  314. }
  315. }
  316. return new_bitmap;
  317. }
  318. // http://fourier.eng.hmc.edu/e161/lectures/resize/node3.html
  319. RefPtr<Gfx::Bitmap> Bitmap::scaled(float sx, float sy) const
  320. {
  321. VERIFY(sx >= 0.0f && sy >= 0.0f);
  322. if (floorf(sx) == sx && floorf(sy) == sy)
  323. return scaled(static_cast<int>(sx), static_cast<int>(sy));
  324. int scaled_width = (int)ceilf(sx * (float)width());
  325. int scaled_height = (int)ceilf(sy * (float)height());
  326. auto new_bitmap = Gfx::Bitmap::try_create(format(), { scaled_width, scaled_height }, scale());
  327. if (!new_bitmap)
  328. return nullptr;
  329. auto old_width = physical_width();
  330. auto old_height = physical_height();
  331. auto new_width = new_bitmap->physical_width();
  332. auto new_height = new_bitmap->physical_height();
  333. // The interpolation goes out of bounds on the bottom- and right-most edges.
  334. // We handle those in two specialized loops not only to make them faster, but
  335. // also to avoid four branch checks for every pixel.
  336. for (int y = 0; y < new_height - 1; y++) {
  337. for (int x = 0; x < new_width - 1; x++) {
  338. auto p = static_cast<float>(x) * static_cast<float>(old_width - 1) / static_cast<float>(new_width - 1);
  339. auto q = static_cast<float>(y) * static_cast<float>(old_height - 1) / static_cast<float>(new_height - 1);
  340. int i = floorf(p);
  341. int j = floorf(q);
  342. float u = p - static_cast<float>(i);
  343. float v = q - static_cast<float>(j);
  344. auto a = get_pixel(i, j);
  345. auto b = get_pixel(i + 1, j);
  346. auto c = get_pixel(i, j + 1);
  347. auto d = get_pixel(i + 1, j + 1);
  348. auto e = a.interpolate(b, u);
  349. auto f = c.interpolate(d, u);
  350. auto color = e.interpolate(f, v);
  351. new_bitmap->set_pixel(x, y, color);
  352. }
  353. }
  354. // Bottom strip (excluding last pixel)
  355. auto old_bottom_y = old_height - 1;
  356. auto new_bottom_y = new_height - 1;
  357. for (int x = 0; x < new_width - 1; x++) {
  358. auto p = static_cast<float>(x) * static_cast<float>(old_width - 1) / static_cast<float>(new_width - 1);
  359. int i = floorf(p);
  360. float u = p - static_cast<float>(i);
  361. auto a = get_pixel(i, old_bottom_y);
  362. auto b = get_pixel(i + 1, old_bottom_y);
  363. auto color = a.interpolate(b, u);
  364. new_bitmap->set_pixel(x, new_bottom_y, color);
  365. }
  366. // Right strip (excluding last pixel)
  367. auto old_right_x = old_width - 1;
  368. auto new_right_x = new_width - 1;
  369. for (int y = 0; y < new_height - 1; y++) {
  370. auto q = static_cast<float>(y) * static_cast<float>(old_height - 1) / static_cast<float>(new_height - 1);
  371. int j = floorf(q);
  372. float v = q - static_cast<float>(j);
  373. auto c = get_pixel(old_right_x, j);
  374. auto d = get_pixel(old_right_x, j + 1);
  375. auto color = c.interpolate(d, v);
  376. new_bitmap->set_pixel(new_right_x, y, color);
  377. }
  378. // Bottom-right pixel
  379. new_bitmap->set_pixel(new_width - 1, new_height - 1, get_pixel(physical_width() - 1, physical_height() - 1));
  380. return new_bitmap;
  381. }
  382. RefPtr<Gfx::Bitmap> Bitmap::cropped(Gfx::IntRect crop) const
  383. {
  384. auto new_bitmap = Gfx::Bitmap::try_create(format(), { crop.width(), crop.height() }, 1);
  385. if (!new_bitmap)
  386. return nullptr;
  387. for (int y = 0; y < crop.height(); ++y) {
  388. for (int x = 0; x < crop.width(); ++x) {
  389. int global_x = x + crop.left();
  390. int global_y = y + crop.top();
  391. if (global_x >= physical_width() || global_y >= physical_height() || global_x < 0 || global_y < 0) {
  392. new_bitmap->set_pixel(x, y, Gfx::Color::Black);
  393. } else {
  394. new_bitmap->set_pixel(x, y, get_pixel(global_x, global_y));
  395. }
  396. }
  397. }
  398. return new_bitmap;
  399. }
  400. RefPtr<Bitmap> Bitmap::to_bitmap_backed_by_anonymous_buffer() const
  401. {
  402. if (m_buffer.is_valid())
  403. return *this;
  404. auto buffer = Core::AnonymousBuffer::create_with_size(round_up_to_power_of_two(size_in_bytes(), PAGE_SIZE));
  405. if (!buffer.is_valid())
  406. return nullptr;
  407. auto bitmap = Bitmap::try_create_with_anonymous_buffer(m_format, move(buffer), size(), scale(), palette_to_vector());
  408. if (!bitmap)
  409. return nullptr;
  410. memcpy(bitmap->scanline(0), scanline(0), size_in_bytes());
  411. return bitmap;
  412. }
  413. Bitmap::~Bitmap()
  414. {
  415. if (m_needs_munmap) {
  416. int rc = munmap(m_data, size_in_bytes());
  417. VERIFY(rc == 0);
  418. }
  419. m_data = nullptr;
  420. delete[] m_palette;
  421. }
  422. void Bitmap::set_mmap_name([[maybe_unused]] String const& name)
  423. {
  424. VERIFY(m_needs_munmap);
  425. #ifdef __serenity__
  426. ::set_mmap_name(m_data, size_in_bytes(), name.characters());
  427. #endif
  428. }
  429. void Bitmap::fill(Color color)
  430. {
  431. VERIFY(!is_indexed(m_format));
  432. for (int y = 0; y < physical_height(); ++y) {
  433. auto* scanline = this->scanline(y);
  434. fast_u32_fill(scanline, color.value(), physical_width());
  435. }
  436. }
  437. void Bitmap::set_volatile()
  438. {
  439. if (m_volatile)
  440. return;
  441. #ifdef __serenity__
  442. int rc = madvise(m_data, size_in_bytes(), MADV_SET_VOLATILE);
  443. if (rc < 0) {
  444. perror("madvise(MADV_SET_VOLATILE)");
  445. VERIFY_NOT_REACHED();
  446. }
  447. #endif
  448. m_volatile = true;
  449. }
  450. [[nodiscard]] bool Bitmap::set_nonvolatile(bool& was_purged)
  451. {
  452. if (!m_volatile) {
  453. was_purged = false;
  454. return true;
  455. }
  456. #ifdef __serenity__
  457. int rc = madvise(m_data, size_in_bytes(), MADV_SET_NONVOLATILE);
  458. if (rc < 0) {
  459. if (errno == ENOMEM) {
  460. was_purged = true;
  461. return false;
  462. }
  463. perror("madvise(MADV_SET_NONVOLATILE)");
  464. VERIFY_NOT_REACHED();
  465. }
  466. was_purged = rc != 0;
  467. #endif
  468. m_volatile = false;
  469. return true;
  470. }
  471. ShareableBitmap Bitmap::to_shareable_bitmap() const
  472. {
  473. auto bitmap = to_bitmap_backed_by_anonymous_buffer();
  474. if (!bitmap)
  475. return {};
  476. return ShareableBitmap(*bitmap);
  477. }
  478. Optional<BackingStore> Bitmap::try_allocate_backing_store(BitmapFormat format, IntSize const& size, int scale_factor)
  479. {
  480. if (size_would_overflow(format, size, scale_factor))
  481. return {};
  482. const auto pitch = minimum_pitch(size.width() * scale_factor, format);
  483. const auto data_size_in_bytes = size_in_bytes(pitch, size.height() * scale_factor);
  484. int map_flags = MAP_ANONYMOUS | MAP_PRIVATE;
  485. #ifdef __serenity__
  486. map_flags |= MAP_PURGEABLE;
  487. void* data = mmap_with_name(nullptr, data_size_in_bytes, PROT_READ | PROT_WRITE, map_flags, 0, 0, String::formatted("GraphicsBitmap [{}]", size).characters());
  488. #else
  489. void* data = mmap(nullptr, data_size_in_bytes, PROT_READ | PROT_WRITE, map_flags, 0, 0);
  490. #endif
  491. if (data == MAP_FAILED) {
  492. perror("mmap");
  493. return {};
  494. }
  495. return { { data, pitch, data_size_in_bytes } };
  496. }
  497. void Bitmap::allocate_palette_from_format(BitmapFormat format, const Vector<RGBA32>& source_palette)
  498. {
  499. size_t size = palette_size(format);
  500. if (size == 0)
  501. return;
  502. m_palette = new RGBA32[size];
  503. if (!source_palette.is_empty()) {
  504. VERIFY(source_palette.size() == size);
  505. memcpy(m_palette, source_palette.data(), size * sizeof(RGBA32));
  506. }
  507. }
  508. Vector<RGBA32> Bitmap::palette_to_vector() const
  509. {
  510. Vector<RGBA32> vector;
  511. auto size = palette_size(m_format);
  512. vector.ensure_capacity(size);
  513. for (size_t i = 0; i < size; ++i)
  514. vector.unchecked_append(palette_color(i).value());
  515. return vector;
  516. }
  517. }