// 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: alpha handling, etc.

//

// Author: Skal (pascal.massimino@gmail.com)

#include <assert.h>

#include "src/enc/vp8i_enc.h"

#include "src/dsp/yuv.h"

//------------------------------------------------------------------------------

// Helper: clean up fully transparent area to help compressibility.

#define SIZE 8

#define SIZE2 (SIZE / 2)

static int IsTransparentARGBArea(const uint32_t* ptr, int stride, int size) {

  int y, x;

  for (y = 0; y < size; ++y) {

    for (x = 0; x < size; ++x) {

      if (ptr[x] & 0xff000000u) {

        return 0;

      }

    }

    ptr += stride;

  }

  return 1;

}

static void Flatten(uint8_t* ptr, int v, int stride, int size) {

  int y;

  for (y = 0; y < size; ++y) {

    memset(ptr, v, size);

    ptr += stride;

  }

}

static void FlattenARGB(uint32_t* ptr, uint32_t v, int stride, int size) {

  int x, y;

  for (y = 0; y < size; ++y) {

    for (x = 0; x < size; ++x) ptr[x] = v;

    ptr += stride;

  }

}

// Smoothen the luma components of transparent pixels. Return true if the whole

// block is transparent.

static int SmoothenBlock(const uint8_t* a_ptr, int a_stride, uint8_t* y_ptr,

                         int y_stride, int width, int height) {

  int sum = 0, count = 0;

  int x, y;

  const uint8_t* alpha_ptr = a_ptr;

  uint8_t* luma_ptr = y_ptr;

  for (y = 0; y < height; ++y) {

    for (x = 0; x < width; ++x) {

      if (alpha_ptr[x] != 0) {

        ++count;

        sum += luma_ptr[x];

      }

    }

    alpha_ptr += a_stride;

    luma_ptr += y_stride;

  }

  if (count > 0 && count < width * height) {

    const uint8_t avg_u8 = (uint8_t)(sum / count);

    alpha_ptr = a_ptr;

    luma_ptr = y_ptr;

    for (y = 0; y < height; ++y) {

      for (x = 0; x < width; ++x) {

        if (alpha_ptr[x] == 0) luma_ptr[x] = avg_u8;

      }

      alpha_ptr += a_stride;

      luma_ptr += y_stride;

    }

  }

  return (count == 0);

}

void WebPReplaceTransparentPixels(WebPPicture* const pic, uint32_t color) {

  if (pic != NULL && pic->use_argb) {

    int y = pic->height;

    uint32_t* argb = pic->argb;

    color &= 0xffffffu;   // force alpha=0

    WebPInitAlphaProcessing();

    while (y-- > 0) {

      WebPAlphaReplace(argb, pic->width, color);

      argb += pic->argb_stride;

    }

  }

}

void WebPCleanupTransparentArea(WebPPicture* pic) {

  int x, y, w, h;

  if (pic == NULL) return;

  w = pic->width / SIZE;

  h = pic->height / SIZE;

  // note: we ignore the left-overs on right/bottom, except for SmoothenBlock().

  if (pic->use_argb) {

    uint32_t argb_value = 0;

    for (y = 0; y < h; ++y) {

      int need_reset = 1;

      for (x = 0; x < w; ++x) {

        const int off = (y * pic->argb_stride + x) * SIZE;

        if (IsTransparentARGBArea(pic->argb + off, pic->argb_stride, SIZE)) {

          if (need_reset) {

            argb_value = pic->argb[off];

            need_reset = 0;

          }

          FlattenARGB(pic->argb + off, argb_value, pic->argb_stride, SIZE);

        } else {

          need_reset = 1;

        }

      }

    }

  } else {

    const int width = pic->width;

    const int height = pic->height;

    const int y_stride = pic->y_stride;

    const int uv_stride = pic->uv_stride;

    const int a_stride = pic->a_stride;

    uint8_t* y_ptr = pic->y;

    uint8_t* u_ptr = pic->u;

    uint8_t* v_ptr = pic->v;

    const uint8_t* a_ptr = pic->a;

    int values[3] = { 0 };

    if (a_ptr == NULL || y_ptr == NULL || u_ptr == NULL || v_ptr == NULL) {

      return;

    }

    for (y = 0; y + SIZE <= height; y += SIZE) {

      int need_reset = 1;

      for (x = 0; x + SIZE <= width; x += SIZE) {

        if (SmoothenBlock(a_ptr + x, a_stride, y_ptr + x, y_stride,

                          SIZE, SIZE)) {

          if (need_reset) {

            values[0] = y_ptr[x];

            values[1] = u_ptr[x >> 1];

            values[2] = v_ptr[x >> 1];

            need_reset = 0;

          }

          Flatten(y_ptr + x,        values[0], y_stride,  SIZE);

          Flatten(u_ptr + (x >> 1), values[1], uv_stride, SIZE2);

          Flatten(v_ptr + (x >> 1), values[2], uv_stride, SIZE2);

        } else {

          need_reset = 1;

        }

      }

      if (x < width) {

        SmoothenBlock(a_ptr + x, a_stride, y_ptr + x, y_stride,

                      width - x, SIZE);

      }

      a_ptr += SIZE * a_stride;

      y_ptr += SIZE * y_stride;

      u_ptr += SIZE2 * uv_stride;

      v_ptr += SIZE2 * uv_stride;

    }

    if (y < height) {

      const int sub_height = height - y;

      for (x = 0; x + SIZE <= width; x += SIZE) {

        SmoothenBlock(a_ptr + x, a_stride, y_ptr + x, y_stride,

                      SIZE, sub_height);

      }

      if (x < width) {

        SmoothenBlock(a_ptr + x, a_stride, y_ptr + x, y_stride,

                      width - x, sub_height);

      }

    }

  }

}

#undef SIZE

#undef SIZE2

//------------------------------------------------------------------------------

// Blend color and remove transparency info

#define BLEND(V0, V1, ALPHA) \

    ((((V0) * (255 - (ALPHA)) + (V1) * (ALPHA)) * 0x101 + 256) >> 16)

#define BLEND_10BIT(V0, V1, ALPHA) \

    ((((V0) * (1020 - (ALPHA)) + (V1) * (ALPHA)) * 0x101 + 1024) >> 18)

static WEBP_INLINE uint32_t MakeARGB32(int r, int g, int b) {

  return (0xff000000u | (r << 16) | (g << 8) | b);

}

void WebPBlendAlpha(WebPPicture* picture, uint32_t background_rgb) {

  const int red = (background_rgb >> 16) & 0xff;

  const int green = (background_rgb >> 8) & 0xff;

  const int blue = (background_rgb >> 0) & 0xff;

  int x, y;

  if (picture == NULL) return;

  if (!picture->use_argb) {

    // omit last pixel during u/v loop

    const int uv_width = (picture->width >> 1);

    const int Y0 = VP8RGBToY(red, green, blue, YUV_HALF);

    // VP8RGBToU/V expects the u/v values summed over four pixels

    const int U0 = VP8RGBToU(4 * red, 4 * green, 4 * blue, 4 * YUV_HALF);

    const int V0 = VP8RGBToV(4 * red, 4 * green, 4 * blue, 4 * YUV_HALF);

    const int has_alpha = picture->colorspace & WEBP_CSP_ALPHA_BIT;

    uint8_t* y_ptr = picture->y;

    uint8_t* u_ptr = picture->u;

    uint8_t* v_ptr = picture->v;

    uint8_t* a_ptr = picture->a;

    if (!has_alpha || a_ptr == NULL) return;    // nothing to do

    for (y = 0; y < picture->height; ++y) {

      // Luma blending

      for (x = 0; x < picture->width; ++x) {

        const uint8_t alpha = a_ptr[x];

        if (alpha < 0xff) {

          y_ptr[x] = BLEND(Y0, y_ptr[x], alpha);

        }

      }

      // Chroma blending every even line

      if ((y & 1) == 0) {

        uint8_t* const a_ptr2 =

            (y + 1 == picture->height) ? a_ptr : a_ptr + picture->a_stride;

        for (x = 0; x < uv_width; ++x) {

          // Average four alpha values into a single blending weight.

          // TODO(skal): might lead to visible contouring. Can we do better?

          const uint32_t alpha =

              a_ptr[2 * x + 0] + a_ptr[2 * x + 1] +

              a_ptr2[2 * x + 0] + a_ptr2[2 * x + 1];

          u_ptr[x] = BLEND_10BIT(U0, u_ptr[x], alpha);

          v_ptr[x] = BLEND_10BIT(V0, v_ptr[x], alpha);

        }

        if (picture->width & 1) {  // rightmost pixel

          const uint32_t alpha = 2 * (a_ptr[2 * x + 0] + a_ptr2[2 * x + 0]);

          u_ptr[x] = BLEND_10BIT(U0, u_ptr[x], alpha);

          v_ptr[x] = BLEND_10BIT(V0, v_ptr[x], alpha);

        }

      } else {

        u_ptr += picture->uv_stride;

        v_ptr += picture->uv_stride;

      }

      memset(a_ptr, 0xff, picture->width);  // reset alpha value to opaque

      a_ptr += picture->a_stride;

      y_ptr += picture->y_stride;

    }

  } else {

    uint32_t* argb = picture->argb;

    const uint32_t background = MakeARGB32(red, green, blue);

    for (y = 0; y < picture->height; ++y) {

      for (x = 0; x < picture->width; ++x) {

        const int alpha = (argb[x] >> 24) & 0xff;

        if (alpha != 0xff) {

          if (alpha > 0) {

            int r = (argb[x] >> 16) & 0xff;

            int g = (argb[x] >>  8) & 0xff;

            int b = (argb[x] >>  0) & 0xff;

            r = BLEND(red, r, alpha);

            g = BLEND(green, g, alpha);

            b = BLEND(blue, b, alpha);

            argb[x] = MakeARGB32(r, g, b);

          } else {

            argb[x] = background;

          }

        }

      }

      argb += picture->argb_stride;

    }

  }

}

#undef BLEND

#undef BLEND_10BIT

//------------------------------------------------------------------------------