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 // functions for sample output.
11 //
12 // Author: Skal (pascal.massimino@gmail.com)
13 
14 #include <assert.h>
15 #include <stdlib.h>
16 #include "src/dec/vp8i_dec.h"
17 #include "src/dec/webpi_dec.h"
18 #include "src/dsp/dsp.h"
19 #include "src/dsp/yuv.h"
20 #include "src/utils/utils.h"
21 
22 //------------------------------------------------------------------------------
23 // Main YUV<->RGB conversion functions
24 
EmitYUV(const VP8Io * const io,WebPDecParams * const p)25 static int EmitYUV(const VP8Io* const io, WebPDecParams* const p) {
26   WebPDecBuffer* output = p->output;
27   const WebPYUVABuffer* const buf = &output->u.YUVA;
28   uint8_t* const y_dst = buf->y + (size_t)io->mb_y * buf->y_stride;
29   uint8_t* const u_dst = buf->u + (size_t)(io->mb_y >> 1) * buf->u_stride;
30   uint8_t* const v_dst = buf->v + (size_t)(io->mb_y >> 1) * buf->v_stride;
31   const int mb_w = io->mb_w;
32   const int mb_h = io->mb_h;
33   const int uv_w = (mb_w + 1) / 2;
34   const int uv_h = (mb_h + 1) / 2;
35   WebPCopyPlane(io->y, io->y_stride, y_dst, buf->y_stride, mb_w, mb_h);
36   WebPCopyPlane(io->u, io->uv_stride, u_dst, buf->u_stride, uv_w, uv_h);
37   WebPCopyPlane(io->v, io->uv_stride, v_dst, buf->v_stride, uv_w, uv_h);
38   return io->mb_h;
39 }
40 
41 // Point-sampling U/V sampler.
EmitSampledRGB(const VP8Io * const io,WebPDecParams * const p)42 static int EmitSampledRGB(const VP8Io* const io, WebPDecParams* const p) {
43   WebPDecBuffer* const output = p->output;
44   WebPRGBABuffer* const buf = &output->u.RGBA;
45   uint8_t* const dst = buf->rgba + (size_t)io->mb_y * buf->stride;
46   WebPSamplerProcessPlane(io->y, io->y_stride,
47                           io->u, io->v, io->uv_stride,
48                           dst, buf->stride, io->mb_w, io->mb_h,
49                           WebPSamplers[output->colorspace]);
50   return io->mb_h;
51 }
52 
53 //------------------------------------------------------------------------------
54 // Fancy upsampling
55 
56 #ifdef FANCY_UPSAMPLING
EmitFancyRGB(const VP8Io * const io,WebPDecParams * const p)57 static int EmitFancyRGB(const VP8Io* const io, WebPDecParams* const p) {
58   int num_lines_out = io->mb_h;   // a priori guess
59   const WebPRGBABuffer* const buf = &p->output->u.RGBA;
60   uint8_t* dst = buf->rgba + (size_t)io->mb_y * buf->stride;
61   WebPUpsampleLinePairFunc upsample = WebPUpsamplers[p->output->colorspace];
62   const uint8_t* cur_y = io->y;
63   const uint8_t* cur_u = io->u;
64   const uint8_t* cur_v = io->v;
65   const uint8_t* top_u = p->tmp_u;
66   const uint8_t* top_v = p->tmp_v;
67   int y = io->mb_y;
68   const int y_end = io->mb_y + io->mb_h;
69   const int mb_w = io->mb_w;
70   const int uv_w = (mb_w + 1) / 2;
71 
72   if (y == 0) {
73     // First line is special cased. We mirror the u/v samples at boundary.
74     upsample(cur_y, NULL, cur_u, cur_v, cur_u, cur_v, dst, NULL, mb_w);
75   } else {
76     // We can finish the left-over line from previous call.
77     upsample(p->tmp_y, cur_y, top_u, top_v, cur_u, cur_v,
78              dst - buf->stride, dst, mb_w);
79     ++num_lines_out;
80   }
81   // Loop over each output pairs of row.
82   for (; y + 2 < y_end; y += 2) {
83     top_u = cur_u;
84     top_v = cur_v;
85     cur_u += io->uv_stride;
86     cur_v += io->uv_stride;
87     dst += 2 * buf->stride;
88     cur_y += 2 * io->y_stride;
89     upsample(cur_y - io->y_stride, cur_y,
90              top_u, top_v, cur_u, cur_v,
91              dst - buf->stride, dst, mb_w);
92   }
93   // move to last row
94   cur_y += io->y_stride;
95   if (io->crop_top + y_end < io->crop_bottom) {
96     // Save the unfinished samples for next call (as we're not done yet).
97     memcpy(p->tmp_y, cur_y, mb_w * sizeof(*p->tmp_y));
98     memcpy(p->tmp_u, cur_u, uv_w * sizeof(*p->tmp_u));
99     memcpy(p->tmp_v, cur_v, uv_w * sizeof(*p->tmp_v));
100     // The fancy upsampler leaves a row unfinished behind
101     // (except for the very last row)
102     num_lines_out--;
103   } else {
104     // Process the very last row of even-sized picture
105     if (!(y_end & 1)) {
106       upsample(cur_y, NULL, cur_u, cur_v, cur_u, cur_v,
107                dst + buf->stride, NULL, mb_w);
108     }
109   }
110   return num_lines_out;
111 }
112 
113 #endif    /* FANCY_UPSAMPLING */
114 
115 //------------------------------------------------------------------------------
116 
FillAlphaPlane(uint8_t * dst,int w,int h,int stride)117 static void FillAlphaPlane(uint8_t* dst, int w, int h, int stride) {
118   int j;
119   for (j = 0; j < h; ++j) {
120     memset(dst, 0xff, w * sizeof(*dst));
121     dst += stride;
122   }
123 }
124 
EmitAlphaYUV(const VP8Io * const io,WebPDecParams * const p,int expected_num_lines_out)125 static int EmitAlphaYUV(const VP8Io* const io, WebPDecParams* const p,
126                         int expected_num_lines_out) {
127   const uint8_t* alpha = io->a;
128   const WebPYUVABuffer* const buf = &p->output->u.YUVA;
129   const int mb_w = io->mb_w;
130   const int mb_h = io->mb_h;
131   uint8_t* dst = buf->a + (size_t)io->mb_y * buf->a_stride;
132   int j;
133   (void)expected_num_lines_out;
134   assert(expected_num_lines_out == mb_h);
135   if (alpha != NULL) {
136     for (j = 0; j < mb_h; ++j) {
137       memcpy(dst, alpha, mb_w * sizeof(*dst));
138       alpha += io->width;
139       dst += buf->a_stride;
140     }
141   } else if (buf->a != NULL) {
142     // the user requested alpha, but there is none, set it to opaque.
143     FillAlphaPlane(dst, mb_w, mb_h, buf->a_stride);
144   }
145   return 0;
146 }
147 
GetAlphaSourceRow(const VP8Io * const io,const uint8_t ** alpha,int * const num_rows)148 static int GetAlphaSourceRow(const VP8Io* const io,
149                              const uint8_t** alpha, int* const num_rows) {
150   int start_y = io->mb_y;
151   *num_rows = io->mb_h;
152 
153   // Compensate for the 1-line delay of the fancy upscaler.
154   // This is similar to EmitFancyRGB().
155   if (io->fancy_upsampling) {
156     if (start_y == 0) {
157       // We don't process the last row yet. It'll be done during the next call.
158       --*num_rows;
159     } else {
160       --start_y;
161       // Fortunately, *alpha data is persistent, so we can go back
162       // one row and finish alpha blending, now that the fancy upscaler
163       // completed the YUV->RGB interpolation.
164       *alpha -= io->width;
165     }
166     if (io->crop_top + io->mb_y + io->mb_h == io->crop_bottom) {
167       // If it's the very last call, we process all the remaining rows!
168       *num_rows = io->crop_bottom - io->crop_top - start_y;
169     }
170   }
171   return start_y;
172 }
173 
EmitAlphaRGB(const VP8Io * const io,WebPDecParams * const p,int expected_num_lines_out)174 static int EmitAlphaRGB(const VP8Io* const io, WebPDecParams* const p,
175                         int expected_num_lines_out) {
176   const uint8_t* alpha = io->a;
177   if (alpha != NULL) {
178     const int mb_w = io->mb_w;
179     const WEBP_CSP_MODE colorspace = p->output->colorspace;
180     const int alpha_first =
181         (colorspace == MODE_ARGB || colorspace == MODE_Argb);
182     const WebPRGBABuffer* const buf = &p->output->u.RGBA;
183     int num_rows;
184     const size_t start_y = GetAlphaSourceRow(io, &alpha, &num_rows);
185     uint8_t* const base_rgba = buf->rgba + start_y * buf->stride;
186     uint8_t* const dst = base_rgba + (alpha_first ? 0 : 3);
187     const int has_alpha = WebPDispatchAlpha(alpha, io->width, mb_w,
188                                             num_rows, dst, buf->stride);
189     (void)expected_num_lines_out;
190     assert(expected_num_lines_out == num_rows);
191     // has_alpha is true if there's non-trivial alpha to premultiply with.
192     if (has_alpha && WebPIsPremultipliedMode(colorspace)) {
193       WebPApplyAlphaMultiply(base_rgba, alpha_first,
194                              mb_w, num_rows, buf->stride);
195     }
196   }
197   return 0;
198 }
199 
EmitAlphaRGBA4444(const VP8Io * const io,WebPDecParams * const p,int expected_num_lines_out)200 static int EmitAlphaRGBA4444(const VP8Io* const io, WebPDecParams* const p,
201                              int expected_num_lines_out) {
202   const uint8_t* alpha = io->a;
203   if (alpha != NULL) {
204     const int mb_w = io->mb_w;
205     const WEBP_CSP_MODE colorspace = p->output->colorspace;
206     const WebPRGBABuffer* const buf = &p->output->u.RGBA;
207     int num_rows;
208     const size_t start_y = GetAlphaSourceRow(io, &alpha, &num_rows);
209     uint8_t* const base_rgba = buf->rgba + start_y * buf->stride;
210 #if (WEBP_SWAP_16BIT_CSP == 1)
211     uint8_t* alpha_dst = base_rgba;
212 #else
213     uint8_t* alpha_dst = base_rgba + 1;
214 #endif
215     uint32_t alpha_mask = 0x0f;
216     int i, j;
217     for (j = 0; j < num_rows; ++j) {
218       for (i = 0; i < mb_w; ++i) {
219         // Fill in the alpha value (converted to 4 bits).
220         const uint32_t alpha_value = alpha[i] >> 4;
221         alpha_dst[2 * i] = (alpha_dst[2 * i] & 0xf0) | alpha_value;
222         alpha_mask &= alpha_value;
223       }
224       alpha += io->width;
225       alpha_dst += buf->stride;
226     }
227     (void)expected_num_lines_out;
228     assert(expected_num_lines_out == num_rows);
229     if (alpha_mask != 0x0f && WebPIsPremultipliedMode(colorspace)) {
230       WebPApplyAlphaMultiply4444(base_rgba, mb_w, num_rows, buf->stride);
231     }
232   }
233   return 0;
234 }
235 
236 //------------------------------------------------------------------------------
237 // YUV rescaling (no final RGB conversion needed)
238 
239 #if !defined(WEBP_REDUCE_SIZE)
Rescale(const uint8_t * src,int src_stride,int new_lines,WebPRescaler * const wrk)240 static int Rescale(const uint8_t* src, int src_stride,
241                    int new_lines, WebPRescaler* const wrk) {
242   int num_lines_out = 0;
243   while (new_lines > 0) {    // import new contributions of source rows.
244     const int lines_in = WebPRescalerImport(wrk, new_lines, src, src_stride);
245     src += lines_in * src_stride;
246     new_lines -= lines_in;
247     num_lines_out += WebPRescalerExport(wrk);    // emit output row(s)
248   }
249   return num_lines_out;
250 }
251 
EmitRescaledYUV(const VP8Io * const io,WebPDecParams * const p)252 static int EmitRescaledYUV(const VP8Io* const io, WebPDecParams* const p) {
253   const int mb_h = io->mb_h;
254   const int uv_mb_h = (mb_h + 1) >> 1;
255   WebPRescaler* const scaler = p->scaler_y;
256   int num_lines_out = 0;
257   if (WebPIsAlphaMode(p->output->colorspace) && io->a != NULL) {
258     // Before rescaling, we premultiply the luma directly into the io->y
259     // internal buffer. This is OK since these samples are not used for
260     // intra-prediction (the top samples are saved in cache_y_/u_/v_).
261     // But we need to cast the const away, though.
262     WebPMultRows((uint8_t*)io->y, io->y_stride,
263                  io->a, io->width, io->mb_w, mb_h, 0);
264   }
265   num_lines_out = Rescale(io->y, io->y_stride, mb_h, scaler);
266   Rescale(io->u, io->uv_stride, uv_mb_h, p->scaler_u);
267   Rescale(io->v, io->uv_stride, uv_mb_h, p->scaler_v);
268   return num_lines_out;
269 }
270 
EmitRescaledAlphaYUV(const VP8Io * const io,WebPDecParams * const p,int expected_num_lines_out)271 static int EmitRescaledAlphaYUV(const VP8Io* const io, WebPDecParams* const p,
272                                 int expected_num_lines_out) {
273   const WebPYUVABuffer* const buf = &p->output->u.YUVA;
274   uint8_t* const dst_a = buf->a + (size_t)p->last_y * buf->a_stride;
275   if (io->a != NULL) {
276     uint8_t* const dst_y = buf->y + (size_t)p->last_y * buf->y_stride;
277     const int num_lines_out = Rescale(io->a, io->width, io->mb_h, p->scaler_a);
278     assert(expected_num_lines_out == num_lines_out);
279     if (num_lines_out > 0) {   // unmultiply the Y
280       WebPMultRows(dst_y, buf->y_stride, dst_a, buf->a_stride,
281                    p->scaler_a->dst_width, num_lines_out, 1);
282     }
283   } else if (buf->a != NULL) {
284     // the user requested alpha, but there is none, set it to opaque.
285     assert(p->last_y + expected_num_lines_out <= io->scaled_height);
286     FillAlphaPlane(dst_a, io->scaled_width, expected_num_lines_out,
287                    buf->a_stride);
288   }
289   return 0;
290 }
291 
InitYUVRescaler(const VP8Io * const io,WebPDecParams * const p)292 static int InitYUVRescaler(const VP8Io* const io, WebPDecParams* const p) {
293   const int has_alpha = WebPIsAlphaMode(p->output->colorspace);
294   const WebPYUVABuffer* const buf = &p->output->u.YUVA;
295   const int out_width  = io->scaled_width;
296   const int out_height = io->scaled_height;
297   const int uv_out_width  = (out_width + 1) >> 1;
298   const int uv_out_height = (out_height + 1) >> 1;
299   const int uv_in_width  = (io->mb_w + 1) >> 1;
300   const int uv_in_height = (io->mb_h + 1) >> 1;
301   // scratch memory for luma rescaler
302   const size_t work_size = 2 * (size_t)out_width;
303   const size_t uv_work_size = 2 * uv_out_width;  // and for each u/v ones
304   uint64_t total_size;
305   size_t rescaler_size;
306   rescaler_t* work;
307   WebPRescaler* scalers;
308   const int num_rescalers = has_alpha ? 4 : 3;
309 
310   total_size = ((uint64_t)work_size + 2 * uv_work_size) * sizeof(*work);
311   if (has_alpha) {
312     total_size += (uint64_t)work_size * sizeof(*work);
313   }
314   rescaler_size = num_rescalers * sizeof(*p->scaler_y) + WEBP_ALIGN_CST;
315   total_size += rescaler_size;
316   if (!CheckSizeOverflow(total_size)) {
317     return 0;
318   }
319 
320   p->memory = WebPSafeMalloc(1ULL, (size_t)total_size);
321   if (p->memory == NULL) {
322     return 0;   // memory error
323   }
324   work = (rescaler_t*)p->memory;
325 
326   scalers = (WebPRescaler*)WEBP_ALIGN(
327       (const uint8_t*)work + total_size - rescaler_size);
328   p->scaler_y = &scalers[0];
329   p->scaler_u = &scalers[1];
330   p->scaler_v = &scalers[2];
331   p->scaler_a = has_alpha ? &scalers[3] : NULL;
332 
333   if (!WebPRescalerInit(p->scaler_y, io->mb_w, io->mb_h,
334                         buf->y, out_width, out_height, buf->y_stride, 1,
335                         work) ||
336       !WebPRescalerInit(p->scaler_u, uv_in_width, uv_in_height,
337                         buf->u, uv_out_width, uv_out_height, buf->u_stride, 1,
338                         work + work_size) ||
339       !WebPRescalerInit(p->scaler_v, uv_in_width, uv_in_height,
340                         buf->v, uv_out_width, uv_out_height, buf->v_stride, 1,
341                         work + work_size + uv_work_size)) {
342     return 0;
343   }
344   p->emit = EmitRescaledYUV;
345 
346   if (has_alpha) {
347     if (!WebPRescalerInit(p->scaler_a, io->mb_w, io->mb_h,
348                           buf->a, out_width, out_height, buf->a_stride, 1,
349                           work + work_size + 2 * uv_work_size)) {
350       return 0;
351     }
352     p->emit_alpha = EmitRescaledAlphaYUV;
353     WebPInitAlphaProcessing();
354   }
355   return 1;
356 }
357 
358 //------------------------------------------------------------------------------
359 // RGBA rescaling
360 
ExportRGB(WebPDecParams * const p,int y_pos)361 static int ExportRGB(WebPDecParams* const p, int y_pos) {
362   const WebPYUV444Converter convert =
363       WebPYUV444Converters[p->output->colorspace];
364   const WebPRGBABuffer* const buf = &p->output->u.RGBA;
365   uint8_t* dst = buf->rgba + (size_t)y_pos * buf->stride;
366   int num_lines_out = 0;
367   // For RGB rescaling, because of the YUV420, current scan position
368   // U/V can be +1/-1 line from the Y one.  Hence the double test.
369   while (WebPRescalerHasPendingOutput(p->scaler_y) &&
370          WebPRescalerHasPendingOutput(p->scaler_u)) {
371     assert(y_pos + num_lines_out < p->output->height);
372     assert(p->scaler_u->y_accum == p->scaler_v->y_accum);
373     WebPRescalerExportRow(p->scaler_y);
374     WebPRescalerExportRow(p->scaler_u);
375     WebPRescalerExportRow(p->scaler_v);
376     convert(p->scaler_y->dst, p->scaler_u->dst, p->scaler_v->dst,
377             dst, p->scaler_y->dst_width);
378     dst += buf->stride;
379     ++num_lines_out;
380   }
381   return num_lines_out;
382 }
383 
EmitRescaledRGB(const VP8Io * const io,WebPDecParams * const p)384 static int EmitRescaledRGB(const VP8Io* const io, WebPDecParams* const p) {
385   const int mb_h = io->mb_h;
386   const int uv_mb_h = (mb_h + 1) >> 1;
387   int j = 0, uv_j = 0;
388   int num_lines_out = 0;
389   while (j < mb_h) {
390     const int y_lines_in =
391         WebPRescalerImport(p->scaler_y, mb_h - j,
392                            io->y + (size_t)j * io->y_stride, io->y_stride);
393     j += y_lines_in;
394     if (WebPRescaleNeededLines(p->scaler_u, uv_mb_h - uv_j)) {
395       const int u_lines_in = WebPRescalerImport(
396           p->scaler_u, uv_mb_h - uv_j, io->u + (size_t)uv_j * io->uv_stride,
397           io->uv_stride);
398       const int v_lines_in = WebPRescalerImport(
399           p->scaler_v, uv_mb_h - uv_j, io->v + (size_t)uv_j * io->uv_stride,
400           io->uv_stride);
401       (void)v_lines_in;   // remove a gcc warning
402       assert(u_lines_in == v_lines_in);
403       uv_j += u_lines_in;
404     }
405     num_lines_out += ExportRGB(p, p->last_y + num_lines_out);
406   }
407   return num_lines_out;
408 }
409 
ExportAlpha(WebPDecParams * const p,int y_pos,int max_lines_out)410 static int ExportAlpha(WebPDecParams* const p, int y_pos, int max_lines_out) {
411   const WebPRGBABuffer* const buf = &p->output->u.RGBA;
412   uint8_t* const base_rgba = buf->rgba + (size_t)y_pos * buf->stride;
413   const WEBP_CSP_MODE colorspace = p->output->colorspace;
414   const int alpha_first =
415       (colorspace == MODE_ARGB || colorspace == MODE_Argb);
416   uint8_t* dst = base_rgba + (alpha_first ? 0 : 3);
417   int num_lines_out = 0;
418   const int is_premult_alpha = WebPIsPremultipliedMode(colorspace);
419   uint32_t non_opaque = 0;
420   const int width = p->scaler_a->dst_width;
421 
422   while (WebPRescalerHasPendingOutput(p->scaler_a) &&
423          num_lines_out < max_lines_out) {
424     assert(y_pos + num_lines_out < p->output->height);
425     WebPRescalerExportRow(p->scaler_a);
426     non_opaque |= WebPDispatchAlpha(p->scaler_a->dst, 0, width, 1, dst, 0);
427     dst += buf->stride;
428     ++num_lines_out;
429   }
430   if (is_premult_alpha && non_opaque) {
431     WebPApplyAlphaMultiply(base_rgba, alpha_first,
432                            width, num_lines_out, buf->stride);
433   }
434   return num_lines_out;
435 }
436 
ExportAlphaRGBA4444(WebPDecParams * const p,int y_pos,int max_lines_out)437 static int ExportAlphaRGBA4444(WebPDecParams* const p, int y_pos,
438                                int max_lines_out) {
439   const WebPRGBABuffer* const buf = &p->output->u.RGBA;
440   uint8_t* const base_rgba = buf->rgba + (size_t)y_pos * buf->stride;
441 #if (WEBP_SWAP_16BIT_CSP == 1)
442   uint8_t* alpha_dst = base_rgba;
443 #else
444   uint8_t* alpha_dst = base_rgba + 1;
445 #endif
446   int num_lines_out = 0;
447   const WEBP_CSP_MODE colorspace = p->output->colorspace;
448   const int width = p->scaler_a->dst_width;
449   const int is_premult_alpha = WebPIsPremultipliedMode(colorspace);
450   uint32_t alpha_mask = 0x0f;
451 
452   while (WebPRescalerHasPendingOutput(p->scaler_a) &&
453          num_lines_out < max_lines_out) {
454     int i;
455     assert(y_pos + num_lines_out < p->output->height);
456     WebPRescalerExportRow(p->scaler_a);
457     for (i = 0; i < width; ++i) {
458       // Fill in the alpha value (converted to 4 bits).
459       const uint32_t alpha_value = p->scaler_a->dst[i] >> 4;
460       alpha_dst[2 * i] = (alpha_dst[2 * i] & 0xf0) | alpha_value;
461       alpha_mask &= alpha_value;
462     }
463     alpha_dst += buf->stride;
464     ++num_lines_out;
465   }
466   if (is_premult_alpha && alpha_mask != 0x0f) {
467     WebPApplyAlphaMultiply4444(base_rgba, width, num_lines_out, buf->stride);
468   }
469   return num_lines_out;
470 }
471 
EmitRescaledAlphaRGB(const VP8Io * const io,WebPDecParams * const p,int expected_num_out_lines)472 static int EmitRescaledAlphaRGB(const VP8Io* const io, WebPDecParams* const p,
473                                 int expected_num_out_lines) {
474   if (io->a != NULL) {
475     WebPRescaler* const scaler = p->scaler_a;
476     int lines_left = expected_num_out_lines;
477     const int y_end = p->last_y + lines_left;
478     while (lines_left > 0) {
479       const int64_t row_offset = (int64_t)scaler->src_y - io->mb_y;
480       WebPRescalerImport(scaler, io->mb_h + io->mb_y - scaler->src_y,
481                          io->a + row_offset * io->width, io->width);
482       lines_left -= p->emit_alpha_row(p, y_end - lines_left, lines_left);
483     }
484   }
485   return 0;
486 }
487 
InitRGBRescaler(const VP8Io * const io,WebPDecParams * const p)488 static int InitRGBRescaler(const VP8Io* const io, WebPDecParams* const p) {
489   const int has_alpha = WebPIsAlphaMode(p->output->colorspace);
490   const int out_width  = io->scaled_width;
491   const int out_height = io->scaled_height;
492   const int uv_in_width  = (io->mb_w + 1) >> 1;
493   const int uv_in_height = (io->mb_h + 1) >> 1;
494   // scratch memory for one rescaler
495   const size_t work_size = 2 * (size_t)out_width;
496   rescaler_t* work;  // rescalers work area
497   uint8_t* tmp;   // tmp storage for scaled YUV444 samples before RGB conversion
498   uint64_t tmp_size1, tmp_size2, total_size;
499   size_t rescaler_size;
500   WebPRescaler* scalers;
501   const int num_rescalers = has_alpha ? 4 : 3;
502 
503   tmp_size1 = (uint64_t)num_rescalers * work_size;
504   tmp_size2 = (uint64_t)num_rescalers * out_width;
505   total_size = tmp_size1 * sizeof(*work) + tmp_size2 * sizeof(*tmp);
506   rescaler_size = num_rescalers * sizeof(*p->scaler_y) + WEBP_ALIGN_CST;
507   total_size += rescaler_size;
508   if (!CheckSizeOverflow(total_size)) {
509     return 0;
510   }
511 
512   p->memory = WebPSafeMalloc(1ULL, (size_t)total_size);
513   if (p->memory == NULL) {
514     return 0;   // memory error
515   }
516   work = (rescaler_t*)p->memory;
517   tmp = (uint8_t*)(work + tmp_size1);
518 
519   scalers = (WebPRescaler*)WEBP_ALIGN(
520       (const uint8_t*)work + total_size - rescaler_size);
521   p->scaler_y = &scalers[0];
522   p->scaler_u = &scalers[1];
523   p->scaler_v = &scalers[2];
524   p->scaler_a = has_alpha ? &scalers[3] : NULL;
525 
526   if (!WebPRescalerInit(p->scaler_y, io->mb_w, io->mb_h,
527                         tmp + 0 * out_width, out_width, out_height, 0, 1,
528                         work + 0 * work_size) ||
529       !WebPRescalerInit(p->scaler_u, uv_in_width, uv_in_height,
530                         tmp + 1 * out_width, out_width, out_height, 0, 1,
531                         work + 1 * work_size) ||
532       !WebPRescalerInit(p->scaler_v, uv_in_width, uv_in_height,
533                         tmp + 2 * out_width, out_width, out_height, 0, 1,
534                         work + 2 * work_size)) {
535     return 0;
536   }
537   p->emit = EmitRescaledRGB;
538   WebPInitYUV444Converters();
539 
540   if (has_alpha) {
541     if (!WebPRescalerInit(p->scaler_a, io->mb_w, io->mb_h,
542                           tmp + 3 * out_width, out_width, out_height, 0, 1,
543                           work + 3 * work_size)) {
544       return 0;
545     }
546     p->emit_alpha = EmitRescaledAlphaRGB;
547     if (p->output->colorspace == MODE_RGBA_4444 ||
548         p->output->colorspace == MODE_rgbA_4444) {
549       p->emit_alpha_row = ExportAlphaRGBA4444;
550     } else {
551       p->emit_alpha_row = ExportAlpha;
552     }
553     WebPInitAlphaProcessing();
554   }
555   return 1;
556 }
557 
558 #endif  // WEBP_REDUCE_SIZE
559 
560 //------------------------------------------------------------------------------
561 // Default custom functions
562 
CustomSetup(VP8Io * io)563 static int CustomSetup(VP8Io* io) {
564   WebPDecParams* const p = (WebPDecParams*)io->opaque;
565   const WEBP_CSP_MODE colorspace = p->output->colorspace;
566   const int is_rgb = WebPIsRGBMode(colorspace);
567   const int is_alpha = WebPIsAlphaMode(colorspace);
568 
569   p->memory = NULL;
570   p->emit = NULL;
571   p->emit_alpha = NULL;
572   p->emit_alpha_row = NULL;
573   if (!WebPIoInitFromOptions(p->options, io, is_alpha ? MODE_YUV : MODE_YUVA)) {
574     return 0;
575   }
576   if (is_alpha && WebPIsPremultipliedMode(colorspace)) {
577     WebPInitUpsamplers();
578   }
579   if (io->use_scaling) {
580 #if !defined(WEBP_REDUCE_SIZE)
581     const int ok = is_rgb ? InitRGBRescaler(io, p) : InitYUVRescaler(io, p);
582     if (!ok) {
583       return 0;    // memory error
584     }
585 #else
586     return 0;   // rescaling support not compiled
587 #endif
588   } else {
589     if (is_rgb) {
590       WebPInitSamplers();
591       p->emit = EmitSampledRGB;   // default
592       if (io->fancy_upsampling) {
593 #ifdef FANCY_UPSAMPLING
594         const int uv_width = (io->mb_w + 1) >> 1;
595         p->memory = WebPSafeMalloc(1ULL, (size_t)(io->mb_w + 2 * uv_width));
596         if (p->memory == NULL) {
597           return 0;   // memory error.
598         }
599         p->tmp_y = (uint8_t*)p->memory;
600         p->tmp_u = p->tmp_y + io->mb_w;
601         p->tmp_v = p->tmp_u + uv_width;
602         p->emit = EmitFancyRGB;
603         WebPInitUpsamplers();
604 #endif
605       }
606     } else {
607       p->emit = EmitYUV;
608     }
609     if (is_alpha) {  // need transparency output
610       p->emit_alpha =
611           (colorspace == MODE_RGBA_4444 || colorspace == MODE_rgbA_4444) ?
612               EmitAlphaRGBA4444
613           : is_rgb ? EmitAlphaRGB
614           : EmitAlphaYUV;
615       if (is_rgb) {
616         WebPInitAlphaProcessing();
617       }
618     }
619   }
620 
621   return 1;
622 }
623 
624 //------------------------------------------------------------------------------
625 
CustomPut(const VP8Io * io)626 static int CustomPut(const VP8Io* io) {
627   WebPDecParams* const p = (WebPDecParams*)io->opaque;
628   const int mb_w = io->mb_w;
629   const int mb_h = io->mb_h;
630   int num_lines_out;
631   assert(!(io->mb_y & 1));
632 
633   if (mb_w <= 0 || mb_h <= 0) {
634     return 0;
635   }
636   num_lines_out = p->emit(io, p);
637   if (p->emit_alpha != NULL) {
638     p->emit_alpha(io, p, num_lines_out);
639   }
640   p->last_y += num_lines_out;
641   return 1;
642 }
643 
644 //------------------------------------------------------------------------------
645 
CustomTeardown(const VP8Io * io)646 static void CustomTeardown(const VP8Io* io) {
647   WebPDecParams* const p = (WebPDecParams*)io->opaque;
648   WebPSafeFree(p->memory);
649   p->memory = NULL;
650 }
651 
652 //------------------------------------------------------------------------------
653 // Main entry point
654 
WebPInitCustomIo(WebPDecParams * const params,VP8Io * const io)655 void WebPInitCustomIo(WebPDecParams* const params, VP8Io* const io) {
656   io->put      = CustomPut;
657   io->setup    = CustomSetup;
658   io->teardown = CustomTeardown;
659   io->opaque   = params;
660 }
661 
662 //------------------------------------------------------------------------------
663