1 | // Copyright 2011 Google Inc. All Rights Reserved. |
2 | // |
3 | // Use of this source code is governed by a BSD-style license |
4 | // that can be found in the COPYING file in the root of the source |
5 | // tree. An additional intellectual property rights grant can be found |
6 | // in the file PATENTS. All contributing project authors may |
7 | // be found in the AUTHORS file in the root of the source tree. |
8 | // ----------------------------------------------------------------------------- |
9 | // |
10 | // Everything about WebPDecBuffer |
11 | // |
12 | // Author: Skal (pascal.massimino@gmail.com) |
13 | |
14 | #include <stdlib.h> |
15 | |
16 | #include "src/dec/vp8i_dec.h" |
17 | #include "src/dec/webpi_dec.h" |
18 | #include "src/utils/utils.h" |
19 | |
20 | //------------------------------------------------------------------------------ |
21 | // WebPDecBuffer |
22 | |
23 | // Number of bytes per pixel for the different color-spaces. |
24 | static const uint8_t kModeBpp[MODE_LAST] = { |
25 | 3, 4, 3, 4, 4, 2, 2, |
26 | 4, 4, 4, 2, // pre-multiplied modes |
27 | 1, 1 }; |
28 | |
29 | // Check that webp_csp_mode is within the bounds of WEBP_CSP_MODE. |
30 | // Convert to an integer to handle both the unsigned/signed enum cases |
31 | // without the need for casting to remove type limit warnings. |
32 | static int IsValidColorspace(int webp_csp_mode) { |
33 | return (webp_csp_mode >= MODE_RGB && webp_csp_mode < MODE_LAST); |
34 | } |
35 | |
36 | // strictly speaking, the very last (or first, if flipped) row |
37 | // doesn't require padding. |
38 | #define MIN_BUFFER_SIZE(WIDTH, HEIGHT, STRIDE) \ |
39 | ((uint64_t)(STRIDE) * ((HEIGHT) - 1) + (WIDTH)) |
40 | |
41 | static VP8StatusCode CheckDecBuffer(const WebPDecBuffer* const buffer) { |
42 | int ok = 1; |
43 | const WEBP_CSP_MODE mode = buffer->colorspace; |
44 | const int width = buffer->width; |
45 | const int height = buffer->height; |
46 | if (!IsValidColorspace(mode)) { |
47 | ok = 0; |
48 | } else if (!WebPIsRGBMode(mode)) { // YUV checks |
49 | const WebPYUVABuffer* const buf = &buffer->u.YUVA; |
50 | const int uv_width = (width + 1) / 2; |
51 | const int uv_height = (height + 1) / 2; |
52 | const int y_stride = abs(buf->y_stride); |
53 | const int u_stride = abs(buf->u_stride); |
54 | const int v_stride = abs(buf->v_stride); |
55 | const int a_stride = abs(buf->a_stride); |
56 | const uint64_t y_size = MIN_BUFFER_SIZE(width, height, y_stride); |
57 | const uint64_t u_size = MIN_BUFFER_SIZE(uv_width, uv_height, u_stride); |
58 | const uint64_t v_size = MIN_BUFFER_SIZE(uv_width, uv_height, v_stride); |
59 | const uint64_t a_size = MIN_BUFFER_SIZE(width, height, a_stride); |
60 | ok &= (y_size <= buf->y_size); |
61 | ok &= (u_size <= buf->u_size); |
62 | ok &= (v_size <= buf->v_size); |
63 | ok &= (y_stride >= width); |
64 | ok &= (u_stride >= uv_width); |
65 | ok &= (v_stride >= uv_width); |
66 | ok &= (buf->y != NULL); |
67 | ok &= (buf->u != NULL); |
68 | ok &= (buf->v != NULL); |
69 | if (mode == MODE_YUVA) { |
70 | ok &= (a_stride >= width); |
71 | ok &= (a_size <= buf->a_size); |
72 | ok &= (buf->a != NULL); |
73 | } |
74 | } else { // RGB checks |
75 | const WebPRGBABuffer* const buf = &buffer->u.RGBA; |
76 | const int stride = abs(buf->stride); |
77 | const uint64_t size = |
78 | MIN_BUFFER_SIZE(width * kModeBpp[mode], height, stride); |
79 | ok &= (size <= buf->size); |
80 | ok &= (stride >= width * kModeBpp[mode]); |
81 | ok &= (buf->rgba != NULL); |
82 | } |
83 | return ok ? VP8_STATUS_OK : VP8_STATUS_INVALID_PARAM; |
84 | } |
85 | #undef MIN_BUFFER_SIZE |
86 | |
87 | static VP8StatusCode AllocateBuffer(WebPDecBuffer* const buffer) { |
88 | const int w = buffer->width; |
89 | const int h = buffer->height; |
90 | const WEBP_CSP_MODE mode = buffer->colorspace; |
91 | |
92 | if (w <= 0 || h <= 0 || !IsValidColorspace(mode)) { |
93 | return VP8_STATUS_INVALID_PARAM; |
94 | } |
95 | |
96 | if (buffer->is_external_memory <= 0 && buffer->private_memory == NULL) { |
97 | uint8_t* output; |
98 | int uv_stride = 0, a_stride = 0; |
99 | uint64_t uv_size = 0, a_size = 0, total_size; |
100 | // We need memory and it hasn't been allocated yet. |
101 | // => initialize output buffer, now that dimensions are known. |
102 | int stride; |
103 | uint64_t size; |
104 | |
105 | if ((uint64_t)w * kModeBpp[mode] >= (1ull << 32)) { |
106 | return VP8_STATUS_INVALID_PARAM; |
107 | } |
108 | stride = w * kModeBpp[mode]; |
109 | size = (uint64_t)stride * h; |
110 | if (!WebPIsRGBMode(mode)) { |
111 | uv_stride = (w + 1) / 2; |
112 | uv_size = (uint64_t)uv_stride * ((h + 1) / 2); |
113 | if (mode == MODE_YUVA) { |
114 | a_stride = w; |
115 | a_size = (uint64_t)a_stride * h; |
116 | } |
117 | } |
118 | total_size = size + 2 * uv_size + a_size; |
119 | |
120 | // Security/sanity checks |
121 | output = (uint8_t*)WebPSafeMalloc(total_size, sizeof(*output)); |
122 | if (output == NULL) { |
123 | return VP8_STATUS_OUT_OF_MEMORY; |
124 | } |
125 | buffer->private_memory = output; |
126 | |
127 | if (!WebPIsRGBMode(mode)) { // YUVA initialization |
128 | WebPYUVABuffer* const buf = &buffer->u.YUVA; |
129 | buf->y = output; |
130 | buf->y_stride = stride; |
131 | buf->y_size = (size_t)size; |
132 | buf->u = output + size; |
133 | buf->u_stride = uv_stride; |
134 | buf->u_size = (size_t)uv_size; |
135 | buf->v = output + size + uv_size; |
136 | buf->v_stride = uv_stride; |
137 | buf->v_size = (size_t)uv_size; |
138 | if (mode == MODE_YUVA) { |
139 | buf->a = output + size + 2 * uv_size; |
140 | } |
141 | buf->a_size = (size_t)a_size; |
142 | buf->a_stride = a_stride; |
143 | } else { // RGBA initialization |
144 | WebPRGBABuffer* const buf = &buffer->u.RGBA; |
145 | buf->rgba = output; |
146 | buf->stride = stride; |
147 | buf->size = (size_t)size; |
148 | } |
149 | } |
150 | return CheckDecBuffer(buffer); |
151 | } |
152 | |
153 | VP8StatusCode WebPFlipBuffer(WebPDecBuffer* const buffer) { |
154 | if (buffer == NULL) { |
155 | return VP8_STATUS_INVALID_PARAM; |
156 | } |
157 | if (WebPIsRGBMode(buffer->colorspace)) { |
158 | WebPRGBABuffer* const buf = &buffer->u.RGBA; |
159 | buf->rgba += (buffer->height - 1) * buf->stride; |
160 | buf->stride = -buf->stride; |
161 | } else { |
162 | WebPYUVABuffer* const buf = &buffer->u.YUVA; |
163 | const int H = buffer->height; |
164 | buf->y += (H - 1) * buf->y_stride; |
165 | buf->y_stride = -buf->y_stride; |
166 | buf->u += ((H - 1) >> 1) * buf->u_stride; |
167 | buf->u_stride = -buf->u_stride; |
168 | buf->v += ((H - 1) >> 1) * buf->v_stride; |
169 | buf->v_stride = -buf->v_stride; |
170 | if (buf->a != NULL) { |
171 | buf->a += (H - 1) * buf->a_stride; |
172 | buf->a_stride = -buf->a_stride; |
173 | } |
174 | } |
175 | return VP8_STATUS_OK; |
176 | } |
177 | |
178 | VP8StatusCode WebPAllocateDecBuffer(int width, int height, |
179 | const WebPDecoderOptions* const options, |
180 | WebPDecBuffer* const buffer) { |
181 | VP8StatusCode status; |
182 | if (buffer == NULL || width <= 0 || height <= 0) { |
183 | return VP8_STATUS_INVALID_PARAM; |
184 | } |
185 | if (options != NULL) { // First, apply options if there is any. |
186 | if (options->use_cropping) { |
187 | const int cw = options->crop_width; |
188 | const int ch = options->crop_height; |
189 | const int x = options->crop_left & ~1; |
190 | const int y = options->crop_top & ~1; |
191 | if (x < 0 || y < 0 || cw <= 0 || ch <= 0 || |
192 | x + cw > width || y + ch > height) { |
193 | return VP8_STATUS_INVALID_PARAM; // out of frame boundary. |
194 | } |
195 | width = cw; |
196 | height = ch; |
197 | } |
198 | |
199 | if (options->use_scaling) { |
200 | #if !defined(WEBP_REDUCE_SIZE) |
201 | int scaled_width = options->scaled_width; |
202 | int scaled_height = options->scaled_height; |
203 | if (!WebPRescalerGetScaledDimensions( |
204 | width, height, &scaled_width, &scaled_height)) { |
205 | return VP8_STATUS_INVALID_PARAM; |
206 | } |
207 | width = scaled_width; |
208 | height = scaled_height; |
209 | #else |
210 | return VP8_STATUS_INVALID_PARAM; // rescaling not supported |
211 | #endif |
212 | } |
213 | } |
214 | buffer->width = width; |
215 | buffer->height = height; |
216 | |
217 | // Then, allocate buffer for real. |
218 | status = AllocateBuffer(buffer); |
219 | if (status != VP8_STATUS_OK) return status; |
220 | |
221 | // Use the stride trick if vertical flip is needed. |
222 | if (options != NULL && options->flip) { |
223 | status = WebPFlipBuffer(buffer); |
224 | } |
225 | return status; |
226 | } |
227 | |
228 | //------------------------------------------------------------------------------ |
229 | // constructors / destructors |
230 | |
231 | int WebPInitDecBufferInternal(WebPDecBuffer* buffer, int version) { |
232 | if (WEBP_ABI_IS_INCOMPATIBLE(version, WEBP_DECODER_ABI_VERSION)) { |
233 | return 0; // version mismatch |
234 | } |
235 | if (buffer == NULL) return 0; |
236 | memset(buffer, 0, sizeof(*buffer)); |
237 | return 1; |
238 | } |
239 | |
240 | void WebPFreeDecBuffer(WebPDecBuffer* buffer) { |
241 | if (buffer != NULL) { |
242 | if (buffer->is_external_memory <= 0) { |
243 | WebPSafeFree(buffer->private_memory); |
244 | } |
245 | buffer->private_memory = NULL; |
246 | } |
247 | } |
248 | |
249 | void WebPCopyDecBuffer(const WebPDecBuffer* const src, |
250 | WebPDecBuffer* const dst) { |
251 | if (src != NULL && dst != NULL) { |
252 | *dst = *src; |
253 | if (src->private_memory != NULL) { |
254 | dst->is_external_memory = 1; // dst buffer doesn't own the memory. |
255 | dst->private_memory = NULL; |
256 | } |
257 | } |
258 | } |
259 | |
260 | // Copy and transfer ownership from src to dst (beware of parameter order!) |
261 | void WebPGrabDecBuffer(WebPDecBuffer* const src, WebPDecBuffer* const dst) { |
262 | if (src != NULL && dst != NULL) { |
263 | *dst = *src; |
264 | if (src->private_memory != NULL) { |
265 | src->is_external_memory = 1; // src relinquishes ownership |
266 | src->private_memory = NULL; |
267 | } |
268 | } |
269 | } |
270 | |
271 | VP8StatusCode WebPCopyDecBufferPixels(const WebPDecBuffer* const src_buf, |
272 | WebPDecBuffer* const dst_buf) { |
273 | assert(src_buf != NULL && dst_buf != NULL); |
274 | assert(src_buf->colorspace == dst_buf->colorspace); |
275 | |
276 | dst_buf->width = src_buf->width; |
277 | dst_buf->height = src_buf->height; |
278 | if (CheckDecBuffer(dst_buf) != VP8_STATUS_OK) { |
279 | return VP8_STATUS_INVALID_PARAM; |
280 | } |
281 | if (WebPIsRGBMode(src_buf->colorspace)) { |
282 | const WebPRGBABuffer* const src = &src_buf->u.RGBA; |
283 | const WebPRGBABuffer* const dst = &dst_buf->u.RGBA; |
284 | WebPCopyPlane(src->rgba, src->stride, dst->rgba, dst->stride, |
285 | src_buf->width * kModeBpp[src_buf->colorspace], |
286 | src_buf->height); |
287 | } else { |
288 | const WebPYUVABuffer* const src = &src_buf->u.YUVA; |
289 | const WebPYUVABuffer* const dst = &dst_buf->u.YUVA; |
290 | WebPCopyPlane(src->y, src->y_stride, dst->y, dst->y_stride, |
291 | src_buf->width, src_buf->height); |
292 | WebPCopyPlane(src->u, src->u_stride, dst->u, dst->u_stride, |
293 | (src_buf->width + 1) / 2, (src_buf->height + 1) / 2); |
294 | WebPCopyPlane(src->v, src->v_stride, dst->v, dst->v_stride, |
295 | (src_buf->width + 1) / 2, (src_buf->height + 1) / 2); |
296 | if (WebPIsAlphaMode(src_buf->colorspace)) { |
297 | WebPCopyPlane(src->a, src->a_stride, dst->a, dst->a_stride, |
298 | src_buf->width, src_buf->height); |
299 | } |
300 | } |
301 | return VP8_STATUS_OK; |
302 | } |
303 | |
304 | int WebPAvoidSlowMemory(const WebPDecBuffer* const output, |
305 | const WebPBitstreamFeatures* const features) { |
306 | assert(output != NULL); |
307 | return (output->is_external_memory >= 2) && |
308 | WebPIsPremultipliedMode(output->colorspace) && |
309 | (features != NULL && features->has_alpha); |
310 | } |
311 | |
312 | //------------------------------------------------------------------------------ |
313 | |