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