GerbilSoft/rom-properties
1
Fork 0
mirror of https://github.com/GerbilSoft/rom-properties.git synced 2025-06-18 11:35:38 -04:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

[librptexture] Qoi: New parser for the Quite OK Image Format.

Browse Source 
qoi.h is used for upstream, instead of writing a custom decoder.
I may write a custom decoder later to decode the Qoi data directly
into an rp_image without having an intermediate step.
This commit is contained in:
David Korth 2025-03-17 18:10:03 -04:00
parent 70eea97ef5
commit 1cd09c3039
8 changed files with 991 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
NEWS.md
View File

@ -7,6 +7,7 @@
J2ME .jar packages and .jad metadata files only. Other .jar files
will be ignored. Android packages (.apk) are also not currently
supported.
* Qoi: Quite OK Image Format parser. Uses qoi.h from upstream.
* New parser features:
* WiiUPackage: Add support for extracted Wii U packages.

5
debian/copyright vendored
View File

@ -248,6 +248,11 @@ Copyright:
2017-2024, David Korth <gerbilsoft@gerbilsoft.com>
License: GPL-2+
Files: src/librptexture/fileformat/qoi.h
Copyright:
Copyright (c) 2021, Dominic Szablewski - https://phoboslab.org
License: MIT
License: BSD-2-clause
All rights reserved.
.

7
src/librptexture/CMakeLists.txt
View File

@ -18,7 +18,7 @@ IF(ENABLE_OPENMP)
ENDIF(OpenMP_FOUND)
ENDIF(ENABLE_OPENMP)
# Sources.
# Sources
SET(${PROJECT_NAME}_SRCS
FileFormatFactory.cpp
ImageSizeCalc.cpp
@ -48,6 +48,7 @@ SET(${PROJECT_NAME}_SRCS
fileformat/KhronosKTX2.cpp
fileformat/PalmOS_Tbmp.cpp
fileformat/PowerVR3.cpp
fileformat/Qoi.cpp
fileformat/SegaPVR.cpp
fileformat/TGA.cpp
fileformat/ValveVTF.cpp
@ -58,7 +59,7 @@ SET(${PROJECT_NAME}_SRCS
data/GLenumStrings.cpp
data/VkEnumStrings.cpp
)
# Headers.
# Headers
SET(${PROJECT_NAME}_H
FileFormatFactory.hpp
argb32_t.hpp
@ -81,6 +82,7 @@ SET(${PROJECT_NAME}_H
decoder/ImageDecoder_BC7.hpp
decoder/ImageDecoder_C64.hpp
decoder/PixelConversion.hpp
decoder/qoi.h
fileformat/FileFormat.hpp
fileformat/FileFormat_p.hpp
@ -93,6 +95,7 @@ SET(${PROJECT_NAME}_H
fileformat/KhronosKTX2.hpp
fileformat/PalmOS_Tbmp.hpp
fileformat/PowerVR3.hpp
fileformat/Qoi.hpp
fileformat/SegaPVR.hpp
fileformat/TGA.hpp
fileformat/ValveVTF.hpp

4
src/librptexture/FileFormatFactory.cpp
View File

@ -35,6 +35,7 @@ using std::vector;
#include "fileformat/KhronosKTX.hpp"
#include "fileformat/KhronosKTX2.hpp"
#include "fileformat/PowerVR3.hpp"
#include "fileformat/Qoi.hpp"
#include "fileformat/SegaPVR.hpp"
#include "fileformat/TGA.hpp"
#include "fileformat/ValveVTF.hpp"
@ -94,11 +95,12 @@ pthread_once_t once_mimeTypes = PTHREAD_ONCE_INIT;
// FileFormat subclasses that use a header at 0 and
// definitely have a 32-bit magic number at address 0.
// TODO: Add support for multiple magic numbers per class.
const array<FileFormatFns, 11> FileFormatFns_magic = {{
const array<FileFormatFns, 12> FileFormatFns_magic = {{
GetFileFormatFns(ASTC, P99_PROTECT({{0x13ABA15C, 0}})), // Needs to be in multi-char constant format
GetFileFormatFns(DirectDrawSurface, P99_PROTECT({{'DDS ', 0}})),
GetFileFormatFns(GodotSTEX, P99_PROTECT({{'GDST', 'GST2'}})),
GetFileFormatFns(PowerVR3, P99_PROTECT({{'PVR\x03', '\x03RVP'}})),
GetFileFormatFns(Qoi , P99_PROTECT({{'qoif', 0}})),
GetFileFormatFns(SegaPVR, P99_PROTECT({{'PVRT', 'GVRT'}})),
GetFileFormatFns(SegaPVR, P99_PROTECT({{'PVRX', 'GBIX'}})),
GetFileFormatFns(SegaPVR, P99_PROTECT({{'GCIX', 0}})),

649
src/librptexture/decoder/qoi.h Normal file
View File

@ -0,0 +1,649 @@
/*
Copyright (c) 2021, Dominic Szablewski - https://phoboslab.org
SPDX-License-Identifier: MIT
QOI - The "Quite OK Image" format for fast, lossless image compression
-- About
QOI encodes and decodes images in a lossless format. Compared to stb_image and
stb_image_write QOI offers 20x-50x faster encoding, 3x-4x faster decoding and
20% better compression.
-- Synopsis
// Define `QOI_IMPLEMENTATION` in *one* C/C++ file before including this
// library to create the implementation.
#define QOI_IMPLEMENTATION
#include "qoi.h"
// Encode and store an RGBA buffer to the file system. The qoi_desc describes
// the input pixel data.
qoi_write("image_new.qoi", rgba_pixels, &(qoi_desc){
.width = 1920,
.height = 1080,
.channels = 4,
.colorspace = QOI_SRGB
});
// Load and decode a QOI image from the file system into a 32bbp RGBA buffer.
// The qoi_desc struct will be filled with the width, height, number of channels
// and colorspace read from the file header.
qoi_desc desc;
void *rgba_pixels = qoi_read("image.qoi", &desc, 4);
-- Documentation
This library provides the following functions;
- qoi_read -- read and decode a QOI file
- qoi_decode -- decode the raw bytes of a QOI image from memory
- qoi_write -- encode and write a QOI file
- qoi_encode -- encode an rgba buffer into a QOI image in memory
See the function declaration below for the signature and more information.
If you don't want/need the qoi_read and qoi_write functions, you can define
QOI_NO_STDIO before including this library.
This library uses malloc() and free(). To supply your own malloc implementation
you can define QOI_MALLOC and QOI_FREE before including this library.
This library uses memset() to zero-initialize the index. To supply your own
implementation you can define QOI_ZEROARR before including this library.
-- Data Format
A QOI file has a 14 byte header, followed by any number of data "chunks" and an
8-byte end marker.
struct qoi_header_t {
char magic[4]; // magic bytes "qoif"
uint32_t width; // image width in pixels (BE)
uint32_t height; // image height in pixels (BE)
uint8_t channels; // 3 = RGB, 4 = RGBA
uint8_t colorspace; // 0 = sRGB with linear alpha, 1 = all channels linear
};
Images are encoded row by row, left to right, top to bottom. The decoder and
encoder start with {r: 0, g: 0, b: 0, a: 255} as the previous pixel value. An
image is complete when all pixels specified by width * height have been covered.
Pixels are encoded as
- a run of the previous pixel
- an index into an array of previously seen pixels
- a difference to the previous pixel value in r,g,b
- full r,g,b or r,g,b,a values
The color channels are assumed to not be premultiplied with the alpha channel
("un-premultiplied alpha").
A running array[64] (zero-initialized) of previously seen pixel values is
maintained by the encoder and decoder. Each pixel that is seen by the encoder
and decoder is put into this array at the position formed by a hash function of
the color value. In the encoder, if the pixel value at the index matches the
current pixel, this index position is written to the stream as QOI_OP_INDEX.
The hash function for the index is:
index_position = (r * 3 + g * 5 + b * 7 + a * 11) % 64
Each chunk starts with a 2- or 8-bit tag, followed by a number of data bits. The
bit length of chunks is divisible by 8 - i.e. all chunks are byte aligned. All
values encoded in these data bits have the most significant bit on the left.
The 8-bit tags have precedence over the 2-bit tags. A decoder must check for the
presence of an 8-bit tag first.
The byte stream's end is marked with 7 0x00 bytes followed a single 0x01 byte.
The possible chunks are:
.- QOI_OP_INDEX ----------.
| Byte[0] |
| 7 6 5 4 3 2 1 0 |
|-------+-----------------|
| 0 0 | index |
`-------------------------`
2-bit tag b00
6-bit index into the color index array: 0..63
A valid encoder must not issue 2 or more consecutive QOI_OP_INDEX chunks to the
same index. QOI_OP_RUN should be used instead.
.- QOI_OP_DIFF -----------.
| Byte[0] |
| 7 6 5 4 3 2 1 0 |
|-------+-----+-----+-----|
| 0 1 | dr | dg | db |
`-------------------------`
2-bit tag b01
2-bit red channel difference from the previous pixel between -2..1
2-bit green channel difference from the previous pixel between -2..1
2-bit blue channel difference from the previous pixel between -2..1
The difference to the current channel values are using a wraparound operation,
so "1 - 2" will result in 255, while "255 + 1" will result in 0.
Values are stored as unsigned integers with a bias of 2. E.g. -2 is stored as
0 (b00). 1 is stored as 3 (b11).
The alpha value remains unchanged from the previous pixel.
.- QOI_OP_LUMA -------------------------------------.
| Byte[0] | Byte[1] |
| 7 6 5 4 3 2 1 0 | 7 6 5 4 3 2 1 0 |
|-------+-----------------+-------------+-----------|
| 1 0 | green diff | dr - dg | db - dg |
`---------------------------------------------------`
2-bit tag b10
6-bit green channel difference from the previous pixel -32..31
4-bit red channel difference minus green channel difference -8..7
4-bit blue channel difference minus green channel difference -8..7
The green channel is used to indicate the general direction of change and is
encoded in 6 bits. The red and blue channels (dr and db) base their diffs off
of the green channel difference and are encoded in 4 bits. I.e.:
dr_dg = (cur_px.r - prev_px.r) - (cur_px.g - prev_px.g)
db_dg = (cur_px.b - prev_px.b) - (cur_px.g - prev_px.g)
The difference to the current channel values are using a wraparound operation,
so "10 - 13" will result in 253, while "250 + 7" will result in 1.
Values are stored as unsigned integers with a bias of 32 for the green channel
and a bias of 8 for the red and blue channel.
The alpha value remains unchanged from the previous pixel.
.- QOI_OP_RUN ------------.
| Byte[0] |
| 7 6 5 4 3 2 1 0 |
|-------+-----------------|
| 1 1 | run |
`-------------------------`
2-bit tag b11
6-bit run-length repeating the previous pixel: 1..62
The run-length is stored with a bias of -1. Note that the run-lengths 63 and 64
(b111110 and b111111) are illegal as they are occupied by the QOI_OP_RGB and
QOI_OP_RGBA tags.
.- QOI_OP_RGB ------------------------------------------.
| Byte[0] | Byte[1] | Byte[2] | Byte[3] |
| 7 6 5 4 3 2 1 0 | 7 .. 0 | 7 .. 0 | 7 .. 0 |
|-------------------------+---------+---------+---------|
| 1 1 1 1 1 1 1 0 | red | green | blue |
`-------------------------------------------------------`
8-bit tag b11111110
8-bit red channel value
8-bit green channel value
8-bit blue channel value
The alpha value remains unchanged from the previous pixel.
.- QOI_OP_RGBA ---------------------------------------------------.
| Byte[0] | Byte[1] | Byte[2] | Byte[3] | Byte[4] |
| 7 6 5 4 3 2 1 0 | 7 .. 0 | 7 .. 0 | 7 .. 0 | 7 .. 0 |
|-------------------------+---------+---------+---------+---------|
| 1 1 1 1 1 1 1 1 | red | green | blue | alpha |
`-----------------------------------------------------------------`
8-bit tag b11111111
8-bit red channel value
8-bit green channel value
8-bit blue channel value
8-bit alpha channel value
*/
/* -----------------------------------------------------------------------------
Header - Public functions */
#ifndef QOI_H
#define QOI_H
#ifdef __cplusplus
extern "C" {
#endif
/* A pointer to a qoi_desc struct has to be supplied to all of qoi's functions.
It describes either the input format (for qoi_write and qoi_encode), or is
filled with the description read from the file header (for qoi_read and
qoi_decode).
The colorspace in this qoi_desc is an enum where
0 = sRGB, i.e. gamma scaled RGB channels and a linear alpha channel
1 = all channels are linear
You may use the constants QOI_SRGB or QOI_LINEAR. The colorspace is purely
informative. It will be saved to the file header, but does not affect
how chunks are en-/decoded. */
#define QOI_SRGB 0
#define QOI_LINEAR 1
typedef struct {
unsigned int width;
unsigned int height;
unsigned char channels;
unsigned char colorspace;
} qoi_desc;
#ifndef QOI_NO_STDIO
/* Encode raw RGB or RGBA pixels into a QOI image and write it to the file
system. The qoi_desc struct must be filled with the image width, height,
number of channels (3 = RGB, 4 = RGBA) and the colorspace.
The function returns 0 on failure (invalid parameters, or fopen or malloc
failed) or the number of bytes written on success. */
int qoi_write(const char *filename, const void *data, const qoi_desc *desc);
/* Read and decode a QOI image from the file system. If channels is 0, the
number of channels from the file header is used. If channels is 3 or 4 the
output format will be forced into this number of channels.
The function either returns NULL on failure (invalid data, or malloc or fopen
failed) or a pointer to the decoded pixels. On success, the qoi_desc struct
will be filled with the description from the file header.
The returned pixel data should be free()d after use. */
void *qoi_read(const char *filename, qoi_desc *desc, int channels);
#endif /* QOI_NO_STDIO */
/* Encode raw RGB or RGBA pixels into a QOI image in memory.
The function either returns NULL on failure (invalid parameters or malloc
failed) or a pointer to the encoded data on success. On success the out_len
is set to the size in bytes of the encoded data.
The returned qoi data should be free()d after use. */
void *qoi_encode(const void *data, const qoi_desc *desc, int *out_len);
/* Decode a QOI image from memory.
The function either returns NULL on failure (invalid parameters or malloc
failed) or a pointer to the decoded pixels. On success, the qoi_desc struct
is filled with the description from the file header.
The returned pixel data should be free()d after use. */
void *qoi_decode(const void *data, int size, qoi_desc *desc, int channels);
#ifdef __cplusplus
}
#endif
#endif /* QOI_H */
/* -----------------------------------------------------------------------------
Implementation */
#ifdef QOI_IMPLEMENTATION
#include <stdlib.h>
#include <string.h>
#ifndef QOI_MALLOC
#define QOI_MALLOC(sz) malloc(sz)
#define QOI_FREE(p) free(p)
#endif
#ifndef QOI_ZEROARR
#define QOI_ZEROARR(a) memset((a),0,sizeof(a))
#endif
#define QOI_OP_INDEX 0x00 /* 00xxxxxx */
#define QOI_OP_DIFF 0x40 /* 01xxxxxx */
#define QOI_OP_LUMA 0x80 /* 10xxxxxx */
#define QOI_OP_RUN 0xc0 /* 11xxxxxx */
#define QOI_OP_RGB 0xfe /* 11111110 */
#define QOI_OP_RGBA 0xff /* 11111111 */
#define QOI_MASK_2 0xc0 /* 11000000 */
#define QOI_COLOR_HASH(C) (C.rgba.r*3 + C.rgba.g*5 + C.rgba.b*7 + C.rgba.a*11)
#define QOI_MAGIC \
(((unsigned int)'q') << 24 | ((unsigned int)'o') << 16 | \
((unsigned int)'i') << 8 | ((unsigned int)'f'))
#define QOI_HEADER_SIZE 14
/* 2GB is the max file size that this implementation can safely handle. We guard
against anything larger than that, assuming the worst case with 5 bytes per
pixel, rounded down to a nice clean value. 400 million pixels ought to be
enough for anybody. */
#define QOI_PIXELS_MAX ((unsigned int)400000000)
typedef union {
struct { unsigned char r, g, b, a; } rgba;
unsigned int v;
} qoi_rgba_t;
static const unsigned char qoi_padding[8] = {0,0,0,0,0,0,0,1};
static void qoi_write_32(unsigned char *bytes, int *p, unsigned int v) {
bytes[(*p)++] = (0xff000000 & v) >> 24;
bytes[(*p)++] = (0x00ff0000 & v) >> 16;
bytes[(*p)++] = (0x0000ff00 & v) >> 8;
bytes[(*p)++] = (0x000000ff & v);
}
static unsigned int qoi_read_32(const unsigned char *bytes, int *p) {
unsigned int a = bytes[(*p)++];
unsigned int b = bytes[(*p)++];
unsigned int c = bytes[(*p)++];
unsigned int d = bytes[(*p)++];
return a << 24 | b << 16 | c << 8 | d;
}
void *qoi_encode(const void *data, const qoi_desc *desc, int *out_len) {
int i, max_size, p, run;
int px_len, px_end, px_pos, channels;
unsigned char *bytes;
const unsigned char *pixels;
qoi_rgba_t index[64];
qoi_rgba_t px, px_prev;
if (
data == NULL || out_len == NULL || desc == NULL ||
desc->width == 0 || desc->height == 0 ||
desc->channels < 3 || desc->channels > 4 ||
desc->colorspace > 1 ||
desc->height >= QOI_PIXELS_MAX / desc->width
) {
return NULL;
}
max_size =
desc->width * desc->height * (desc->channels + 1) +
QOI_HEADER_SIZE + sizeof(qoi_padding);
p = 0;
bytes = (unsigned char *) QOI_MALLOC(max_size);
if (!bytes) {
return NULL;
}
qoi_write_32(bytes, &p, QOI_MAGIC);
qoi_write_32(bytes, &p, desc->width);
qoi_write_32(bytes, &p, desc->height);
bytes[p++] = desc->channels;
bytes[p++] = desc->colorspace;
pixels = (const unsigned char *)data;
QOI_ZEROARR(index);
run = 0;
px_prev.rgba.r = 0;
px_prev.rgba.g = 0;
px_prev.rgba.b = 0;
px_prev.rgba.a = 255;
px = px_prev;
px_len = desc->width * desc->height * desc->channels;
px_end = px_len - desc->channels;
channels = desc->channels;
for (px_pos = 0; px_pos < px_len; px_pos += channels) {
px.rgba.r = pixels[px_pos + 0];
px.rgba.g = pixels[px_pos + 1];
px.rgba.b = pixels[px_pos + 2];
if (channels == 4) {
px.rgba.a = pixels[px_pos + 3];
}
if (px.v == px_prev.v) {
run++;
if (run == 62 || px_pos == px_end) {
bytes[p++] = QOI_OP_RUN | (run - 1);
run = 0;
}
}
else {
int index_pos;
if (run > 0) {
bytes[p++] = QOI_OP_RUN | (run - 1);
run = 0;
}
index_pos = QOI_COLOR_HASH(px) % 64;
if (index[index_pos].v == px.v) {
bytes[p++] = QOI_OP_INDEX | index_pos;
}
else {
index[index_pos] = px;
if (px.rgba.a == px_prev.rgba.a) {
signed char vr = px.rgba.r - px_prev.rgba.r;
signed char vg = px.rgba.g - px_prev.rgba.g;
signed char vb = px.rgba.b - px_prev.rgba.b;
signed char vg_r = vr - vg;
signed char vg_b = vb - vg;
if (
vr > -3 && vr < 2 &&
vg > -3 && vg < 2 &&
vb > -3 && vb < 2
) {
bytes[p++] = QOI_OP_DIFF | (vr + 2) << 4 | (vg + 2) << 2 | (vb + 2);
}
else if (
vg_r > -9 && vg_r < 8 &&
vg > -33 && vg < 32 &&
vg_b > -9 && vg_b < 8
) {
bytes[p++] = QOI_OP_LUMA | (vg + 32);
bytes[p++] = (vg_r + 8) << 4 | (vg_b + 8);
}
else {
bytes[p++] = QOI_OP_RGB;
bytes[p++] = px.rgba.r;
bytes[p++] = px.rgba.g;
bytes[p++] = px.rgba.b;
}
}
else {
bytes[p++] = QOI_OP_RGBA;
bytes[p++] = px.rgba.r;
bytes[p++] = px.rgba.g;
bytes[p++] = px.rgba.b;
bytes[p++] = px.rgba.a;
}
}
}
px_prev = px;
}
for (i = 0; i < (int)sizeof(qoi_padding); i++) {
bytes[p++] = qoi_padding[i];
}
*out_len = p;
return bytes;
}
void *qoi_decode(const void *data, int size, qoi_desc *desc, int channels) {
const unsigned char *bytes;
unsigned int header_magic;
unsigned char *pixels;
qoi_rgba_t index[64];
qoi_rgba_t px;
int px_len, chunks_len, px_pos;
int p = 0, run = 0;
if (
data == NULL || desc == NULL ||
(channels != 0 && channels != 3 && channels != 4) ||
size < QOI_HEADER_SIZE + (int)sizeof(qoi_padding)
) {
return NULL;
}
bytes = (const unsigned char *)data;
header_magic = qoi_read_32(bytes, &p);
desc->width = qoi_read_32(bytes, &p);
desc->height = qoi_read_32(bytes, &p);
desc->channels = bytes[p++];
desc->colorspace = bytes[p++];
if (
desc->width == 0 || desc->height == 0 ||
desc->channels < 3 || desc->channels > 4 ||
desc->colorspace > 1 ||
header_magic != QOI_MAGIC ||
desc->height >= QOI_PIXELS_MAX / desc->width
) {
return NULL;
}
if (channels == 0) {
channels = desc->channels;
}
px_len = desc->width * desc->height * channels;
pixels = (unsigned char *) QOI_MALLOC(px_len);
if (!pixels) {
return NULL;
}
QOI_ZEROARR(index);
px.rgba.r = 0;
px.rgba.g = 0;
px.rgba.b = 0;
px.rgba.a = 255;
chunks_len = size - (int)sizeof(qoi_padding);
for (px_pos = 0; px_pos < px_len; px_pos += channels) {
if (run > 0) {
run--;
}
else if (p < chunks_len) {
int b1 = bytes[p++];
if (b1 == QOI_OP_RGB) {
px.rgba.r = bytes[p++];
px.rgba.g = bytes[p++];
px.rgba.b = bytes[p++];
}
else if (b1 == QOI_OP_RGBA) {
px.rgba.r = bytes[p++];
px.rgba.g = bytes[p++];
px.rgba.b = bytes[p++];
px.rgba.a = bytes[p++];
}
else if ((b1 & QOI_MASK_2) == QOI_OP_INDEX) {
px = index[b1];
}
else if ((b1 & QOI_MASK_2) == QOI_OP_DIFF) {
px.rgba.r += ((b1 >> 4) & 0x03) - 2;
px.rgba.g += ((b1 >> 2) & 0x03) - 2;
px.rgba.b += ( b1 & 0x03) - 2;
}
else if ((b1 & QOI_MASK_2) == QOI_OP_LUMA) {
int b2 = bytes[p++];
int vg = (b1 & 0x3f) - 32;
px.rgba.r += vg - 8 + ((b2 >> 4) & 0x0f);
px.rgba.g += vg;
px.rgba.b += vg - 8 + (b2 & 0x0f);
}
else if ((b1 & QOI_MASK_2) == QOI_OP_RUN) {
run = (b1 & 0x3f);
}
index[QOI_COLOR_HASH(px) % 64] = px;
}
pixels[px_pos + 0] = px.rgba.r;
pixels[px_pos + 1] = px.rgba.g;
pixels[px_pos + 2] = px.rgba.b;
if (channels == 4) {
pixels[px_pos + 3] = px.rgba.a;
}
}
return pixels;
}
#ifndef QOI_NO_STDIO
#include <stdio.h>
int qoi_write(const char *filename, const void *data, const qoi_desc *desc) {
FILE *f = fopen(filename, "wb");
int size, err;
void *encoded;
if (!f) {
return 0;
}
encoded = qoi_encode(data, desc, &size);
if (!encoded) {
fclose(f);
return 0;
}
fwrite(encoded, 1, size, f);
fflush(f);
err = ferror(f);
fclose(f);
QOI_FREE(encoded);
return err ? 0 : size;
}
void *qoi_read(const char *filename, qoi_desc *desc, int channels) {
FILE *f = fopen(filename, "rb");
int size, bytes_read;
void *pixels, *data;
if (!f) {
return NULL;
}
fseek(f, 0, SEEK_END);
size = ftell(f);
if (size <= 0 || fseek(f, 0, SEEK_SET) != 0) {
fclose(f);
return NULL;
}
data = QOI_MALLOC(size);
if (!data) {
fclose(f);
return NULL;
}
bytes_read = fread(data, 1, size, f);
fclose(f);
pixels = (bytes_read != size) ? NULL : qoi_decode(data, bytes_read, desc, channels);
QOI_FREE(data);
return pixels;
}
#endif /* QOI_NO_STDIO */
#endif /* QOI_IMPLEMENTATION */

308
src/librptexture/fileformat/Qoi.cpp Normal file
View File

@ -0,0 +1,308 @@
/***************************************************************************
* ROM Properties Page shell extension. (librptexture) *
* Qoi.cpp: Quite OK Image Format image reader. *
* *
* Copyright (c) 2017-2025 by David Korth. *
* SPDX-License-Identifier: GPL-2.0-or-later *
***************************************************************************/
#include "stdafx.h"
#include "Qoi.hpp"
#include "FileFormat_p.hpp"
// Other rom-properties libraries
#include "libi18n/i18n.h"
#define QOI_IMPLEMENTATION
#include "decoder/qoi.h"
// Other rom-properties libraries
using namespace LibRpFile;
using LibRpBase::RomFields;
// C++ STL classes
using std::array;
namespace LibRpTexture {
// Qoi header, with magic number.
#define QOI_MAGIC_NUMBER 'qoif'
struct QoiHeader {
uint32_t magic;
qoi_desc desc;
};
ASSERT_STRUCT(QoiHeader, 16);
class QoiPrivate final : public FileFormatPrivate
{
public:
QoiPrivate(Qoi *q, const IRpFilePtr &file);
private:
typedef FileFormatPrivate super;
RP_DISABLE_COPY(QoiPrivate)
public:
/** TextureInfo **/
static const array<const char*, 1+1> exts;
static const array<const char*, 2+1> mimeTypes;
static const TextureInfo textureInfo;
public:
// Qoi header
QoiHeader qoiHeader;
// Decoded image
rp_image_ptr img;
/**
* Load the image.
* @return Image, or nullptr on error.
*/
rp_image_const_ptr loadImage(void);
};
FILEFORMAT_IMPL(Qoi)
/** QoiPrivate **/
/* TextureInfo */
const array<const char*, 1+1> QoiPrivate::exts = {{
".qoi",
nullptr
}};
const array<const char*, 2+1> QoiPrivate::mimeTypes = {{
// Unofficial MIME types.
// TODO: Get these upstreamed on FreeDesktop.org.
"image/x-qoi",
// Official MIME types. (Not registered yet!)
"image/qoi",
nullptr
}};
const TextureInfo QoiPrivate::textureInfo = {
exts.data(), mimeTypes.data()
};
QoiPrivate::QoiPrivate(Qoi *q, const IRpFilePtr &file)
: super(q, file, &textureInfo)
{
// Clear the Qoi header struct.
memset(&qoiHeader, 0, sizeof(qoiHeader));
}
/**
* Load the image.
* @return Image, or nullptr on error.
*/
rp_image_const_ptr QoiPrivate::loadImage(void)
{
if (img) {
// Image has already been loaded.
return img;
} else if (!this->isValid || !this->file) {
// Can't load the image.
return {};
}
// Sanity check: Maximum image dimensions of 32768x32768.
assert(qoiHeader.desc.width > 0);
assert(qoiHeader.desc.width <= 32768);
assert(qoiHeader.desc.height > 0);
assert(qoiHeader.desc.height <= 32768);
if (qoiHeader.desc.width == 0 || qoiHeader.desc.width > 32768 ||
qoiHeader.desc.height == 0 || qoiHeader.desc.height > 32768)
{
// Invalid image dimensions.
return {};
}
if (file->size() > 128*1024*1024) {
// Sanity check: Qoi files shouldn't be more than 128 MB.
return {};
}
const uint32_t file_sz = static_cast<uint32_t>(file->size());
// Qoi stores either 24-bit RGB or 32-bit RGBA image data.
// We want to read it in as 32-bit RGBA.
// Read in the entire file. (TODO: mmap?)
auto buf = aligned_uptr<uint8_t>(16, file_sz);
size_t size = file->seekAndRead(0, buf.get(), file_sz);
if (size != file_sz) {
// Seek and/or read error.
return {};
}
// Decode the image.
qoi_desc tmp_desc;
void *pixels = qoi_decode(buf.get(), file_sz, &tmp_desc, 4);
if (!pixels) {
// Error decoding the image.
return {};
}
buf.reset();
// Copy the decoded image into an rp_image.
rp_image *const tmp_img = new rp_image(qoiHeader.desc.width, qoiHeader.desc.height, rp_image::Format::ARGB32);
uint32_t *px_dest = static_cast<uint32_t*>(tmp_img->bits());
const uint32_t *px_src = static_cast<uint32_t*>(pixels);
const int src_stride = qoiHeader.desc.width;
const int src_bytes = src_stride * sizeof(*px_src);
const int dest_stride = tmp_img->stride() / sizeof(*px_dest);
for (unsigned int y = qoiHeader.desc.height; y > 0; y--) {
memcpy(px_dest, px_src, src_bytes);
px_dest += dest_stride;
px_src += src_stride;
}
free(pixels);
img.reset(tmp_img);
return img;
}
/** Qoi **/
/**
* Read a Quite OK Image Format image file.
*
* A ROM image must be opened by the caller. The file handle
* will be ref()'d and must be kept open in order to load
* data from the ROM image.
*
* To close the file, either delete this object or call close().
*
* NOTE: Check isValid() to determine if this is a valid ROM.
*
* @param file Open ROM image.
*/
Qoi::Qoi(const IRpFilePtr &file)
: super(new QoiPrivate(this, file))
{
RP_D(Qoi);
d->mimeType = "image/x-qoi"; // unofficial, not on fd.o
d->textureFormatName = "Quite OK Image Format";
if (!d->file) {
// Could not ref() the file handle.
return;
}
// Read the Qoi header.
d->file->rewind();
size_t size = d->file->read(&d->qoiHeader, sizeof(d->qoiHeader));
if (size != sizeof(d->qoiHeader)) {
d->file.reset();
return;
}
// Verify the Qoi magic.
if (d->qoiHeader.magic != cpu_to_be32(QOI_MAGIC_NUMBER)) {
// Incorrect magic.
d->file.reset();
return;
}
// File is valid.
d->isValid = true;
#if SYS_BYTEORDER == SYS_LIL_ENDIAN
// Header is stored in big-endian, so it always
// needs to be byteswapped on little-endian.
// NOTE: Magic number is *not* byteswapped.
d->qoiHeader.desc.width = be32_to_cpu(d->qoiHeader.desc.width);
d->qoiHeader.desc.height = be32_to_cpu(d->qoiHeader.desc.height);
#endif
// Cache the dimensions for the FileFormat base class.
d->dimensions[0] = d->qoiHeader.desc.width;
d->dimensions[1] = d->qoiHeader.desc.height;
}
/** Property accessors **/
/**
* Get the pixel format, e.g. "RGB888" or "DXT1".
* @return Pixel format, or nullptr if unavailable.
*/
const char *Qoi::pixelFormat(void) const
{
RP_D(const Qoi);
if (!d->isValid) {
return nullptr;
}
// TODO: Determine if the alpha channel is used at all.
return "ARGB32";
}
#ifdef ENABLE_LIBRPBASE_ROMFIELDS
/**
* Get property fields for rom-properties.
* @param fields RomFields object to which fields should be added.
* @return Number of fields added, or 0 on error.
*/
int Qoi::getFields(RomFields *fields) const
{
assert(fields != nullptr);
if (!fields)
return 0;
RP_D(const Qoi);
if (!d->isValid) {
// Unknown file type.
return -EIO;
}
const int initial_count = fields->count();
fields->reserve(initial_count + 1); // Maximum of 1 field.
// Qoi description struct
const qoi_desc *const desc = &d->qoiHeader.desc;
// Colorspace
const char *colorspace;
switch (desc->colorspace) {
default:
colorspace = nullptr;
break;
case 0:
colorspace = C_("Qoi|Colorspace", "sRGB with linear alpha");
break;
case 1:
colorspace = C_("Qoi|Colorspace", "all channels linear");
break;
}
if (colorspace) {
fields->addField_string(C_("Qoi", "Colorspace"), colorspace);
}
// Finished reading the field data.
return (fields->count() - initial_count);
}
#endif /* ENABLE_LIBRPBASE_ROMFIELDS */
/** Image accessors **/
/**
* Get the image.
* For textures with mipmaps, this is the largest mipmap.
* The image is owned by this object.
* @return Image, or nullptr on error.
*/
rp_image_const_ptr Qoi::image(void) const
{
RP_D(const Qoi);
if (!d->isValid) {
// Unknown file type.
return {};
}
// Load the image.
return const_cast<QoiPrivate*>(d)->loadImage();
}
} // namespace LibRpTexture

18
src/librptexture/fileformat/Qoi.hpp Normal file
View File

@ -0,0 +1,18 @@
/***************************************************************************
* ROM Properties Page shell extension. (librptexture) *
* Qoi.hpp: Quite OK Image Format image reader. *
* *
* Copyright (c) 2017-2025 by David Korth. *
* SPDX-License-Identifier: GPL-2.0-or-later *
***************************************************************************/
#pragma once
#include "FileFormat.hpp"
namespace LibRpTexture {
FILEFORMAT_DECL_BEGIN(Qoi)
FILEFORMAT_DECL_END()
}

2
xdg/mime.thumbnail.types
View File

@ -130,6 +130,8 @@ image/x-godot-ctex # Godot CTEX (v4)
image/ktx # KhronosKTX
image/ktx2 # KhronosKTX2
image/x-pvr # PowerVR3
image/x-qoi # Qoi
image/qoi # Qoi
image/x-sega-pvr # SegaPVR
image/x-sega-gvr # SegaPVR
image/x-sega-svr # SegaPVR