3f9cd9850eb8ae45191d0dd5ddb24250e58d2bb9
1 /* Copyright (C) 2021-2023 Harry Godden (hgn) - All Rights Reserved
3 * A portion of this file is copied and altered from the QOI projects' source,
4 * Originally written by Dominic Szablewski. It is slightly modified.
5 * For the original unaltered QOI header, you can find it here:
6 * https://github.com/phoboslab/qoi/blob/master/qoi.h
8 * Copyright (C) 2021, Dominic Szablewski
9 * SPDX-License-Identifier: MIT
12 Copyright (c) 2022 Dominic Szablewski - https://phoboslab.org
14 Permission is hereby granted, free of charge, to any person obtaining a copy
15 of this software and associated documentation files (the "Software"), to deal
16 in the Software without restriction, including without limitation the rights
17 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
18 copies of the Software, and to permit persons to whom the Software is
19 furnished to do so, subject to the following conditions:
21 The above copyright notice and this permission notice shall be included in all
22 copies or substantial portions of the Software.
24 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
25 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
26 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
27 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
28 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
29 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
38 #include "vg/vg_log.h"
40 #define STB_IMAGE_WRITE_IMPLEMENTATION
41 #include "vg/submodules/stb/stb_image_write.h"
45 #define STBI_MALLOC(X)
46 #define STBI_REALLOC(X,Y)
50 #define STBI_ONLY_JPEG
51 #define STBI_NO_THREAD_LOCALS
52 #define STB_IMAGE_IMPLEMENTATION
53 #include "vg/submodules/stb/stb_image.h"
60 #define VG_TEX2D_LINEAR 0x1
61 #define VG_TEX2D_NEAREST 0x2
62 #define VG_TEX2D_REPEAT 0x4
63 #define VG_TEX2D_CLAMP 0x8
64 #define VG_TEX2D_NOMIP 0x10
66 static u8 const_vg_tex2d_err
[] ={
67 0xff,0x00,0xff,0xff, 0x00,0x00,0x00,0xff,
68 0xff,0x00,0xff,0xff, 0x00,0x00,0x00,0xff,
69 0x00,0x00,0x00,0xff, 0xff,0x00,0xff,0xff,
70 0x00,0x00,0x00,0xff, 0xff,0x00,0xff,0xff,
71 0xff,0x00,0xff,0xff, 0x00,0x00,0x00,0xff,
72 0xff,0x00,0xff,0xff, 0x00,0x00,0x00,0xff,
73 0x00,0x00,0x00,0xff, 0xff,0x00,0xff,0xff,
74 0x00,0x00,0x00,0xff, 0xff,0x00,0xff,0xff,
83 unsigned char channels
;
84 unsigned char colorspace
;
88 #define QOI_ZEROARR(a) memset((a),0,sizeof(a))
91 #define QOI_OP_INDEX 0x00 /* 00xxxxxx */
92 #define QOI_OP_DIFF 0x40 /* 01xxxxxx */
93 #define QOI_OP_LUMA 0x80 /* 10xxxxxx */
94 #define QOI_OP_RUN 0xc0 /* 11xxxxxx */
95 #define QOI_OP_RGB 0xfe /* 11111110 */
96 #define QOI_OP_RGBA 0xff /* 11111111 */
98 #define QOI_MASK_2 0xc0 /* 11000000 */
100 #define QOI_COLOR_HASH(C) (C.rgba.r*3 + C.rgba.g*5 + C.rgba.b*7 + C.rgba.a*11)
102 (((unsigned int)'q') << 24 | ((unsigned int)'o') << 16 | \
103 ((unsigned int)'i') << 8 | ((unsigned int)'f'))
104 #define QOI_HEADER_SIZE 14
106 /* 2GB is the max file size that this implementation can safely handle. We guard
107 against anything larger than that, assuming the worst case with 5 bytes per
108 pixel, rounded down to a nice clean value. 400 million pixels ought to be
109 enough for anybody. */
110 #define QOI_PIXELS_MAX ((unsigned int)400000000)
113 struct { unsigned char r
, g
, b
, a
; } rgba
;
117 static const unsigned char qoi_padding
[8] = {0,0,0,0,0,0,0,1};
118 static u32
qoi_read_32( const u8
*bytes
, int *p
) {
119 u32 a
= bytes
[(*p
)++];
120 u32 b
= bytes
[(*p
)++];
121 u32 c
= bytes
[(*p
)++];
122 u32 d
= bytes
[(*p
)++];
123 return a
<< 24 | b
<< 16 | c
<< 8 | d
;
126 struct texture_load_info
{
128 u32 width
, height
, flags
;
132 static void async_vg_tex2d_upload( void *payload
, u32 size
)
134 if( vg_thread_purpose() != k_thread_purpose_main
){
135 vg_fatal_error( "Catastrophic programming error.\n" );
138 struct texture_load_info
*info
= payload
;
140 glGenTextures( 1, info
->dest
);
141 glBindTexture( GL_TEXTURE_2D
, *info
->dest
);
142 glTexImage2D( GL_TEXTURE_2D
, 0, GL_RGBA
, info
->width
, info
->height
,
143 0, GL_RGBA
, GL_UNSIGNED_BYTE
, info
->rgba
);
145 if( !(info
->flags
& VG_TEX2D_NOMIP
) ){
146 glGenerateMipmap( GL_TEXTURE_2D
);
149 if( info
->flags
& VG_TEX2D_LINEAR
){
150 if( info
->flags
& VG_TEX2D_NOMIP
){
151 glTexParameteri( GL_TEXTURE_2D
, GL_TEXTURE_MIN_FILTER
, GL_LINEAR
);
154 glTexParameteri( GL_TEXTURE_2D
, GL_TEXTURE_MIN_FILTER
,
155 GL_LINEAR_MIPMAP_LINEAR
);
157 glTexParameteri( GL_TEXTURE_2D
, GL_TEXTURE_MAG_FILTER
, GL_LINEAR
);
160 if( info
->flags
& VG_TEX2D_NEAREST
){
161 glTexParameteri( GL_TEXTURE_2D
, GL_TEXTURE_MIN_FILTER
, GL_NEAREST
);
162 glTexParameteri( GL_TEXTURE_2D
, GL_TEXTURE_MAG_FILTER
, GL_NEAREST
);
165 if( info
->flags
& VG_TEX2D_CLAMP
){
166 glTexParameteri( GL_TEXTURE_2D
, GL_TEXTURE_WRAP_S
, GL_CLAMP_TO_EDGE
);
167 glTexParameteri( GL_TEXTURE_2D
, GL_TEXTURE_WRAP_T
, GL_CLAMP_TO_EDGE
);
170 if( info
->flags
& VG_TEX2D_REPEAT
){
171 glTexParameteri( GL_TEXTURE_2D
, GL_TEXTURE_WRAP_S
, GL_REPEAT
);
172 glTexParameteri( GL_TEXTURE_2D
, GL_TEXTURE_WRAP_T
, GL_REPEAT
);
176 static void vg_tex2d_replace_with_error( GLuint
*dest
)
178 u32 hdr_size
= vg_align8(sizeof(struct texture_load_info
));
180 vg_async_item
*call
= vg_async_alloc( hdr_size
);
181 struct texture_load_info
*info
= call
->payload
;
184 info
->flags
= VG_TEX2D_NEAREST
|VG_TEX2D_REPEAT
|VG_TEX2D_NOMIP
;
187 info
->rgba
= const_vg_tex2d_err
;
189 vg_async_dispatch( call
, async_vg_tex2d_upload
);
193 void vg_tex2d_load_qoi_async( const u8
*bytes
, u32 size
,
194 u32 flags
, GLuint
*dest
)
197 qoi_rgba_t index
[64];
199 int px_len
, chunks_len
, px_pos
;
202 u32 channels
= 4; /* TODO */
208 (channels
!= 0 && channels
!= 3 && channels
!= 4) ||
209 size
< QOI_HEADER_SIZE
+ (int)sizeof(qoi_padding
)
211 vg_error( "Error while decoding qoi file: illegal parameters\n" );
212 vg_tex2d_replace_with_error( dest
);
216 header_magic
= qoi_read_32(bytes
, &p
);
217 desc
.width
= qoi_read_32(bytes
, &p
);
218 desc
.height
= qoi_read_32(bytes
, &p
);
219 desc
.channels
= bytes
[p
++];
220 desc
.colorspace
= bytes
[p
++];
223 desc
.width
== 0 || desc
.height
== 0 ||
224 desc
.channels
< 3 || desc
.channels
> 4 ||
225 desc
.colorspace
> 1 ||
226 header_magic
!= QOI_MAGIC
||
227 desc
.height
>= QOI_PIXELS_MAX
/ desc
.width
229 vg_error( "Error while decoding qoi file: invalid file\n" );
230 vg_tex2d_replace_with_error( dest
);
235 channels
= desc
.channels
;
238 px_len
= desc
.width
* desc
.height
* channels
;
240 /* allocate async call
241 * --------------------------
243 u32 hdr_size
= vg_align8(sizeof(struct texture_load_info
)),
244 tex_size
= vg_align8(px_len
);
246 vg_async_item
*call
= vg_async_alloc( hdr_size
+ tex_size
);
247 struct texture_load_info
*info
= call
->payload
;
251 info
->width
= desc
.width
;
252 info
->height
= desc
.height
;
253 info
->rgba
= ((u8
*)call
->payload
) + hdr_size
;
257 * ----------------------------
260 u8
*pixels
= info
->rgba
;
268 chunks_len
= size
- (int)sizeof(qoi_padding
);
269 for (px_pos
= 0; px_pos
< px_len
; px_pos
+= channels
) {
273 else if (p
< chunks_len
) {
276 if (b1
== QOI_OP_RGB
) {
277 px
.rgba
.r
= bytes
[p
++];
278 px
.rgba
.g
= bytes
[p
++];
279 px
.rgba
.b
= bytes
[p
++];
281 else if (b1
== QOI_OP_RGBA
) {
282 px
.rgba
.r
= bytes
[p
++];
283 px
.rgba
.g
= bytes
[p
++];
284 px
.rgba
.b
= bytes
[p
++];
285 px
.rgba
.a
= bytes
[p
++];
287 else if ((b1
& QOI_MASK_2
) == QOI_OP_INDEX
) {
290 else if ((b1
& QOI_MASK_2
) == QOI_OP_DIFF
) {
291 px
.rgba
.r
+= ((b1
>> 4) & 0x03) - 2;
292 px
.rgba
.g
+= ((b1
>> 2) & 0x03) - 2;
293 px
.rgba
.b
+= ( b1
& 0x03) - 2;
295 else if ((b1
& QOI_MASK_2
) == QOI_OP_LUMA
) {
297 int vg
= (b1
& 0x3f) - 32;
298 px
.rgba
.r
+= vg
- 8 + ((b2
>> 4) & 0x0f);
300 px
.rgba
.b
+= vg
- 8 + (b2
& 0x0f);
302 else if ((b1
& QOI_MASK_2
) == QOI_OP_RUN
) {
306 index
[QOI_COLOR_HASH(px
) % 64] = px
;
309 pixels
[px_pos
+ 0] = px
.rgba
.r
;
310 pixels
[px_pos
+ 1] = px
.rgba
.g
;
311 pixels
[px_pos
+ 2] = px
.rgba
.b
;
314 pixels
[px_pos
+ 3] = px
.rgba
.a
;
320 * --------------------------
323 vg_async_dispatch( call
, async_vg_tex2d_upload
);
327 void vg_tex2d_load_qoi_async_file( const char *path
, u32 flags
, GLuint
*dest
)
329 if( vg_thread_purpose() != k_thread_purpose_loader
)
330 vg_fatal_error( "wrong thread\n" );
332 vg_linear_clear( vg_mem
.scratch
);
335 const void *data
= vg_file_read( vg_mem
.scratch
, path
, &size
);
336 vg_tex2d_load_qoi_async( data
, size
, flags
, dest
);
339 #endif /* VG_TEX_H */