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