/
IMG_webp.c
276 lines (231 loc) · 7.5 KB
1
/*
2
SDL_image: An example image loading library for use with SDL
3
Copyright (C) 1997-2018 Sam Lantinga <slouken@libsdl.org>
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
20
21
22
23
24
25
26
27
28
29
*/
/* This is a WEBP image file loading framework */
#include "SDL_image.h"
#ifdef LOAD_WEBP
/*=============================================================================
File: SDL_webp.c
30
31
Purpose: A WEBP loader for the SDL library
Revision:
32
33
34
35
36
37
38
39
40
41
42
43
44
Created by: Michael Bonfils (Murlock) (26 November 2011)
murlock42@gmail.com
=============================================================================*/
#include "SDL_endian.h"
#ifdef macintosh
#define MACOS
#endif
#include <webp/decode.h>
static struct {
45
46
int loaded;
void *handle;
47
48
49
VP8StatusCode (*WebPGetFeaturesInternal) (const uint8_t *data, size_t data_size, WebPBitstreamFeatures* features, int decoder_abi_version);
uint8_t* (*WebPDecodeRGBInto) (const uint8_t* data, size_t data_size, uint8_t* output_buffer, size_t output_buffer_size, int output_stride);
uint8_t* (*WebPDecodeRGBAInto) (const uint8_t* data, size_t data_size, uint8_t* output_buffer, size_t output_buffer_size, int output_stride);
50
51
52
} lib;
#ifdef LOAD_WEBP_DYNAMIC
53
54
55
56
57
58
59
60
#define FUNCTION_LOADER(FUNC, SIG) \
lib.FUNC = (SIG) SDL_LoadFunction(lib.handle, #FUNC); \
if (lib.FUNC == NULL) { SDL_UnloadObject(lib.handle); return -1; }
#else
#define FUNCTION_LOADER(FUNC, SIG) \
lib.FUNC = FUNC;
#endif
61
62
int IMG_InitWEBP()
{
63
if ( lib.loaded == 0 ) {
64
#ifdef LOAD_WEBP_DYNAMIC
65
66
67
68
lib.handle = SDL_LoadObject(LOAD_WEBP_DYNAMIC);
if ( lib.handle == NULL ) {
return -1;
}
69
70
71
72
#endif
FUNCTION_LOADER(WebPGetFeaturesInternal, VP8StatusCode (*) (const uint8_t *data, size_t data_size, WebPBitstreamFeatures* features, int decoder_abi_version))
FUNCTION_LOADER(WebPDecodeRGBInto, uint8_t * (*) (const uint8_t* data, size_t data_size, uint8_t* output_buffer, size_t output_buffer_size, int output_stride))
FUNCTION_LOADER(WebPDecodeRGBAInto, uint8_t * (*) (const uint8_t* data, size_t data_size, uint8_t* output_buffer, size_t output_buffer_size, int output_stride))
73
74
75
76
}
++lib.loaded;
return 0;
77
78
79
}
void IMG_QuitWEBP()
{
80
81
82
83
if ( lib.loaded == 0 ) {
return;
}
if ( lib.loaded == 1 ) {
84
#ifdef LOAD_WEBP_DYNAMIC
85
SDL_UnloadObject(lib.handle);
86
#endif
87
88
}
--lib.loaded;
89
90
91
}
static int webp_getinfo( SDL_RWops *src, int *datasize ) {
92
93
94
95
96
97
98
99
100
101
Sint64 start;
int is_WEBP;
Uint8 magic[20];
if ( !src )
return 0;
start = SDL_RWtell(src);
is_WEBP = 0;
if ( SDL_RWread(src, magic, 1, sizeof(magic)) == sizeof(magic) ) {
if ( magic[ 0] == 'R' &&
102
103
104
105
106
107
108
109
110
111
magic[ 1] == 'I' &&
magic[ 2] == 'F' &&
magic[ 3] == 'F' &&
magic[ 8] == 'W' &&
magic[ 9] == 'E' &&
magic[10] == 'B' &&
magic[11] == 'P' &&
magic[12] == 'V' &&
magic[13] == 'P' &&
magic[14] == '8' &&
112
#if WEBP_DECODER_ABI_VERSION < 0x0003 /* old versions don't support WEBPVP8X and WEBPVP8L */
113
magic[15] == ' ') {
114
#else
115
(magic[15] == ' ' || magic[15] == 'X' || magic[15] == 'L')) {
116
#endif
117
118
is_WEBP = 1;
if ( datasize ) {
119
*datasize = (int)(SDL_RWseek(src, 0, RW_SEEK_END) - start);
120
121
122
123
124
}
}
}
SDL_RWseek(src, start, RW_SEEK_SET);
return(is_WEBP);
125
126
127
128
129
}
/* See if an image is contained in a data source */
int IMG_isWEBP(SDL_RWops *src)
{
130
return webp_getinfo( src, NULL );
131
132
133
134
}
SDL_Surface *IMG_LoadWEBP_RW(SDL_RWops *src)
{
135
136
137
138
139
140
141
142
143
144
Sint64 start;
const char *error = NULL;
SDL_Surface *volatile surface = NULL;
Uint32 Rmask;
Uint32 Gmask;
Uint32 Bmask;
Uint32 Amask;
WebPBitstreamFeatures features;
int raw_data_size;
uint8_t *raw_data = NULL;
145
int r;
146
147
148
149
150
151
152
153
154
uint8_t *ret;
if ( !src ) {
/* The error message has been set in SDL_RWFromFile */
return NULL;
}
start = SDL_RWtell(src);
155
if ( (IMG_Init(IMG_INIT_WEBP) & IMG_INIT_WEBP) == 0 ) {
156
157
158
159
160
161
162
163
164
165
166
goto error;
}
raw_data_size = -1;
if ( !webp_getinfo( src, &raw_data_size ) ) {
error = "Invalid WEBP";
goto error;
}
raw_data = (uint8_t*) SDL_malloc( raw_data_size );
if ( raw_data == NULL ) {
167
error = "Failed to allocate enough buffer for WEBP";
168
169
170
goto error;
}
171
r = (int)SDL_RWread(src, raw_data, 1, raw_data_size );
172
173
174
175
176
if ( r != raw_data_size ) {
error = "Failed to read WEBP";
goto error;
}
177
#if 0
178
179
180
181
182
183
// extract size of picture, not interesting since we don't know about alpha channel
int width = -1, height = -1;
if ( !WebPGetInfo( raw_data, raw_data_size, &width, &height ) ) {
printf("WebPGetInfo has failed\n" );
return NULL;
}
184
185
#endif
186
if ( lib.WebPGetFeaturesInternal( raw_data, raw_data_size, &features, WEBP_DECODER_ABI_VERSION ) != VP8_STATUS_OK ) {
187
188
189
error = "WebPGetFeatures has failed";
goto error;
}
190
191
/* Check if it's ok !*/
192
#if SDL_BYTEORDER == SDL_LIL_ENDIAN
193
194
195
196
Rmask = 0x000000FF;
Gmask = 0x0000FF00;
Bmask = 0x00FF0000;
Amask = (features.has_alpha) ? 0xFF000000 : 0;
197
#else
198
199
200
201
202
203
204
{
int s = (features.has_alpha) ? 0 : 8;
Rmask = 0xFF000000 >> s;
Gmask = 0x00FF0000 >> s;
Bmask = 0x0000FF00 >> s;
Amask = 0x000000FF >> s;
}
205
#endif
206
207
208
209
surface = SDL_CreateRGBSurface(SDL_SWSURFACE,
features.width, features.height,
features.has_alpha?32:24, Rmask,Gmask,Bmask,Amask);
210
211
212
213
214
if ( surface == NULL ) {
error = "Failed to allocate SDL_Surface";
goto error;
}
215
216
if ( features.has_alpha ) {
217
ret = lib.WebPDecodeRGBAInto( raw_data, raw_data_size, (uint8_t *)surface->pixels, surface->pitch * surface->h, surface->pitch );
218
} else {
219
ret = lib.WebPDecodeRGBInto( raw_data, raw_data_size, (uint8_t *)surface->pixels, surface->pitch * surface->h, surface->pitch );
220
}
221
222
223
224
225
if ( !ret ) {
error = "Failed to decode WEBP";
goto error;
}
226
227
228
229
230
if ( raw_data ) {
SDL_free( raw_data );
}
231
return surface;
232
233
234
235
error:
236
237
238
if ( raw_data ) {
SDL_free( raw_data );
}
239
240
241
242
243
if ( surface ) {
SDL_FreeSurface( surface );
}
244
if ( error ) {
245
IMG_SetError( "%s", error );
246
}
247
248
249
SDL_RWseek(src, start, RW_SEEK_SET);
return(NULL);
250
251
252
253
254
255
}
#else
int IMG_InitWEBP()
{
256
257
IMG_SetError("WEBP images are not supported");
return(-1);
258
259
260
261
262
263
264
265
266
}
void IMG_QuitWEBP()
{
}
/* See if an image is contained in a data source */
int IMG_isWEBP(SDL_RWops *src)
{
267
return(0);
268
269
270
271
272
}
/* Load a WEBP type image from an SDL datasource */
SDL_Surface *IMG_LoadWEBP_RW(SDL_RWops *src)
{
273
return(NULL);
274
275
276
}
#endif /* LOAD_WEBP */