image_impl.h

// Aseprite Document Library
// Copyright (C) 2018-2023  Igara Studio S.A.
// Copyright (C) 2001-2016  David Capello
//
// This file is released under the terms of the MIT license.
// Read LICENSE.txt for more information.

#ifndef DOC_IMAGE_IMPL_H_INCLUDED
#define DOC_IMAGE_IMPL_H_INCLUDED
#pragma once

#include <algorithm>
#include <cstdlib>
#include <cstring>

#include "doc/blend_funcs.h"
#include "doc/image.h"
#include "doc/image_bits.h"
#include "doc/image_iterator.h"
#include "doc/palette.h"

namespace doc {

  template<typename ImageTraits> class LockImageBits;

  template<class Traits>
  class ImageImpl : public Image {
  public:
    using traits_t = Traits;
    using address_t = typename traits_t::address_t;
    using const_address_t = typename traits_t::const_address_t;

  private:
    ImageBufferPtr m_buffer;
    address_t* m_rows;
    address_t m_bits;

    inline address_t getLineAddress(int y) {
      ASSERT(y >= 0 && y < height());
      return m_rows[y];
    }

    inline const_address_t getLineAddress(int y) const {
      ASSERT(y >= 0 && y < height());
      return m_rows[y];
    }

  public:
    inline address_t address(int x, int y) const {
      if constexpr (Traits::pixels_per_byte == 0) {
        return (address_t)(getLineAddress(y) + x);
      }
      else {
        return (address_t)(getLineAddress(y) + x / Traits::pixels_per_byte);
      }
    }

    ImageImpl(const ImageSpec& spec,
              const ImageBufferPtr& buffer)
      : Image(spec)
      , m_buffer(buffer)
    {
      ASSERT(Traits::color_mode == spec.colorMode());

      m_rowBytes = Traits::rowstride_bytes(width());

      const std::size_t for_rows = doc_align_size(sizeof(address_t) * height());
      const std::size_t for_pixels = m_rowBytes * height();
      const std::size_t required_size = for_pixels + for_rows;

      if (!m_buffer)
        m_buffer = std::make_shared<ImageBuffer>(required_size);
      else
        m_buffer->resizeIfNecessary(required_size);

      std::fill(m_buffer->buffer(),
                m_buffer->buffer()+required_size, 0);

      m_rows = (address_t*)m_buffer->buffer();
      m_bits = (address_t)(m_buffer->buffer() + for_rows);

      auto addr = (uint8_t*)m_bits;
      for (int y=0; y<height(); ++y) {
        m_rows[y] = (address_t)addr;
        addr += m_rowBytes;
      }
    }

    uint8_t* getPixelAddress(int x, int y) const override {
      ASSERT(x >= 0 && x < width());
      ASSERT(y >= 0 && y < height());

      return (uint8_t*)address(x, y);
    }

    color_t getPixel(int x, int y) const override {
      ASSERT(x >= 0 && x < width());
      ASSERT(y >= 0 && y < height());

      return *address(x, y);
    }

    void putPixel(int x, int y, color_t color) override {
      ASSERT(x >= 0 && x < width());
      ASSERT(y >= 0 && y < height());

      *address(x, y) = color;
    }

    void clear(color_t color) override {
      const int w = width();
      const int h = height();
      for (int y=0; y<h; ++y) {
        address_t p = address(0, y);
        std::fill(p, p+w, color);
      }
    }

    void copy(const Image* _src, gfx::Clip area) override {
      const ImageImpl<Traits>* src = (const ImageImpl<Traits>*)_src;
      address_t src_address;
      address_t dst_address;

      if (!area.clip(width(), height(), src->width(), src->height()))
        return;

      for (int end_y=area.dst.y+area.size.h;
           area.dst.y<end_y;
           ++area.dst.y, ++area.src.y) {
        src_address = src->address(area.src.x, area.src.y);
        dst_address = address(area.dst.x, area.dst.y);

        std::copy(src_address,
                  src_address + area.size.w,
                  dst_address);
      }
    }

    void drawHLine(int x1, int y, int x2, color_t color) override {
      LockImageBits<Traits> bits(this, gfx::Rect(x1, y, x2 - x1 + 1, 1));
      typename LockImageBits<Traits>::iterator it(bits.begin());
      typename LockImageBits<Traits>::iterator end(bits.end());

      for (; it != end; ++it)
        *it = color;
    }

    void fillRect(int x1, int y1, int x2, int y2, color_t color) override {
      // Fill the first line
      ImageImpl<Traits>::drawHLine(x1, y1, x2, color);

      // Copy all other lines
      address_t first = address(x1, y1);
      int w = x2 - x1 + 1;
      for (int y=y1; y<=y2; ++y)
        std::copy(first, first+w, address(x1, y));
    }

    void blendRect(int x1, int y1, int x2, int y2, color_t color, int opacity) override {
      fillRect(x1, y1, x2, y2, color);
    }

  private:
    bool clip_rects(const Image* src, int& dst_x, int& dst_y, int& src_x, int& src_y, int& w, int& h) const {
      // Clip with destionation image
      if (dst_x < 0) {
        w += dst_x;
        src_x -= dst_x;
        dst_x = 0;
      }
      if (dst_y < 0) {
        h += dst_y;
        src_y -= dst_y;
        dst_y = 0;
      }
      if (dst_x+w > width()) {
        w = width() - dst_x;
      }
      if (dst_y+h > height()) {
        h = height() - dst_y;
      }

      // Clip with source image
      if (src_x < 0) {
        w += src_x;
        dst_x -= src_x;
        src_x = 0;
      }
      if (src_y < 0) {
        h += src_y;
        dst_y -= src_y;
        src_y = 0;
      }
      if (src_x+w > src->width()) {
        w = src->width() - src_x;
      }
      if (src_y+h > src->height()) {
        h = src->height() - src_y;
      }

      // Empty cases
      if (w < 1 || h < 1)
        return false;

      if ((src_x+w <= 0) || (src_x >= src->width()) ||
          (src_y+h <= 0) || (src_y >= src->height()))
        return false;

      if ((dst_x+w <= 0) || (dst_x >= width()) ||
          (dst_y+h <= 0) || (dst_y >= height()))
        return false;

      // Check this function is working correctly
      ASSERT(src->bounds().contains(gfx::Rect(src_x, src_y, w, h)));
      ASSERT(bounds().contains(gfx::Rect(dst_x, dst_y, w, h)));
      return true;
    }
  };

  //////////////////////////////////////////////////////////////////////
  // Specializations

  template<>
  inline void ImageImpl<IndexedTraits>::clear(color_t color) {
    uint8_t* p = address(0, 0);
    std::fill(p, p+rowBytes()*height(), color);
  }

  template<>
  inline void ImageImpl<BitmapTraits>::clear(color_t color) {
    uint8_t* p = address(0, 0);
    std::fill(p, p+rowBytes()*height(), (color ? 0xff: 0x00));
  }

  template<>
  inline color_t ImageImpl<BitmapTraits>::getPixel(int x, int y) const {
    ASSERT(x >= 0 && x < width());
    ASSERT(y >= 0 && y < height());

    std::div_t d = std::div(x, 8);
    return ((*(getLineAddress(y) + d.quot)) & (1<<d.rem)) ? 1: 0;
  }

  template<>
  inline void ImageImpl<BitmapTraits>::putPixel(int x, int y, color_t color) {
    ASSERT(x >= 0 && x < width());
    ASSERT(y >= 0 && y < height());

    std::div_t d = std::div(x, 8);
    if (color)
      (*(getLineAddress(y) + d.quot)) |= (1 << d.rem);
    else
      (*(getLineAddress(y) + d.quot)) &= ~(1 << d.rem);
  }

  template<>
  inline void ImageImpl<BitmapTraits>::fillRect(int x1, int y1, int x2, int y2, color_t color) {
    for (int y=y1; y<=y2; ++y)
      ImageImpl<BitmapTraits>::drawHLine(x1, y, x2, color);
  }

  template<>
  inline void ImageImpl<RgbTraits>::blendRect(int x1, int y1, int x2, int y2, color_t color, int opacity) {
    address_t addr;
    int x, y;

    for (y=y1; y<=y2; ++y) {
      addr = (address_t)getPixelAddress(x1, y);
      for (x=x1; x<=x2; ++x) {
        *addr = rgba_blender_normal(*addr, color, opacity);
        ++addr;
      }
    }
  }

  void copy_bitmaps(Image* dst, const Image* src, gfx::Clip area);
  template<>
  inline void ImageImpl<BitmapTraits>::copy(const Image* src, gfx::Clip area) {
    copy_bitmaps(this, src, area);
  }

} // namespace doc

#endif