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 "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.
29static 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.
39static 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.
48static 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
59int 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
85int 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
93int 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
126int 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
167static 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
185static 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
191static 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
198int 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
270int WebPPictureCopy(const WebPPicture* src, WebPPicture* dst) {
271 (void)src;
272 (void)dst;
273 return 0;
274}
275
276int WebPPictureIsView(const WebPPicture* picture) {
277 (void)picture;
278 return 0;
279}
280
281int 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
293int 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
303int 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