Home | History | Annotate | Download | only in enc
      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 <assert.h>
     15 #include <stdlib.h>
     16 
     17 #include "./vp8i_enc.h"
     18 #include "../utils/rescaler_utils.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 //------------------------------------------------------------------------------
    265