mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-17 16:32:11 +01:00
The LICENSE has changed from a single license (Apache2) to a dual license (Apache2 or MIT, at your option). If you've previously used Wuffs under the Apache2 license, you are able to keep doing so. No further action required by you. The two files listed below (previous releases) are exceptions, as they are older snapshots, frozen in time. Their license has not changed: release/c/wuffs-v0.2.c release/c/wuffs-v0.3.c Every name in the AUTHORS file, other than Google Inc., has signed Google's CLA (Contributor License Agreement).
256 lines
8.2 KiB
C
256 lines
8.2 KiB
C
// Copyright 2021 The Wuffs Authors.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
|
|
// option. This file may not be copied, modified, or distributed
|
|
// except according to those terms.
|
|
|
|
// ---------------- Magic Numbers
|
|
|
|
// ICO doesn't start with a magic identifier. Instead, see if the opening bytes
|
|
// are plausibly ICO.
|
|
//
|
|
// Callers should have already verified that (prefix_data.len >= 2) and the
|
|
// first two bytes are 0x00.
|
|
//
|
|
// See:
|
|
// - https://docs.fileformat.com/image/ico/
|
|
static int32_t //
|
|
wuffs_base__magic_number_guess_fourcc__maybe_ico(
|
|
wuffs_base__slice_u8 prefix_data,
|
|
bool prefix_closed) {
|
|
// Allow-list for the Image Type field.
|
|
if (prefix_data.len < 4) {
|
|
return prefix_closed ? 0 : -1;
|
|
} else if (prefix_data.ptr[3] != 0) {
|
|
return 0;
|
|
}
|
|
switch (prefix_data.ptr[2]) {
|
|
case 0x01: // ICO
|
|
case 0x02: // CUR
|
|
break;
|
|
default:
|
|
return 0;
|
|
}
|
|
|
|
// The Number Of Images should be positive.
|
|
if (prefix_data.len < 6) {
|
|
return prefix_closed ? 0 : -1;
|
|
} else if ((prefix_data.ptr[4] == 0) && (prefix_data.ptr[5] == 0)) {
|
|
return 0;
|
|
}
|
|
|
|
// The first ICONDIRENTRY's fourth byte should be zero.
|
|
if (prefix_data.len < 10) {
|
|
return prefix_closed ? 0 : -1;
|
|
} else if (prefix_data.ptr[9] != 0) {
|
|
return 0;
|
|
}
|
|
|
|
// TODO: have a separate FourCC for CUR?
|
|
return 0x49434F20; // 'ICO 'be
|
|
}
|
|
|
|
// TGA doesn't start with a magic identifier. Instead, see if the opening bytes
|
|
// are plausibly TGA.
|
|
//
|
|
// Callers should have already verified that (prefix_data.len >= 2) and the
|
|
// second byte (prefix_data.ptr[1], the Color Map Type byte), is either 0x00 or
|
|
// 0x01.
|
|
//
|
|
// See:
|
|
// - https://docs.fileformat.com/image/tga/
|
|
// - https://www.dca.fee.unicamp.br/~martino/disciplinas/ea978/tgaffs.pdf
|
|
static int32_t //
|
|
wuffs_base__magic_number_guess_fourcc__maybe_tga(
|
|
wuffs_base__slice_u8 prefix_data,
|
|
bool prefix_closed) {
|
|
// Allow-list for the Image Type field.
|
|
if (prefix_data.len < 3) {
|
|
return prefix_closed ? 0 : -1;
|
|
}
|
|
switch (prefix_data.ptr[2]) {
|
|
case 0x01:
|
|
case 0x02:
|
|
case 0x03:
|
|
case 0x09:
|
|
case 0x0A:
|
|
case 0x0B:
|
|
break;
|
|
default:
|
|
// TODO: 0x20 and 0x21 are invalid, according to the spec, but are
|
|
// apparently unofficial extensions.
|
|
return 0;
|
|
}
|
|
|
|
// Allow-list for the Color Map Entry Size field (if the Color Map Type field
|
|
// is non-zero) or else all the Color Map fields should be zero.
|
|
if (prefix_data.len < 8) {
|
|
return prefix_closed ? 0 : -1;
|
|
} else if (prefix_data.ptr[1] != 0x00) {
|
|
switch (prefix_data.ptr[7]) {
|
|
case 0x0F:
|
|
case 0x10:
|
|
case 0x18:
|
|
case 0x20:
|
|
break;
|
|
default:
|
|
return 0;
|
|
}
|
|
} else if ((prefix_data.ptr[3] | prefix_data.ptr[4] | prefix_data.ptr[5] |
|
|
prefix_data.ptr[6] | prefix_data.ptr[7]) != 0x00) {
|
|
return 0;
|
|
}
|
|
|
|
// Allow-list for the Pixel Depth field.
|
|
if (prefix_data.len < 17) {
|
|
return prefix_closed ? 0 : -1;
|
|
}
|
|
switch (prefix_data.ptr[16]) {
|
|
case 0x01:
|
|
case 0x08:
|
|
case 0x0F:
|
|
case 0x10:
|
|
case 0x18:
|
|
case 0x20:
|
|
break;
|
|
default:
|
|
return 0;
|
|
}
|
|
|
|
return 0x54474120; // 'TGA 'be
|
|
}
|
|
|
|
WUFFS_BASE__MAYBE_STATIC int32_t //
|
|
wuffs_base__magic_number_guess_fourcc(wuffs_base__slice_u8 prefix_data,
|
|
bool prefix_closed) {
|
|
// This is similar to (but different from):
|
|
// - the magic/Magdir tables under https://github.com/file/file
|
|
// - the MIME Sniffing algorithm at https://mimesniff.spec.whatwg.org/
|
|
|
|
// table holds the 'magic numbers' (which are actually variable length
|
|
// strings). The strings may contain NUL bytes, so the "const char* magic"
|
|
// value starts with the length-minus-1 of the 'magic number'.
|
|
//
|
|
// Keep it sorted by magic[1], then magic[0] descending (prioritizing longer
|
|
// matches) and finally by magic[2:]. When multiple entries match, the
|
|
// longest one wins.
|
|
//
|
|
// The fourcc field might be negated, in which case there's further
|
|
// specialization (see § below).
|
|
static struct {
|
|
int32_t fourcc;
|
|
const char* magic;
|
|
} table[] = {
|
|
{-0x30302020, "\x01\x00\x00"}, // '00 'be
|
|
{+0x475A2020, "\x02\x1F\x8B\x08"}, // GZ
|
|
{+0x5A535444, "\x03\x28\xB5\x2F\xFD"}, // ZSTD
|
|
{+0x425A3220, "\x02\x42\x5A\x68"}, // BZ2
|
|
{+0x424D5020, "\x01\x42\x4D"}, // BMP
|
|
{+0x47494620, "\x03\x47\x49\x46\x38"}, // GIF
|
|
{+0x54494646, "\x03\x49\x49\x2A\x00"}, // TIFF (little-endian)
|
|
{+0x54494646, "\x03\x4D\x4D\x00\x2A"}, // TIFF (big-endian)
|
|
{+0x4E50424D, "\x02\x50\x35\x0A"}, // NPBM (P5; *.pgm)
|
|
{+0x4E50424D, "\x02\x50\x36\x0A"}, // NPBM (P6; *.ppm)
|
|
{-0x52494646, "\x03\x52\x49\x46\x46"}, // RIFF
|
|
{+0x4C5A4D41, "\x04\x5D\x00\x10\x00\x00"}, // LZMA
|
|
{+0x4C5A4D41, "\x02\x5D\x00\x00"}, // LZMA
|
|
{+0x4E494520, "\x02\x6E\xC3\xAF"}, // NIE
|
|
{+0x514F4920, "\x03\x71\x6F\x69\x66"}, // QOI
|
|
{+0x5A4C4942, "\x01\x78\x9C"}, // ZLIB
|
|
{+0x504E4720, "\x03\x89\x50\x4E\x47"}, // PNG
|
|
{+0x585A2020, "\x04\xFD\x37\x7A\x58\x5A"}, // XZ
|
|
{+0x4A504547, "\x01\xFF\xD8"}, // JPEG
|
|
};
|
|
static const size_t table_len = sizeof(table) / sizeof(table[0]);
|
|
|
|
if (prefix_data.len == 0) {
|
|
return prefix_closed ? 0 : -1;
|
|
}
|
|
uint8_t pre_first_byte = prefix_data.ptr[0];
|
|
|
|
int32_t fourcc = 0;
|
|
size_t i;
|
|
for (i = 0; i < table_len; i++) {
|
|
uint8_t mag_first_byte = ((uint8_t)(table[i].magic[1]));
|
|
if (pre_first_byte < mag_first_byte) {
|
|
break;
|
|
} else if (pre_first_byte > mag_first_byte) {
|
|
continue;
|
|
}
|
|
fourcc = table[i].fourcc;
|
|
|
|
uint8_t mag_remaining_len = ((uint8_t)(table[i].magic[0]));
|
|
if (mag_remaining_len == 0) {
|
|
goto match;
|
|
}
|
|
|
|
const char* mag_remaining_ptr = table[i].magic + 2;
|
|
uint8_t* pre_remaining_ptr = prefix_data.ptr + 1;
|
|
size_t pre_remaining_len = prefix_data.len - 1;
|
|
if (pre_remaining_len < mag_remaining_len) {
|
|
if (!memcmp(pre_remaining_ptr, mag_remaining_ptr, pre_remaining_len)) {
|
|
return prefix_closed ? 0 : -1;
|
|
}
|
|
} else {
|
|
if (!memcmp(pre_remaining_ptr, mag_remaining_ptr, mag_remaining_len)) {
|
|
goto match;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (prefix_data.len < 2) {
|
|
return prefix_closed ? 0 : -1;
|
|
} else if ((prefix_data.ptr[1] == 0x00) || (prefix_data.ptr[1] == 0x01)) {
|
|
return wuffs_base__magic_number_guess_fourcc__maybe_tga(prefix_data,
|
|
prefix_closed);
|
|
}
|
|
|
|
return 0;
|
|
|
|
match:
|
|
// Negative FourCC values (see § above) are further specialized.
|
|
if (fourcc < 0) {
|
|
fourcc = -fourcc;
|
|
|
|
if (fourcc == 0x52494646) { // 'RIFF'be
|
|
if (prefix_data.len < 12) {
|
|
return prefix_closed ? 0 : -1;
|
|
}
|
|
uint32_t x = wuffs_base__peek_u32be__no_bounds_check(prefix_data.ptr + 8);
|
|
if (x == 0x57454250) { // 'WEBP'be
|
|
return 0x57454250; // 'WEBP'be
|
|
}
|
|
|
|
} else if (fourcc == 0x30302020) { // '00 'be
|
|
// Binary data starting with multiple 0x00 NUL bytes is quite common.
|
|
// Unfortunately, some file formats also don't start with a magic
|
|
// identifier, so we have to use heuristics (where the order matters, the
|
|
// same as /usr/bin/file's magic/Magdir tables) as best we can. Maybe
|
|
// it's TGA, ICO/CUR, etc. Maybe it's something else.
|
|
int32_t tga = wuffs_base__magic_number_guess_fourcc__maybe_tga(
|
|
prefix_data, prefix_closed);
|
|
if (tga != 0) {
|
|
return tga;
|
|
}
|
|
int32_t ico = wuffs_base__magic_number_guess_fourcc__maybe_ico(
|
|
prefix_data, prefix_closed);
|
|
if (ico != 0) {
|
|
return ico;
|
|
}
|
|
if (prefix_data.len < 4) {
|
|
return prefix_closed ? 0 : -1;
|
|
} else if ((prefix_data.ptr[2] != 0x00) &&
|
|
((prefix_data.ptr[2] >= 0x80) ||
|
|
(prefix_data.ptr[3] != 0x00))) {
|
|
// Roughly speaking, this could be a non-degenerate (non-0-width and
|
|
// non-0-height) WBMP image.
|
|
return 0x57424D50; // 'WBMP'be
|
|
}
|
|
return 0;
|
|
}
|
|
}
|
|
return fourcc;
|
|
}
|