libwebp: update to 0.4.4

third_party/libwebp/enc/picture_rescale.c

 // Copyright 2014 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 // WebPPicture tools: copy, crop, rescaling and view.
@@ skipping 157 matching lines @@
   return 1;
 }
 
 //------------------------------------------------------------------------------
 // Simple picture rescaler
 
 static void RescalePlane(const uint8_t* src,
                          int src_width, int src_height, int src_stride,
                          uint8_t* dst,
                          int dst_width, int dst_height, int dst_stride,
-                         int32_t* const work,
+                         rescaler_t* const work,
                          int num_channels) {
   WebPRescaler rescaler;
   int y = 0;
   WebPRescalerInit(&rescaler, src_width, src_height,
                    dst, dst_width, dst_height, dst_stride,
-                   num_channels,
-                   src_width, dst_width,
-                   src_height, dst_height,
-                   work);
-  memset(work, 0, 2 * dst_width * num_channels * sizeof(*work));
+                   num_channels, work);
   while (y < src_height) {
     y += WebPRescalerImport(&rescaler, src_height - y,
                             src + y * src_stride, src_stride);
     WebPRescalerExport(&rescaler);
   }
 }
 
 static void AlphaMultiplyARGB(WebPPicture* const pic, int inverse) {
   assert(pic->argb != NULL);
   WebPMultARGBRows((uint8_t*)pic->argb, pic->argb_stride * sizeof(*pic->argb),
                    pic->width, pic->height, inverse);
 }
 
 static void AlphaMultiplyY(WebPPicture* const pic, int inverse) {
   if (pic->a != NULL) {
     WebPMultRows(pic->y, pic->y_stride, pic->a, pic->a_stride,
                  pic->width, pic->height, inverse);
   }
 }
 
 int WebPPictureRescale(WebPPicture* pic, int width, int height) {
   WebPPicture tmp;
   int prev_width, prev_height;
-  int32_t* work;
+  rescaler_t* work;
 
   if (pic == NULL) return 0;
   prev_width = pic->width;
   prev_height = pic->height;
   // if width is unspecified, scale original proportionally to height ratio.
   if (width == 0) {
     width = (prev_width * height + prev_height / 2) / prev_height;
   }
   // if height is unspecified, scale original proportionally to width ratio.
   if (height == 0) {
     height = (prev_height * width + prev_width / 2) / prev_width;
   }
   // Check if the overall dimensions still make sense.
   if (width <= 0 || height <= 0) return 0;
 
   PictureGrabSpecs(pic, &tmp);
   tmp.width = width;
   tmp.height = height;
   if (!WebPPictureAlloc(&tmp)) return 0;
 
   if (!pic->use_argb) {
-    work = (int32_t*)WebPSafeMalloc(2ULL * width, sizeof(*work));
+    work = (rescaler_t*)WebPSafeMalloc(2ULL * width, sizeof(*work));
     if (work == NULL) {
       WebPPictureFree(&tmp);
       return 0;
     }
     // If present, we need to rescale alpha first (for AlphaMultiplyY).
     if (pic->a != NULL) {
       WebPInitAlphaProcessing();
       RescalePlane(pic->a, prev_width, prev_height, pic->a_stride,
                    tmp.a, width, height, tmp.a_stride, work, 1);
     }
 
     // We take transparency into account on the luma plane only. That's not
     // totally exact blending, but still is a good approximation.
     AlphaMultiplyY(pic, 0);
     RescalePlane(pic->y, prev_width, prev_height, pic->y_stride,
                  tmp.y, width, height, tmp.y_stride, work, 1);
     AlphaMultiplyY(&tmp, 1);
 
     RescalePlane(pic->u,
                  HALVE(prev_width), HALVE(prev_height), pic->uv_stride,
                  tmp.u,
                  HALVE(width), HALVE(height), tmp.uv_stride, work, 1);
     RescalePlane(pic->v,
                  HALVE(prev_width), HALVE(prev_height), pic->uv_stride,
                  tmp.v,
                  HALVE(width), HALVE(height), tmp.uv_stride, work, 1);
   } else {
-    work = (int32_t*)WebPSafeMalloc(2ULL * width * 4, sizeof(*work));
+    work = (rescaler_t*)WebPSafeMalloc(2ULL * width * 4, sizeof(*work));
     if (work == NULL) {
       WebPPictureFree(&tmp);
       return 0;
     }
     // In order to correctly interpolate colors, we need to apply the alpha
     // weighting first (black-matting), scale the RGB values, and remove
     // the premultiplication afterward (while preserving the alpha channel).
     WebPInitAlphaProcessing();
     AlphaMultiplyARGB(pic, 0);
     RescalePlane((const uint8_t*)pic->argb, prev_width, prev_height,
                  pic->argb_stride * 4,
                  (uint8_t*)tmp.argb, width, height,
                  tmp.argb_stride * 4,
                  work, 4);
     AlphaMultiplyARGB(&tmp, 1);
   }
   WebPPictureFree(pic);
   WebPSafeFree(work);
   *pic = tmp;
   return 1;
 }
 
 //------------------------------------------------------------------------------