1 // Copyright 2014 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 // WebPPicture tools: copy, crop, rescaling and view. 11 // 12 // Author: Skal (pascal.massimino (at) gmail.com) 13 14 #include "src/webp/encode.h" 15 16 #if !defined(WEBP_REDUCE_SIZE) 17 18 #include <assert.h> 19 #include <stdlib.h> 20 21 #include "src/enc/vp8i_enc.h" 22 #include "src/utils/rescaler_utils.h" 23 #include "src/utils/utils.h" 24 25 #define HALVE(x) (((x) + 1) >> 1) 26 27 // Grab the 'specs' (writer, *opaque, width, height...) from 'src' and copy them 28 // into 'dst'. Mark 'dst' as not owning any memory. 29 static void PictureGrabSpecs(const WebPPicture* const src, 30 WebPPicture* const dst) { 31 assert(src != NULL && dst != NULL); 32 *dst = *src; 33 WebPPictureResetBuffers(dst); 34 } 35 36 //------------------------------------------------------------------------------ 37 38 // Adjust top-left corner to chroma sample position. 39 static void SnapTopLeftPosition(const WebPPicture* const pic, 40 int* const left, int* const top) { 41 if (!pic->use_argb) { 42 *left &= ~1; 43 *top &= ~1; 44 } 45 } 46 47 // Adjust top-left corner and verify that the sub-rectangle is valid. 48 static int AdjustAndCheckRectangle(const WebPPicture* const pic, 49 int* const left, int* const top, 50 int width, int height) { 51 SnapTopLeftPosition(pic, left, top); 52 if ((*left) < 0 || (*top) < 0) return 0; 53 if (width <= 0 || height <= 0) return 0; 54 if ((*left) + width > pic->width) return 0; 55 if ((*top) + height > pic->height) return 0; 56 return 1; 57 } 58 59 int WebPPictureCopy(const WebPPicture* src, WebPPicture* dst) { 60 if (src == NULL || dst == NULL) return 0; 61 if (src == dst) return 1; 62 63 PictureGrabSpecs(src, dst); 64 if (!WebPPictureAlloc(dst)) return 0; 65 66 if (!src->use_argb) { 67 WebPCopyPlane(src->y, src->y_stride, 68 dst->y, dst->y_stride, dst->width, dst->height); 69 WebPCopyPlane(src->u, src->uv_stride, dst->u, dst->uv_stride, 70 HALVE(dst->width), HALVE(dst->height)); 71 WebPCopyPlane(src->v, src->uv_stride, dst->v, dst->uv_stride, 72 HALVE(dst->width), HALVE(dst->height)); 73 if (dst->a != NULL) { 74 WebPCopyPlane(src->a, src->a_stride, 75 dst->a, dst->a_stride, dst->width, dst->height); 76 } 77 } else { 78 WebPCopyPlane((const uint8_t*)src->argb, 4 * src->argb_stride, 79 (uint8_t*)dst->argb, 4 * dst->argb_stride, 80 4 * dst->width, dst->height); 81 } 82 return 1; 83 } 84 85 int WebPPictureIsView(const WebPPicture* picture) { 86 if (picture == NULL) return 0; 87 if (picture->use_argb) { 88 return (picture->memory_argb_ == NULL); 89 } 90 return (picture->memory_ == NULL); 91 } 92 93 int WebPPictureView(const WebPPicture* src, 94 int left, int top, int width, int height, 95 WebPPicture* dst) { 96 if (src == NULL || dst == NULL) return 0; 97 98 // verify rectangle position. 99 if (!AdjustAndCheckRectangle(src, &left, &top, width, height)) return 0; 100 101 if (src != dst) { // beware of aliasing! We don't want to leak 'memory_'. 102 PictureGrabSpecs(src, dst); 103 } 104 dst->width = width; 105 dst->height = height; 106 if (!src->use_argb) { 107 dst->y = src->y + top * src->y_stride + left; 108 dst->u = src->u + (top >> 1) * src->uv_stride + (left >> 1); 109 dst->v = src->v + (top >> 1) * src->uv_stride + (left >> 1); 110 dst->y_stride = src->y_stride; 111 dst->uv_stride = src->uv_stride; 112 if (src->a != NULL) { 113 dst->a = src->a + top * src->a_stride + left; 114 dst->a_stride = src->a_stride; 115 } 116 } else { 117 dst->argb = src->argb + top * src->argb_stride + left; 118 dst->argb_stride = src->argb_stride; 119 } 120 return 1; 121 } 122 123 //------------------------------------------------------------------------------ 124 // Picture cropping 125 126 int WebPPictureCrop(WebPPicture* pic, 127 int left, int top, int width, int height) { 128 WebPPicture tmp; 129 130 if (pic == NULL) return 0; 131 if (!AdjustAndCheckRectangle(pic, &left, &top, width, height)) return 0; 132 133 PictureGrabSpecs(pic, &tmp); 134 tmp.width = width; 135 tmp.height = height; 136 if (!WebPPictureAlloc(&tmp)) return 0; 137 138 if (!pic->use_argb) { 139 const int y_offset = top * pic->y_stride + left; 140 const int uv_offset = (top / 2) * pic->uv_stride + left / 2; 141 WebPCopyPlane(pic->y + y_offset, pic->y_stride, 142 tmp.y, tmp.y_stride, width, height); 143 WebPCopyPlane(pic->u + uv_offset, pic->uv_stride, 144 tmp.u, tmp.uv_stride, HALVE(width), HALVE(height)); 145 WebPCopyPlane(pic->v + uv_offset, pic->uv_stride, 146 tmp.v, tmp.uv_stride, HALVE(width), HALVE(height)); 147 148 if (tmp.a != NULL) { 149 const int a_offset = top * pic->a_stride + left; 150 WebPCopyPlane(pic->a + a_offset, pic->a_stride, 151 tmp.a, tmp.a_stride, width, height); 152 } 153 } else { 154 const uint8_t* const src = 155 (const uint8_t*)(pic->argb + top * pic->argb_stride + left); 156 WebPCopyPlane(src, pic->argb_stride * 4, (uint8_t*)tmp.argb, 157 tmp.argb_stride * 4, width * 4, height); 158 } 159 WebPPictureFree(pic); 160 *pic = tmp; 161 return 1; 162 } 163 164 //------------------------------------------------------------------------------ 165 // Simple picture rescaler 166 167 static void RescalePlane(const uint8_t* src, 168 int src_width, int src_height, int src_stride, 169 uint8_t* dst, 170 int dst_width, int dst_height, int dst_stride, 171 rescaler_t* const work, 172 int num_channels) { 173 WebPRescaler rescaler; 174 int y = 0; 175 WebPRescalerInit(&rescaler, src_width, src_height, 176 dst, dst_width, dst_height, dst_stride, 177 num_channels, work); 178 while (y < src_height) { 179 y += WebPRescalerImport(&rescaler, src_height - y, 180 src + y * src_stride, src_stride); 181 WebPRescalerExport(&rescaler); 182 } 183 } 184 185 static void AlphaMultiplyARGB(WebPPicture* const pic, int inverse) { 186 assert(pic->argb != NULL); 187 WebPMultARGBRows((uint8_t*)pic->argb, pic->argb_stride * sizeof(*pic->argb), 188 pic->width, pic->height, inverse); 189 } 190 191 static void AlphaMultiplyY(WebPPicture* const pic, int inverse) { 192 if (pic->a != NULL) { 193 WebPMultRows(pic->y, pic->y_stride, pic->a, pic->a_stride, 194 pic->width, pic->height, inverse); 195 } 196 } 197 198 int WebPPictureRescale(WebPPicture* pic, int width, int height) { 199 WebPPicture tmp; 200 int prev_width, prev_height; 201 rescaler_t* work; 202 203 if (pic == NULL) return 0; 204 prev_width = pic->width; 205 prev_height = pic->height; 206 if (!WebPRescalerGetScaledDimensions( 207 prev_width, prev_height, &width, &height)) { 208 return 0; 209 } 210 211 PictureGrabSpecs(pic, &tmp); 212 tmp.width = width; 213 tmp.height = height; 214 if (!WebPPictureAlloc(&tmp)) return 0; 215 216 if (!pic->use_argb) { 217 work = (rescaler_t*)WebPSafeMalloc(2ULL * width, sizeof(*work)); 218 if (work == NULL) { 219 WebPPictureFree(&tmp); 220 return 0; 221 } 222 // If present, we need to rescale alpha first (for AlphaMultiplyY). 223 if (pic->a != NULL) { 224 WebPInitAlphaProcessing(); 225 RescalePlane(pic->a, prev_width, prev_height, pic->a_stride, 226 tmp.a, width, height, tmp.a_stride, work, 1); 227 } 228 229 // We take transparency into account on the luma plane only. That's not 230 // totally exact blending, but still is a good approximation. 231 AlphaMultiplyY(pic, 0); 232 RescalePlane(pic->y, prev_width, prev_height, pic->y_stride, 233 tmp.y, width, height, tmp.y_stride, work, 1); 234 AlphaMultiplyY(&tmp, 1); 235 236 RescalePlane(pic->u, 237 HALVE(prev_width), HALVE(prev_height), pic->uv_stride, 238 tmp.u, 239 HALVE(width), HALVE(height), tmp.uv_stride, work, 1); 240 RescalePlane(pic->v, 241 HALVE(prev_width), HALVE(prev_height), pic->uv_stride, 242 tmp.v, 243 HALVE(width), HALVE(height), tmp.uv_stride, work, 1); 244 } else { 245 work = (rescaler_t*)WebPSafeMalloc(2ULL * width * 4, sizeof(*work)); 246 if (work == NULL) { 247 WebPPictureFree(&tmp); 248 return 0; 249 } 250 // In order to correctly interpolate colors, we need to apply the alpha 251 // weighting first (black-matting), scale the RGB values, and remove 252 // the premultiplication afterward (while preserving the alpha channel). 253 WebPInitAlphaProcessing(); 254 AlphaMultiplyARGB(pic, 0); 255 RescalePlane((const uint8_t*)pic->argb, prev_width, prev_height, 256 pic->argb_stride * 4, 257 (uint8_t*)tmp.argb, width, height, 258 tmp.argb_stride * 4, 259 work, 4); 260 AlphaMultiplyARGB(&tmp, 1); 261 } 262 WebPPictureFree(pic); 263 WebPSafeFree(work); 264 *pic = tmp; 265 return 1; 266 } 267 268 #else // defined(WEBP_REDUCE_SIZE) 269 270 int WebPPictureCopy(const WebPPicture* src, WebPPicture* dst) { 271 (void)src; 272 (void)dst; 273 return 0; 274 } 275 276 int WebPPictureIsView(const WebPPicture* picture) { 277 (void)picture; 278 return 0; 279 } 280 281 int WebPPictureView(const WebPPicture* src, 282 int left, int top, int width, int height, 283 WebPPicture* dst) { 284 (void)src; 285 (void)left; 286 (void)top; 287 (void)width; 288 (void)height; 289 (void)dst; 290 return 0; 291 } 292 293 int WebPPictureCrop(WebPPicture* pic, 294 int left, int top, int width, int height) { 295 (void)pic; 296 (void)left; 297 (void)top; 298 (void)width; 299 (void)height; 300 return 0; 301 } 302 303 int WebPPictureRescale(WebPPicture* pic, int width, int height) { 304 (void)pic; 305 (void)width; 306 (void)height; 307 return 0; 308 } 309 #endif // !defined(WEBP_REDUCE_SIZE) 310
