path: root/pdf/draw_utils.cc

// Copyright (c) 2011 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "pdf/draw_utils.h"

#include <math.h>
#include <stddef.h>
#include <stdint.h>
#include <algorithm>
#include <vector>

#include "base/logging.h"
#include "base/numerics/safe_math.h"

namespace chrome_pdf {

inline uint8_t GetBlue(const uint32_t& pixel) {
  return static_cast<uint8_t>(pixel & 0xFF);
}

inline uint8_t GetGreen(const uint32_t& pixel) {
  return static_cast<uint8_t>((pixel >> 8) & 0xFF);
}

inline uint8_t GetRed(const uint32_t& pixel) {
  return static_cast<uint8_t>((pixel >> 16) & 0xFF);
}

inline uint8_t GetAlpha(const uint32_t& pixel) {
  return static_cast<uint8_t>((pixel >> 24) & 0xFF);
}

inline uint32_t MakePixel(uint8_t red,
                          uint8_t green,
                          uint8_t blue,
                          uint8_t alpha) {
  return (static_cast<uint32_t>(alpha) << 24) |
      (static_cast<uint32_t>(red) << 16) |
      (static_cast<uint32_t>(green) << 8) |
      static_cast<uint32_t>(blue);
}

inline uint8_t GradientChannel(uint8_t start, uint8_t end, double ratio) {
  double new_channel = start - (static_cast<double>(start) - end) * ratio;
  if (new_channel < 0)
    return 0;
  if (new_channel > 255)
    return 255;
  return static_cast<uint8_t>(new_channel + 0.5);
}

inline uint8_t ProcessColor(uint8_t src_color,
                            uint8_t dest_color,
                            uint8_t alpha) {
  uint32_t processed = static_cast<uint32_t>(src_color) * alpha +
                       static_cast<uint32_t>(dest_color) * (0xFF - alpha);
  return static_cast<uint8_t>((processed / 0xFF) & 0xFF);
}

inline bool ImageDataContainsRect(const pp::ImageData& image_data,
                                  const pp::Rect& rect) {
  return rect.width() >= 0 && rect.height() >= 0 &&
      pp::Rect(image_data.size()).Contains(rect);
}

void AlphaBlend(const pp::ImageData& src,
                const pp::Rect& src_rc,
                pp::ImageData* dest,
                const pp::Point& dest_origin,
                uint8_t alpha_adjustment) {
  if (src_rc.IsEmpty() || !ImageDataContainsRect(src, src_rc))
    return;

  pp::Rect dest_rc(dest_origin, src_rc.size());
  if (dest_rc.IsEmpty() || !ImageDataContainsRect(*dest, dest_rc))
    return;

  const uint32_t* src_origin_pixel = src.GetAddr32(src_rc.point());
  uint32_t* dest_origin_pixel = dest->GetAddr32(dest_origin);

  int height = src_rc.height();
  int width = src_rc.width();
  for (int y = 0; y < height; y++) {
    const uint32_t* src_pixel = src_origin_pixel;
    uint32_t* dest_pixel = dest_origin_pixel;
    for (int x = 0; x < width; x++) {
      uint8_t alpha =
          static_cast<uint8_t>(static_cast<uint32_t>(alpha_adjustment) *
                               GetAlpha(*src_pixel) / 0xFF);
      uint8_t red =
          ProcessColor(GetRed(*src_pixel), GetRed(*dest_pixel), alpha);
      uint8_t green =
          ProcessColor(GetGreen(*src_pixel), GetGreen(*dest_pixel), alpha);
      uint8_t blue =
          ProcessColor(GetBlue(*src_pixel), GetBlue(*dest_pixel), alpha);
      *dest_pixel = MakePixel(red, green, blue, GetAlpha(*dest_pixel));

      src_pixel++;
      dest_pixel++;
    }
    src_origin_pixel = reinterpret_cast<const uint32_t*>(
        reinterpret_cast<const char*>(src_origin_pixel) + src.stride());
    dest_origin_pixel = reinterpret_cast<uint32_t*>(
        reinterpret_cast<char*>(dest_origin_pixel) + dest->stride());
  }
}

void GradientFill(pp::ImageData* image,
                  const pp::Rect& rc,
                  uint32_t start_color,
                  uint32_t end_color,
                  bool horizontal) {
  std::vector<uint32_t> colors;
  colors.resize(horizontal ? rc.width() : rc.height());
  for (size_t i = 0; i < colors.size(); ++i) {
    double ratio = static_cast<double>(i) / colors.size();
    colors[i] = MakePixel(
        GradientChannel(GetRed(start_color), GetRed(end_color), ratio),
        GradientChannel(GetGreen(start_color), GetGreen(end_color), ratio),
        GradientChannel(GetBlue(start_color), GetBlue(end_color), ratio),
        GradientChannel(GetAlpha(start_color), GetAlpha(end_color), ratio));
  }

  if (horizontal) {
    const void* data = &(colors[0]);
    size_t size = colors.size() * 4;
    uint32_t* origin_pixel = image->GetAddr32(rc.point());
    for (int y = 0; y < rc.height(); y++) {
      memcpy(origin_pixel, data, size);
      origin_pixel = reinterpret_cast<uint32_t*>(
          reinterpret_cast<char*>(origin_pixel) + image->stride());
    }
  } else {
    uint32_t* origin_pixel = image->GetAddr32(rc.point());
    for (int y = 0; y < rc.height(); y++) {
      uint32_t* pixel = origin_pixel;
      for (int x = 0; x < rc.width(); x++) {
        *pixel = colors[y];
        pixel++;
      }
      origin_pixel = reinterpret_cast<uint32_t*>(
          reinterpret_cast<char*>(origin_pixel) + image->stride());
    }
  }
}

void GradientFill(pp::Instance* instance,
                  pp::ImageData* image,
                  const pp::Rect& dirty_rc,
                  const pp::Rect& gradient_rc,
                  uint32_t start_color,
                  uint32_t end_color,
                  bool horizontal,
                  uint8_t transparency) {
  pp::Rect draw_rc = gradient_rc.Intersect(dirty_rc);
  if (draw_rc.IsEmpty())
    return;

  pp::ImageData gradient(instance, PP_IMAGEDATAFORMAT_BGRA_PREMUL,
      gradient_rc.size(), false);

  GradientFill(&gradient, pp::Rect(pp::Point(), gradient_rc.size()),
               start_color, end_color, horizontal);

  pp::Rect copy_rc(draw_rc);
  copy_rc.Offset(-gradient_rc.x(), -gradient_rc.y());
  AlphaBlend(gradient, copy_rc, image, draw_rc.point(), transparency);
}

void CopyImage(const pp::ImageData& src, const pp::Rect& src_rc,
               pp::ImageData* dest, const pp::Rect& dest_rc,
               bool stretch) {
  if (src_rc.IsEmpty() || !ImageDataContainsRect(src, src_rc))
    return;

  pp::Rect stretched_rc(dest_rc.point(),
                        stretch ? dest_rc.size() : src_rc.size());
  if (stretched_rc.IsEmpty() || !ImageDataContainsRect(*dest, stretched_rc))
    return;

  const uint32_t* src_origin_pixel = src.GetAddr32(src_rc.point());
  uint32_t* dest_origin_pixel = dest->GetAddr32(dest_rc.point());
  if (stretch) {
    double x_ratio = static_cast<double>(src_rc.width()) / dest_rc.width();
    double y_ratio = static_cast<double>(src_rc.height()) / dest_rc.height();
    int32_t height = dest_rc.height();
    int32_t width = dest_rc.width();
    for (int32_t y = 0; y < height; ++y) {
      uint32_t* dest_pixel = dest_origin_pixel;
      for (int32_t x = 0; x < width; ++x) {
        uint32_t src_x = static_cast<uint32_t>(x * x_ratio);
        uint32_t src_y = static_cast<uint32_t>(y * y_ratio);
        const uint32_t* src_pixel = src.GetAddr32(
            pp::Point(src_rc.x() + src_x, src_rc.y() + src_y));
        *dest_pixel = *src_pixel;
        dest_pixel++;
      }
      dest_origin_pixel = reinterpret_cast<uint32_t*>(
          reinterpret_cast<char*>(dest_origin_pixel) + dest->stride());
    }
  } else {
    int32_t height = src_rc.height();
    base::CheckedNumeric<int32_t> width_bytes = src_rc.width();
    width_bytes *= 4;
    for (int32_t y = 0; y < height; ++y) {
      memcpy(dest_origin_pixel, src_origin_pixel, width_bytes.ValueOrDie());
      src_origin_pixel = reinterpret_cast<const uint32_t*>(
          reinterpret_cast<const char*>(src_origin_pixel) + src.stride());
      dest_origin_pixel = reinterpret_cast<uint32_t*>(
          reinterpret_cast<char*>(dest_origin_pixel) + dest->stride());
    }
  }
}

void FillRect(pp::ImageData* image, const pp::Rect& rc, uint32_t color) {
  int height = rc.height();
  if (height == 0)
    return;

  // Fill in first row.
  uint32_t* top_line = image->GetAddr32(rc.point());
  int width = rc.width();
  for (int x = 0; x < width; x++)
    top_line[x] = color;

  // Fill in the rest of the rectangle.
  int byte_width = width * 4;
  uint32_t* cur_line = reinterpret_cast<uint32_t*>(
          reinterpret_cast<char*>(top_line) + image->stride());
  for (int y = 1; y < height; y++) {
    memcpy(cur_line, top_line, byte_width);
    cur_line = reinterpret_cast<uint32_t*>(
            reinterpret_cast<char*>(cur_line) + image->stride());
  }
}

ShadowMatrix::ShadowMatrix(uint32_t depth, double factor, uint32_t background)
    : depth_(depth), factor_(factor), background_(background) {
  DCHECK(depth_ > 0);
  matrix_.resize(depth_ * depth_);

  // pv - is a rounding power factor for smoothing corners.
  // pv = 2.0 will make corners completely round.
  const double pv = 4.0;
  // pow_pv - cache to avoid recalculating pow(x, pv) every time.
  std::vector<double> pow_pv(depth_, 0.0);

  double r = static_cast<double>(depth_);
  double coef = 256.0 / pow(r, factor);

  for (uint32_t y = 0; y < depth_; y++) {
    // Since matrix is symmetrical, we can reduce the number of calculations
    // by mirroring results.
    for (uint32_t x = 0; x <= y; x++) {
      // Fill cache if needed.
      if (pow_pv[x] == 0.0)
        pow_pv[x] =  pow(x, pv);
      if (pow_pv[y] == 0.0)
        pow_pv[y] =  pow(y, pv);

      // v - is a value for the smoothing function.
      // If x == 0 simplify calculations.
      double v = (x == 0) ? y : pow(pow_pv[x] + pow_pv[y], 1 / pv);

      // Smoothing function.
      // If factor == 1, smoothing will be linear from 0 to the end,
      // if 0 < factor < 1, smoothing will drop faster near 0.
      // if factor > 1, smoothing will drop faster near the end (depth).
      double f = 256.0 - coef * pow(v, factor);

      uint8_t alpha = 0;
      if (f > kOpaqueAlpha)
        alpha = kOpaqueAlpha;
      else if (f < kTransparentAlpha)
        alpha = kTransparentAlpha;
      else
        alpha = static_cast<uint8_t>(f);

      uint8_t red = ProcessColor(0, GetRed(background), alpha);
      uint8_t green = ProcessColor(0, GetGreen(background), alpha);
      uint8_t blue = ProcessColor(0, GetBlue(background), alpha);
      uint32_t pixel = MakePixel(red, green, blue, GetAlpha(background));

      // Mirror matrix.
      matrix_[y * depth_ + x] = pixel;
      matrix_[x * depth_ + y] = pixel;
    }
  }
}

ShadowMatrix::~ShadowMatrix() {
}

void PaintShadow(pp::ImageData* image,
                 const pp::Rect& clip_rc,
                 const pp::Rect& shadow_rc,
                 const ShadowMatrix& matrix) {
  pp::Rect draw_rc = shadow_rc.Intersect(clip_rc);
  if (draw_rc.IsEmpty())
    return;

  int32_t depth = static_cast<int32_t>(matrix.depth());
  for (int32_t y = draw_rc.y(); y < draw_rc.bottom(); y++) {
    for (int32_t x = draw_rc.x(); x < draw_rc.right(); x++) {
      int32_t matrix_x = std::max(depth + shadow_rc.x() - x - 1,
                                  depth - shadow_rc.right() + x);
      int32_t matrix_y = std::max(depth + shadow_rc.y() - y - 1,
                                  depth - shadow_rc.bottom() + y);
      uint32_t* pixel = image->GetAddr32(pp::Point(x, y));

      if (matrix_x < 0)
        matrix_x = 0;
      else if (matrix_x >= static_cast<int32_t>(depth))
        matrix_x = depth - 1;

      if (matrix_y < 0)
        matrix_y = 0;
      else if (matrix_y >= static_cast<int32_t>(depth))
        matrix_y = depth - 1;

      *pixel = matrix.GetValue(matrix_x, matrix_y);
    }
  }
}

void DrawShadow(pp::ImageData* image,
                const pp::Rect& shadow_rc,
                const pp::Rect& object_rc,
                const pp::Rect& clip_rc,
                const ShadowMatrix& matrix) {
  if (shadow_rc == object_rc)
    return;  // Nothing to paint.

  // Fill top part.
  pp::Rect rc(shadow_rc.point(),
              pp::Size(shadow_rc.width(), object_rc.y() - shadow_rc.y()));
  PaintShadow(image, rc.Intersect(clip_rc), shadow_rc, matrix);

  // Fill bottom part.
  rc = pp::Rect(shadow_rc.x(), object_rc.bottom(),
                shadow_rc.width(), shadow_rc.bottom() - object_rc.bottom());
  PaintShadow(image, rc.Intersect(clip_rc), shadow_rc, matrix);

  // Fill left part.
  rc = pp::Rect(shadow_rc.x(), object_rc.y(),
                object_rc.x() - shadow_rc.x(), object_rc.height());
  PaintShadow(image, rc.Intersect(clip_rc), shadow_rc, matrix);

  // Fill right part.
  rc = pp::Rect(object_rc.right(), object_rc.y(),
                shadow_rc.right() - object_rc.right(), object_rc.height());
  PaintShadow(image, rc.Intersect(clip_rc), shadow_rc, matrix);
}

}  // namespace chrome_pdf