beenull/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-22 23:50:19 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6
ladybird/Libraries/LibGfx/BMPLoader.cpp
Ben Wiederhake f2f0c22052 LibGfx: Mark compilation-unit-only functions as static 
This enables a nice warning in case a function becomes dead code.
2020-08-12 20:40:59 +02:00

1315 lines
41 KiB
C++
Raw Blame History

/*
* Copyright (c) 2020, Matthew Olsson <matthewcolsson@gmail.com>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <AK/Function.h>
#include <AK/LexicalPath.h>
#include <AK/MappedFile.h>
#include <LibGfx/BMPLoader.h>
#define BMP_DEBUG 0
#define IF_BMP_DEBUG(x) \
if (BMP_DEBUG) \
x
namespace Gfx {
const u8 bmp_header_size = 14;
const u32 color_palette_limit = 1024;
// Compression flags
struct Compression {
enum : u32 {
RGB = 0,
RLE8,
RLE4,
BITFIELDS,
RLE24, // doubles as JPEG for V4+, but that is unsupported
PNG,
ALPHABITFIELDS,
CMYK = 11,
CMYKRLE8,
CMYKRLE4,
};
};
struct DIBCore {
// u16 for BITMAPHEADERCORE, but i32 for everything else. If the dib type is
// BITMAPHEADERCORE, this is range checked.
i32 width;
i32 height;
u16 bpp;
};
struct DIBInfo {
u32 compression { Compression::RGB };
u32 image_size { 0 };
i32 horizontal_resolution { 0 };
i32 vertical_resolution { 0 };
u32 number_of_palette_colors { 0 };
u32 number_of_important_palette_colors { number_of_palette_colors };
// Introduced in the BITMAPV2INFOHEADER and would ideally be stored in the
// DIBV2 struct, however with a compression value of BI_BITFIELDS or
// BI_ALPHABITFIELDS, these can be specified with the Info header.
Vector<u32> masks;
Vector<i8> mask_shifts;
Vector<u8> mask_sizes;
};
struct DIBOSV2 {
u16 recording;
u16 halftoning;
u16 size1;
u16 size2;
};
template<typename T>
struct Endpoint {
T x;
T y;
T z;
};
struct DIBV4 {
u32 color_space { 0 };
Endpoint<i32> red_endpoint { 0, 0, 0 };
Endpoint<i32> green_endpoint { 0, 0, 0 };
Endpoint<i32> blue_endpoint { 0, 0, 0 };
Endpoint<u32> gamma_endpoint { 0, 0, 0 };
};
struct DIBV5 {
u32 intent { 0 };
u32 profile_data { 0 };
u32 profile_size { 0 };
};
struct DIB {
DIBCore core;
DIBInfo info;
DIBOSV2 osv2;
DIBV4 v4;
DIBV5 v5;
};
enum class DIBType {
Core = 0,
OSV2Short,
OSV2,
Info,
V2,
V3,
V4,
V5
};
struct BMPLoadingContext {
enum class State {
NotDecoded = 0,
HeaderDecoded,
DIBDecoded,
ColorTableDecoded,
PixelDataDecoded,
Error,
};
State state { State::NotDecoded };
const u8* data { nullptr };
size_t data_size { 0 };
u32 data_offset { 0 };
DIB dib;
DIBType dib_type;
Vector<u32> color_table;
RefPtr<Gfx::Bitmap> bitmap;
u8 dib_size() const
{
switch (dib_type) {
case DIBType::Core:
return 12;
case DIBType::OSV2Short:
return 16;
case DIBType::OSV2:
return 64;
case DIBType::Info:
return 40;
case DIBType::V2:
return 52;
case DIBType::V3:
return 56;
case DIBType::V4:
return 108;
case DIBType::V5:
return 124;
}
ASSERT_NOT_REACHED();
}
};
static RefPtr<Bitmap> load_bmp_impl(const u8*, size_t);
RefPtr<Gfx::Bitmap> load_bmp(const StringView& path)
{
MappedFile mapped_file(path);
if (!mapped_file.is_valid())
return nullptr;
auto bitmap = load_bmp_impl((const u8*)mapped_file.data(), mapped_file.size());
if (bitmap)
bitmap->set_mmap_name(String::format("Gfx::Bitmap [%dx%d] - Decoded BMP: %s", bitmap->width(), bitmap->height(), LexicalPath::canonicalized_path(path).characters()));
return bitmap;
}
static const LogStream& operator<<(const LogStream& out, Endpoint<i32> ep)
{
return out << "(" << ep.x << ", " << ep.y << ", " << ep.z << ")";
}
static const LogStream& operator<<(const LogStream& out, Endpoint<u32> ep)
{
return out << "(" << ep.x << ", " << ep.y << ", " << ep.z << ")";
}
class Streamer {
public:
Streamer(const u8* data, size_t size)
: m_data_ptr(data)
, m_size_remaining(size)
{
}
u8 read_u8()
{
ASSERT(m_size_remaining >= 1);
m_size_remaining--;
return *(m_data_ptr++);
}
u16 read_u16()
{
return read_u8() | (read_u8() << 8);
}
u32 read_u24()
{
return read_u8() | (read_u8() << 8) | (read_u8() << 16);
}
i32 read_i32()
{
return static_cast<i32>(read_u16() | (read_u16() << 16));
}
u32 read_u32()
{
return read_u16() | (read_u16() << 16);
}
void drop_bytes(u8 num_bytes)
{
ASSERT(m_size_remaining >= num_bytes);
m_size_remaining -= num_bytes;
m_data_ptr += num_bytes;
}
bool at_end() const { return !m_size_remaining; }
bool has_u8() const { return m_size_remaining >= 1; }
bool has_u16() const { return m_size_remaining >= 2; }
bool has_u24() const { return m_size_remaining >= 3; }
bool has_u32() const { return m_size_remaining >= 4; }
size_t remaining() const { return m_size_remaining; }
void set_remaining(size_t remaining) { m_size_remaining = remaining; }
private:
const u8* m_data_ptr { nullptr };
size_t m_size_remaining { 0 };
};
// Lookup table for distributing all possible 2-bit numbers evenly into 8-bit numbers
static u8 scaling_factors_2bit[4] = {
0x00,
0x55,
0xaa,
0xff,
};
// Lookup table for distributing all possible 3-bit numbers evenly into 8-bit numbers
static u8 scaling_factors_3bit[8] = {
0x00,
0x24,
0x48,
0x6d,
0x91,
0xb6,
0xdb,
0xff,
};
static u8 scale_masked_8bit_number(u8 number, u8 bits_set)
{
// If there are more than 4 bit set, an easy way to scale the number is to
// just copy the most significant bits into the least significant bits
if (bits_set >= 4)
return number | (number >> bits_set);
if (!bits_set)
return 0;
if (bits_set == 1)
return number ? 0xff : 0;
if (bits_set == 2)
return scaling_factors_2bit[number >> 6];
return scaling_factors_3bit[number >> 5];
}
static u8 get_scaled_color(u32 data, u8 mask_size, i8 mask_shift)
{
// A negative mask_shift indicates we actually need to left shift
// the result in order to get out a valid 8-bit color (for example, the blue
// value in an RGB555 encoding is XXXBBBBB, which needs to be shifted to the
// left by 3, hence it would have a "mask_shift" value of -3).
if (mask_shift < 0)
return scale_masked_8bit_number(data << -mask_shift, mask_size);
return scale_masked_8bit_number(data >> mask_shift, mask_size);
}
// Scales an 8-bit number with "mask_size" bits set (and "8 - mask_size" bits
// ignored). This function scales the number appropriately over the entire
// 256 value color spectrum.
// Note that a much simpler scaling can be done by simple bit shifting. If you
// just ignore the bottom 8-mask_size bits, then you get *close*. However,
// consider, as an example, a 5 bit number (so the bottom 3 bits are ignored).
// The purest white you could get is 0xf8, which is 248 in RGB-land. We need
// to scale the values in order to reach the proper value of 255.
static u32 int_to_scaled_rgb(BMPLoadingContext& context, u32 data)
{
u8 r = get_scaled_color(data & context.dib.info.masks[0], context.dib.info.mask_sizes[0], context.dib.info.mask_shifts[0]);
u8 g = get_scaled_color(data & context.dib.info.masks[1], context.dib.info.mask_sizes[1], context.dib.info.mask_shifts[1]);
u8 b = get_scaled_color(data & context.dib.info.masks[2], context.dib.info.mask_sizes[2], context.dib.info.mask_shifts[2]);
u32 color = (r << 16) | (g << 8) | b;
if (context.dib.info.masks.size() == 4) {
// The bitmap has an alpha mask
u8 a = get_scaled_color(data & context.dib.info.masks[3], context.dib.info.mask_sizes[3], context.dib.info.mask_shifts[3]);
color |= (a << 24);
} else {
color |= 0xff000000;
}
return color;
}
static void populate_dib_mask_info(BMPLoadingContext& context)
{
if (context.dib.info.masks.is_empty())
return;
// Mask shift is the number of right shifts needed to align the MSb of the
// mask to the MSb of the LSB.
// Mask size is the number of set bits in the mask. This is required for
// color scaling (for example, ensuring that a 4-bit color value spans the
// entire 256 value color spectrum.
auto& masks = context.dib.info.masks;
auto& mask_shifts = context.dib.info.mask_shifts;
auto& mask_sizes = context.dib.info.mask_sizes;
if (!mask_shifts.is_empty() && !mask_sizes.is_empty())
return;
ASSERT(mask_shifts.is_empty() && mask_sizes.is_empty());
mask_shifts.ensure_capacity(masks.size());
mask_sizes.ensure_capacity(masks.size());
for (size_t i = 0; i < masks.size(); ++i) {
u32 mask = masks[i];
u8 shift = 0;
u8 size = 0;
bool found_set_bit = false;
while (shift <= 32) {
u8 bit = (mask >> shift) & 0x1;
if (found_set_bit)
size++;
if (!found_set_bit && bit) {
found_set_bit = true;
} else if (found_set_bit && !bit) {
break;
}
shift++;
}
if (shift > 32) {
mask_shifts.append(0);
mask_sizes.append(0);
} else {
mask_shifts.append(shift - 8);
mask_sizes.append(size);
}
}
}
static bool check_for_invalid_bitmask_combinations(BMPLoadingContext& context)
{
auto& bpp = context.dib.core.bpp;
auto& compression = context.dib.info.compression;
if (compression == Compression::ALPHABITFIELDS && context.dib_type != DIBType::Info)
return false;
switch (context.dib_type) {
case DIBType::Core:
if (bpp == 2 || bpp == 16 || bpp == 32)
return false;
break;
case DIBType::Info:
if ((compression == Compression::BITFIELDS || compression == Compression::ALPHABITFIELDS) && bpp != 16 && bpp != 32)
return false;
break;
case DIBType::OSV2Short:
case DIBType::OSV2:
case DIBType::V2:
case DIBType::V3:
case DIBType::V4:
case DIBType::V5:
if (compression == Compression::BITFIELDS && bpp != 16 && bpp != 32)
return false;
break;
}
return true;
}
static bool set_dib_bitmasks(BMPLoadingContext& context, Streamer& streamer)
{
if (!check_for_invalid_bitmask_combinations(context))
return false;
auto& bpp = context.dib.core.bpp;
if (bpp <= 8 || bpp == 24)
return true;
auto& compression = context.dib.info.compression;
auto& type = context.dib_type;
if (type > DIBType::OSV2 && bpp == 16 && compression == Compression::RGB) {
context.dib.info.masks.append({ 0x7c00, 0x03e0, 0x001f });
context.dib.info.mask_shifts.append({ 7, 2, -3 });
context.dib.info.mask_sizes.append({ 5, 5, 5 });
populate_dib_mask_info(context);
} else if (type == DIBType::Info && (compression == Compression::BITFIELDS || compression == Compression::ALPHABITFIELDS)) {
// Consume the extra BITFIELDS bytes
auto number_of_mask_fields = compression == Compression::ALPHABITFIELDS ? 4 : 3;
streamer.set_remaining(number_of_mask_fields * 4);
for (auto i = 0; i < number_of_mask_fields; i++)
context.dib.info.masks.append(streamer.read_u32());
populate_dib_mask_info(context);
} else if (type >= DIBType::V2 && compression == Compression::BITFIELDS) {
populate_dib_mask_info(context);
}
return true;
}
static bool decode_bmp_header(BMPLoadingContext& context)
{
if (context.state == BMPLoadingContext::State::Error)
return false;
if (context.state >= BMPLoadingContext::State::HeaderDecoded)
return true;
if (!context.data || context.data_size < bmp_header_size) {
IF_BMP_DEBUG(dbg() << "Missing BMP header");
context.state = BMPLoadingContext::State::Error;
return false;
}
Streamer streamer(context.data, bmp_header_size);
u16 header = streamer.read_u16();
if (header != 0x4d42) {
IF_BMP_DEBUG(dbgprintf("BMP has invalid magic header number: %04x\n", header));
context.state = BMPLoadingContext::State::Error;
return false;
}
// The reported size of the file in the header is actually not important
// for decoding the file. Some specifications say that this value should
// be the size of the header instead, so we just rely on the known file
// size, instead of a possibly-correct-but-also-possibly-incorrect reported
// value of the file size.
streamer.drop_bytes(4);
// Ingore reserved bytes
streamer.drop_bytes(4);
context.data_offset = streamer.read_u32();
context.state = BMPLoadingContext::State::HeaderDecoded;
IF_BMP_DEBUG(dbg() << "BMP data size: " << context.data_size);
IF_BMP_DEBUG(dbg() << "BMP data offset: " << context.data_offset);
return true;
}
static bool decode_bmp_core_dib(BMPLoadingContext& context, Streamer& streamer)
{
auto& core = context.dib.core;
// The width and height are u16 fields in the actual BITMAPCOREHEADER format.
if (context.dib_type == DIBType::Core) {
core.width = streamer.read_u16();
core.height = streamer.read_u16();
} else {
core.width = streamer.read_i32();
core.height = streamer.read_i32();
}
if (core.width < 0) {
IF_BMP_DEBUG(dbg() << "BMP has a negative width: " << core.width);
return false;
}
auto color_planes = streamer.read_u16();
if (color_planes != 1) {
IF_BMP_DEBUG(dbg() << "BMP has an invalid number of color planes: " << color_planes);
return false;
}
core.bpp = streamer.read_u16();
switch (core.bpp) {
case 1:
case 2:
case 4:
case 8:
case 16:
case 24:
case 32:
break;
default:
IF_BMP_DEBUG(dbg() << "BMP has an invalid bpp: " << core.bpp);
context.state = BMPLoadingContext::State::Error;
return false;
}
IF_BMP_DEBUG(dbg() << "BMP width: " << core.width);
IF_BMP_DEBUG(dbg() << "BMP height: " << core.height);
IF_BMP_DEBUG(dbg() << "BMP bits_per_pixel: " << core.bpp);
return true;
}
static bool decode_bmp_osv2_dib(BMPLoadingContext& context, Streamer& streamer, bool short_variant = false)
{
auto& core = context.dib.core;
core.width = streamer.read_u32();
core.height = streamer.read_u32();
if (core.width < 0) {
IF_BMP_DEBUG(dbg() << "BMP has a negative width: " << core.width);
return false;
}
auto color_planes = streamer.read_u16();
if (color_planes != 1) {
IF_BMP_DEBUG(dbg() << "BMP has an invalid number of color planes: " << color_planes);
return false;
}
core.bpp = streamer.read_u16();
IF_BMP_DEBUG(dbg() << "BMP width: " << core.width);
IF_BMP_DEBUG(dbg() << "BMP height: " << core.height);
IF_BMP_DEBUG(dbg() << "BMP bpp: " << core.bpp);
if (short_variant)
return true;
auto& info = context.dib.info;
auto& osv2 = context.dib.osv2;
info.compression = streamer.read_u32();
info.image_size = streamer.read_u32();
info.horizontal_resolution = streamer.read_u32();
info.vertical_resolution = streamer.read_u32();
info.number_of_palette_colors = streamer.read_u32();
info.number_of_important_palette_colors = streamer.read_u32();
if (info.number_of_palette_colors > color_palette_limit || info.number_of_important_palette_colors > color_palette_limit) {
IF_BMP_DEBUG(dbg() << "BMP header indicates too many palette colors: " << info.number_of_palette_colors);
return false;
}
// Units (2) + reserved (2)
streamer.drop_bytes(4);
osv2.recording = streamer.read_u16();
osv2.halftoning = streamer.read_u16();
osv2.size1 = streamer.read_u32();
osv2.size2 = streamer.read_u32();
// ColorEncoding (4) + Identifier (4)
streamer.drop_bytes(8);
IF_BMP_DEBUG(dbg() << "BMP compression: " << info.compression);
IF_BMP_DEBUG(dbg() << "BMP image size: " << info.image_size);
IF_BMP_DEBUG(dbg() << "BMP horizontal res: " << info.horizontal_resolution);
IF_BMP_DEBUG(dbg() << "BMP vertical res: " << info.vertical_resolution);
IF_BMP_DEBUG(dbg() << "BMP colors: " << info.number_of_palette_colors);
IF_BMP_DEBUG(dbg() << "BMP important colors: " << info.number_of_important_palette_colors);
return true;
}
ALWAYS_INLINE static bool is_supported_compression_format(BMPLoadingContext& context, u8 compression)
{
return compression == Compression::RGB || compression == Compression::BITFIELDS
|| compression == Compression::ALPHABITFIELDS || compression == Compression::RLE8
|| compression == Compression::RLE4 || (compression == Compression::RLE24 && context.dib_type <= DIBType::OSV2);
}
static bool decode_bmp_info_dib(BMPLoadingContext& context, Streamer& streamer)
{
if (!decode_bmp_core_dib(context, streamer))
return false;
auto& info = context.dib.info;
auto compression = streamer.read_u32();
info.compression = compression;
if (!is_supported_compression_format(context, compression)) {
IF_BMP_DEBUG(dbg() << "BMP has unsupported compression value: " << compression);
return false;
}
info.image_size = streamer.read_u32();
info.horizontal_resolution = streamer.read_i32();
info.vertical_resolution = streamer.read_i32();
info.number_of_palette_colors = streamer.read_u32();
info.number_of_important_palette_colors = streamer.read_u32();
if (info.number_of_palette_colors > color_palette_limit || info.number_of_important_palette_colors > color_palette_limit) {
IF_BMP_DEBUG(dbg() << "BMP header indicates too many palette colors: " << info.number_of_palette_colors);
return false;
}
if (info.number_of_important_palette_colors == 0)
info.number_of_important_palette_colors = info.number_of_palette_colors;
IF_BMP_DEBUG(dbg() << "BMP compression: " << info.compression);
IF_BMP_DEBUG(dbg() << "BMP image size: " << info.image_size);
IF_BMP_DEBUG(dbg() << "BMP horizontal resolution: " << info.horizontal_resolution);
IF_BMP_DEBUG(dbg() << "BMP vertical resolution: " << info.vertical_resolution);
IF_BMP_DEBUG(dbg() << "BMP palette colors: " << info.number_of_palette_colors);
IF_BMP_DEBUG(dbg() << "BMP important palette colors: " << info.number_of_important_palette_colors);
return true;
}
static bool decode_bmp_v2_dib(BMPLoadingContext& context, Streamer& streamer)
{
if (!decode_bmp_info_dib(context, streamer))
return false;
context.dib.info.masks.append(streamer.read_u32());
context.dib.info.masks.append(streamer.read_u32());
context.dib.info.masks.append(streamer.read_u32());
IF_BMP_DEBUG(dbgprintf("BMP red mask: %08x\n", context.dib.info.masks[0]));
IF_BMP_DEBUG(dbgprintf("BMP green mask: %08x\n", context.dib.info.masks[1]));
IF_BMP_DEBUG(dbgprintf("BMP blue mask: %08x\n", context.dib.info.masks[2]));
return true;
}
static bool decode_bmp_v3_dib(BMPLoadingContext& context, Streamer& streamer)
{
if (!decode_bmp_v2_dib(context, streamer))
return false;
// There is zero documentation about when alpha masks actually get applied.
// Well, there's some, but it's not even close to comprehensive. So, this is
// in no way based off of any spec, it's simply based off of the BMP test
// suite results.
if (context.dib.info.compression == Compression::ALPHABITFIELDS) {
context.dib.info.masks.append(streamer.read_u32());
IF_BMP_DEBUG(dbgprintf("BMP alpha mask: %08x\n", context.dib.info.masks[3]));
} else if (context.dib_size() >= 56 && context.dib.core.bpp >= 16) {
auto mask = streamer.read_u32();
if ((context.dib.core.bpp == 32 && mask != 0) || context.dib.core.bpp == 16) {
context.dib.info.masks.append(mask);
IF_BMP_DEBUG(dbgprintf("BMP alpha mask: %08x\n", mask));
}
} else {
streamer.drop_bytes(4);
}
return true;
}
static bool decode_bmp_v4_dib(BMPLoadingContext& context, Streamer& streamer)
{
if (!decode_bmp_v3_dib(context, streamer))
return false;
auto& v4 = context.dib.v4;
v4.color_space = streamer.read_u32();
v4.red_endpoint = { streamer.read_i32(), streamer.read_i32(), streamer.read_i32() };
v4.green_endpoint = { streamer.read_i32(), streamer.read_i32(), streamer.read_i32() };
v4.blue_endpoint = { streamer.read_i32(), streamer.read_i32(), streamer.read_i32() };
v4.gamma_endpoint = { streamer.read_u32(), streamer.read_u32(), streamer.read_u32() };
IF_BMP_DEBUG(dbg() << "BMP color space: " << v4.color_space);
IF_BMP_DEBUG(dbg() << "BMP red endpoint: " << v4.red_endpoint);
IF_BMP_DEBUG(dbg() << "BMP green endpoint: " << v4.green_endpoint);
IF_BMP_DEBUG(dbg() << "BMP blue endpoint: " << v4.blue_endpoint);
IF_BMP_DEBUG(dbg() << "BMP gamma endpoint: " << v4.gamma_endpoint);
return true;
}
static bool decode_bmp_v5_dib(BMPLoadingContext& context, Streamer& streamer)
{
if (!decode_bmp_v4_dib(context, streamer))
return false;
auto& v5 = context.dib.v5;
v5.intent = streamer.read_u32();
v5.profile_data = streamer.read_u32();
v5.profile_size = streamer.read_u32();
IF_BMP_DEBUG(dbg() << "BMP intent: " << v5.intent);
IF_BMP_DEBUG(dbg() << "BMP profile data: " << v5.profile_data);
IF_BMP_DEBUG(dbg() << "BMP profile size: " << v5.profile_size);
return true;
}
static bool decode_bmp_dib(BMPLoadingContext& context)
{
if (context.state == BMPLoadingContext::State::Error)
return false;
if (context.state >= BMPLoadingContext::State::DIBDecoded)
return true;
if (context.state < BMPLoadingContext::State::HeaderDecoded && !decode_bmp_header(context))
return false;
if (context.data_size < bmp_header_size + 4)
return false;
Streamer streamer(context.data + bmp_header_size, 4);
u32 dib_size = streamer.read_u32();
if (context.data_size < bmp_header_size + dib_size)
return false;
streamer.set_remaining(dib_size - 4);
IF_BMP_DEBUG(dbg() << "BMP dib size: " << dib_size);
bool error = false;
if (dib_size == 12) {
context.dib_type = DIBType::Core;
if (!decode_bmp_core_dib(context, streamer))
error = true;
} else if (dib_size == 64) {
context.dib_type = DIBType::OSV2;
if (!decode_bmp_osv2_dib(context, streamer))
error = true;
} else if (dib_size == 16) {
context.dib_type = DIBType::OSV2Short;
if (!decode_bmp_osv2_dib(context, streamer, true))
error = true;
} else if (dib_size == 40) {
context.dib_type = DIBType::Info;
if (!decode_bmp_info_dib(context, streamer))
error = true;
} else if (dib_size == 52) {
context.dib_type = DIBType::V2;
if (!decode_bmp_v2_dib(context, streamer))
error = true;
} else if (dib_size == 56) {
context.dib_type = DIBType::V3;
if (!decode_bmp_v3_dib(context, streamer))
error = true;
} else if (dib_size == 108) {
context.dib_type = DIBType::V4;
if (!decode_bmp_v4_dib(context, streamer))
error = true;
} else if (dib_size == 124) {
context.dib_type = DIBType::V5;
if (!decode_bmp_v5_dib(context, streamer))
error = true;
} else {
IF_BMP_DEBUG(dbg() << "Unsupported BMP DIB size: " << dib_size);
error = true;
}
if (!error && !set_dib_bitmasks(context, streamer))
error = true;
if (error) {
IF_BMP_DEBUG(dbg() << "BMP has an invalid DIB");
context.state = BMPLoadingContext::State::Error;
return false;
}
context.state = BMPLoadingContext::State::DIBDecoded;
return true;
}
static bool decode_bmp_color_table(BMPLoadingContext& context)
{
if (context.state == BMPLoadingContext::State::Error)
return false;
if (context.state < BMPLoadingContext::State::DIBDecoded && !decode_bmp_dib(context))
return false;
if (context.state >= BMPLoadingContext::State::ColorTableDecoded)
return true;
if (context.dib.core.bpp > 8) {
context.state = BMPLoadingContext::State::ColorTableDecoded;
return true;
}
auto bytes_per_color = context.dib_type == DIBType::Core ? 3 : 4;
u32 max_colors = 1 << context.dib.core.bpp;
auto size_of_color_table = context.data_offset - bmp_header_size - context.dib_size();
if (context.dib_type <= DIBType::OSV2) {
// Partial color tables are not supported, so the space of the color
// table must be at least enough for the maximum amount of colors
if (size_of_color_table < 3 * max_colors) {
// This is against the spec, but most viewers process it anyways
IF_BMP_DEBUG(dbg() << "BMP with CORE header does not have enough colors. Has: " << size_of_color_table << ", expected: " << (3 * max_colors));
}
}
Streamer streamer(context.data + bmp_header_size + context.dib_size(), size_of_color_table);
for (u32 i = 0; !streamer.at_end() && i < max_colors; ++i) {
if (bytes_per_color == 4) {
context.color_table.append(streamer.read_u32());
} else {
context.color_table.append(streamer.read_u24());
}
}
context.state = BMPLoadingContext::State::ColorTableDecoded;
return true;
}
struct RLEState {
enum : u8 {
PixelCount = 0,
PixelValue,
Meta, // Represents just consuming a null byte, which indicates something special
};
};
static bool uncompress_bmp_rle_data(BMPLoadingContext& context, ByteBuffer& buffer)
{
// RLE-compressed images cannot be stored top-down
if (context.dib.core.height < 0) {
IF_BMP_DEBUG(dbg() << "BMP is top-down and RLE compressed");
context.state = BMPLoadingContext::State::Error;
return false;
}
Streamer streamer(context.data + context.data_offset, context.data_size);
auto compression = context.dib.info.compression;
u32 total_rows = static_cast<u32>(context.dib.core.height);
u32 total_columns = round_up_to_power_of_two(static_cast<u32>(context.dib.core.width), 4);
u32 column = 0;
u32 row = 0;
auto currently_consuming = RLEState::PixelCount;
i16 pixel_count = 0;
if (compression == Compression::RLE24) {
buffer = ByteBuffer::create_zeroed(total_rows * round_up_to_power_of_two(total_columns, 4) * 4);
} else {
buffer = ByteBuffer::create_zeroed(total_rows * round_up_to_power_of_two(total_columns, 4));
}
// Avoid as many if statements as possible by pulling out
// compression-dependent actions into separate lambdas
Function<u32()> get_buffer_index;
Function<bool(u32, bool)> set_byte;
Function<Optional<u32>()> read_byte;
if (compression == Compression::RLE8) {
get_buffer_index = [&]() -> u32 { return row * total_columns + column; };
} else if (compression == Compression::RLE4) {
get_buffer_index = [&]() -> u32 { return (row * total_columns + column) / 2; };
} else {
get_buffer_index = [&]() -> u32 { return (row * total_columns + column) * 3; };
}
if (compression == Compression::RLE8) {
set_byte = [&](u32 color, bool) -> bool {
if (column >= total_columns) {
column = 0;
row++;
}
auto index = get_buffer_index();
if (index >= buffer.size()) {
IF_BMP_DEBUG(dbg() << "BMP has badly-formatted RLE data");
return false;
}
buffer[index] = color;
column++;
return true;
};
} else if (compression == Compression::RLE24) {
set_byte = [&](u32 color, bool) -> bool {
if (column >= total_columns) {
column = 0;
row++;
}
auto index = get_buffer_index();
if (index >= buffer.size()) {
IF_BMP_DEBUG(dbg() << "BMP has badly-formatted RLE data");
return false;
}
((u32&)buffer[index]) = color;
column++;
return true;
};
} else {
set_byte = [&](u32 byte, bool rle4_set_second_nibble) -> bool {
if (column >= total_columns) {
column = 0;
row++;
}
u32 index = get_buffer_index();
if (index >= buffer.size() || (rle4_set_second_nibble && index + 1 >= buffer.size())) {
IF_BMP_DEBUG(dbg() << "BMP has badly-formatted RLE data");
return false;
}
if (column % 2) {
buffer[index] |= byte >> 4;
if (rle4_set_second_nibble) {
buffer[index + 1] |= byte << 4;
column++;
}
} else {
if (rle4_set_second_nibble) {
buffer[index] = byte;
column++;
} else {
buffer[index] |= byte & 0xf0;
}
}
column++;
return true;
};
}
if (compression == Compression::RLE24) {
read_byte = [&]() -> Optional<u32> {
if (!streamer.has_u24()) {
IF_BMP_DEBUG(dbg() << "BMP has badly-formatted RLE data");
return {};
}
return streamer.read_u24();
};
} else {
read_byte = [&]() -> Optional<u32> {
if (!streamer.has_u8()) {
IF_BMP_DEBUG(dbg() << "BMP has badly-formatted RLE data");
return {};
}
return streamer.read_u8();
};
}
while (true) {
u32 byte;
switch (currently_consuming) {
case RLEState::PixelCount:
if (!streamer.has_u8())
return false;
byte = streamer.read_u8();
if (!byte) {
currently_consuming = RLEState::Meta;
} else {
pixel_count = byte;
currently_consuming = RLEState::PixelValue;
}
break;
case RLEState::PixelValue: {
auto result = read_byte();
if (!result.has_value())
return false;
byte = result.value();
for (u8 i = 0; i < pixel_count; ++i) {
if (compression != Compression::RLE4) {
if (!set_byte(byte, true))
return false;
} else {
if (!set_byte(byte, i != pixel_count - 1))
return false;
i++;
}
}
currently_consuming = RLEState::PixelCount;
break;
}
case RLEState::Meta:
if (!streamer.has_u8())
return false;
byte = streamer.read_u8();
if (!byte) {
column = 0;
row++;
currently_consuming = RLEState::PixelCount;
continue;
}
if (byte == 1)
return true;
if (byte == 2) {
u8 offset_x = streamer.read_u8();
u8 offset_y = streamer.read_u8();
column += offset_x;
if (column >= total_columns) {
column -= total_columns;
row++;
}
row += offset_y;
currently_consuming = RLEState::PixelCount;
continue;
}
// Consume literal bytes
pixel_count = byte;
i16 i = byte;
while (i >= 1) {
auto result = read_byte();
if (!result.has_value())
return false;
byte = result.value();
if (!set_byte(byte, i != 1))
return false;
i--;
if (compression == Compression::RLE4)
i--;
}
// Optionally consume a padding byte
if (compression != Compression::RLE4) {
if (pixel_count % 2) {
byte = streamer.read_u8();
}
} else {
if (((pixel_count + 1) / 2) % 2) {
byte = streamer.read_u8();
}
}
currently_consuming = RLEState::PixelCount;
break;
}
}
ASSERT_NOT_REACHED();
}
static bool decode_bmp_pixel_data(BMPLoadingContext& context)
{
if (context.state == BMPLoadingContext::State::Error)
return false;
if (context.state <= BMPLoadingContext::State::ColorTableDecoded && !decode_bmp_color_table(context))
return false;
const u16 bits_per_pixel = context.dib.core.bpp;
BitmapFormat format = [&]() -> BitmapFormat {
switch (bits_per_pixel) {
case 1:
return BitmapFormat::Indexed1;
case 2:
return BitmapFormat::Indexed2;
case 4:
return BitmapFormat::Indexed4;
case 8:
return BitmapFormat::Indexed8;
case 16:
if (context.dib.info.masks.size() == 4)
return BitmapFormat::RGBA32;
return BitmapFormat::RGB32;
case 24:
return BitmapFormat::RGB32;
case 32:
return BitmapFormat::RGBA32;
default:
return BitmapFormat::Invalid;
}
}();
if (format == BitmapFormat::Invalid) {
IF_BMP_DEBUG(dbg() << "BMP has invalid bpp of " << bits_per_pixel);
context.state = BMPLoadingContext::State::Error;
return false;
}
const u32 width = abs(context.dib.core.width);
const u32 height = abs(context.dib.core.height);
context.bitmap = Bitmap::create_purgeable(format, { static_cast<int>(width), static_cast<int>(height) });
if (!context.bitmap) {
IF_BMP_DEBUG(dbg() << "BMP appears to have overly large dimensions");
return false;
}
auto buffer = ByteBuffer::wrap(const_cast<u8*>(context.data + context.data_offset), context.data_size);
if (context.dib.info.compression == Compression::RLE4 || context.dib.info.compression == Compression::RLE8
|| context.dib.info.compression == Compression::RLE24) {
if (!uncompress_bmp_rle_data(context, buffer))
return false;
}
Streamer streamer(buffer.data(), buffer.size());
auto process_row = [&](u32 row) -> bool {
u32 space_remaining_before_consuming_row = streamer.remaining();
for (u32 column = 0; column < width;) {
switch (bits_per_pixel) {
case 1: {
if (!streamer.has_u8())
return false;
u8 byte = streamer.read_u8();
u8 mask = 8;
while (column < width && mask > 0) {
mask -= 1;
context.bitmap->scanline_u8(row)[column++] = (byte >> mask) & 0x1;
}
break;
}
case 2: {
if (!streamer.has_u8())
return false;
u8 byte = streamer.read_u8();
u8 mask = 8;
while (column < width && mask > 0) {
mask -= 2;
context.bitmap->scanline_u8(row)[column++] = (byte >> mask) & 0x3;
}
break;
}
case 4: {
if (!streamer.has_u8())
return false;
u8 byte = streamer.read_u8();
context.bitmap->scanline_u8(row)[column++] = (byte >> 4) & 0xf;
if (column < width)
context.bitmap->scanline_u8(row)[column++] = byte & 0xf;
break;
}
case 8:
if (!streamer.has_u8())
return false;
context.bitmap->scanline_u8(row)[column++] = streamer.read_u8();
break;
case 16: {
if (!streamer.has_u16())
return false;
context.bitmap->scanline(row)[column++] = int_to_scaled_rgb(context, streamer.read_u16());
break;
}
case 24: {
if (!streamer.has_u24())
return false;
context.bitmap->scanline(row)[column++] = streamer.read_u24();
break;
}
case 32:
if (!streamer.has_u32())
return false;
if (context.dib.info.masks.is_empty()) {
context.bitmap->scanline(row)[column++] = streamer.read_u32() | 0xff000000;
} else {
context.bitmap->scanline(row)[column++] = int_to_scaled_rgb(context, streamer.read_u32());
}
break;
}
}
auto consumed = space_remaining_before_consuming_row - streamer.remaining();
// Calculate padding
u8 bytes_to_drop = [consumed]() -> u8 {
switch (consumed % 4) {
case 0:
return 0;
case 1:
return 3;
case 2:
return 2;
case 3:
return 1;
}
ASSERT_NOT_REACHED();
}();
if (streamer.remaining() < bytes_to_drop)
return false;
streamer.drop_bytes(bytes_to_drop);
return true;
};
if (context.dib.core.height < 0) {
// BMP is stored top-down
for (u32 row = 0; row < height; ++row) {
if (!process_row(row))
return false;
}
} else {
for (i32 row = height - 1; row >= 0; --row) {
if (!process_row(row))
return false;
}
}
for (size_t i = 0; i < context.color_table.size(); ++i)
context.bitmap->set_palette_color(i, Color::from_rgb(context.color_table[i]));
context.state = BMPLoadingContext::State::PixelDataDecoded;
return true;
}
static RefPtr<Bitmap> load_bmp_impl(const u8* data, size_t data_size)
{
BMPLoadingContext context;
context.data = data;
context.data_size = data_size;
// Forces a decode of the header, dib, and color table as well
if (!decode_bmp_pixel_data(context)) {
context.state = BMPLoadingContext::State::Error;
return nullptr;
}
return context.bitmap;
}
BMPImageDecoderPlugin::BMPImageDecoderPlugin(const u8* data, size_t data_size)
{
m_context = make<BMPLoadingContext>();
m_context->data = data;
m_context->data_size = data_size;
}
BMPImageDecoderPlugin::~BMPImageDecoderPlugin()
{
}
IntSize BMPImageDecoderPlugin::size()
{
if (m_context->state == BMPLoadingContext::State::Error)
return {};
if (m_context->state < BMPLoadingContext::State::DIBDecoded && !decode_bmp_dib(*m_context))
return {};
return { m_context->dib.core.width, abs(m_context->dib.core.height) };
}
RefPtr<Gfx::Bitmap> BMPImageDecoderPlugin::bitmap()
{
if (m_context->state == BMPLoadingContext::State::Error)
return nullptr;
if (m_context->state < BMPLoadingContext::State::PixelDataDecoded && !decode_bmp_pixel_data(*m_context))
return nullptr;
ASSERT(m_context->bitmap);
return m_context->bitmap;
}
void BMPImageDecoderPlugin::set_volatile()
{
if (m_context->bitmap)
m_context->bitmap->set_volatile();
}
bool BMPImageDecoderPlugin::set_nonvolatile()
{
if (!m_context->bitmap)
return false;
return m_context->bitmap->set_nonvolatile();
}
bool BMPImageDecoderPlugin::sniff()
{
return decode_bmp_header(*m_context);
}
bool BMPImageDecoderPlugin::is_animated()
{
return false;
}
size_t BMPImageDecoderPlugin::loop_count()
{
return 0;
}
size_t BMPImageDecoderPlugin::frame_count()
{
return 1;
}
ImageFrameDescriptor BMPImageDecoderPlugin::frame(size_t i)
{
if (i > 0)
return { bitmap(), 0 };
return {};
}
}
Reference in a new issue View git blame Copy permalink