bitmap-helpers.hh

Go to the documentation of this file.

/*
 * Scroom - Generic viewer for 2D data
 * Copyright (C) 2009-2022 Kees-Jan Dijkzeul
 *
 * SPDX-License-Identifier: LGPL-2.1
 */
 
#pragma once
 
#include <type_traits>
 
#include <boost/operators.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/utility.hpp>
 
#include <cairo.h>
 
#include <scroom/global.hh>
 
namespace Scroom::Bitmap
{
  class BitmapSurface
  {
  public:
    using Ptr = boost::shared_ptr<BitmapSurface>;
 
  private:
    cairo_surface_t* const                 surface;
    boost::shared_ptr<unsigned char> const data;
 
  public:
    static Ptr create(int width, int height, cairo_format_t format);
    static Ptr create(int width, int height, cairo_format_t format, int stride, boost::shared_ptr<unsigned char> const& data);
 
    ~BitmapSurface();
    BitmapSurface(const BitmapSurface&)            = delete;
    BitmapSurface(BitmapSurface&&)                 = delete;
    BitmapSurface& operator=(const BitmapSurface&) = delete;
    BitmapSurface& operator=(BitmapSurface&&)      = delete;
 
    cairo_surface_t* get();
 
  private:
    BitmapSurface(int width, int height, cairo_format_t format);
    BitmapSurface(int width, int height, cairo_format_t format, int stride, boost::shared_ptr<unsigned char> const& data);
  };
 
  // SampleIterator
 
  template <typename ConstBase>
  class SampleIterator : public boost::addable2<SampleIterator<ConstBase>, unsigned int>
  {
  public:
    using Base = typename std::remove_const<ConstBase>::type;
 
    static const int bitsPerBase{8 * sizeof(ConstBase) / sizeof(byte)};
 
    const int       bps;
    const int       samplesPerBase;
    const int       pixelOffset;
    const ConstBase pixelMask;
 
    ConstBase* currentBase;
    int        currentOffset;
 
  private:
    static Base mask(int bps) { return (((ConstBase(1) << (bps - 1)) - 1) << 1) | 1; }
 
    SampleIterator(div_t d, ConstBase* base, int bps_)
      : bps(bps_)
      , samplesPerBase(bitsPerBase / bps)
      , pixelOffset(bps)
      , pixelMask(mask(bps))
      , currentBase(base + d.quot)
      , currentOffset(samplesPerBase - 1 - d.rem)
    {
    }
 
  public:
    // https://bugs.llvm.org/show_bug.cgi?id=37902
    // NOLINTNEXTLINE (cppcoreguidelines-pro-type-member-init,hicpp-member-init)
    explicit SampleIterator(ConstBase* base, int offset = 0, int bps_ = 1)
      : SampleIterator(div(offset, /* samplesPerBase */ bitsPerBase / bps_), base, bps_)
    {
    }
 
    Base get() { return (*currentBase >> (currentOffset * pixelOffset)) & pixelMask; }
 
    void set(ConstBase value)
    {
      *currentBase = (*currentBase & ~(pixelMask << currentOffset * pixelOffset)) | (value << (currentOffset * pixelOffset));
    }
 
    SampleIterator& operator++()
    {
      // Prefix operator
      if(!(currentOffset--))
      {
        currentOffset = samplesPerBase - 1;
        ++currentBase;
      }
 
      return *this;
    }
 
    SampleIterator operator++(int)
    {
      // Postfix operator
      SampleIterator<ConstBase> result = *this;
 
      if(!(currentOffset--))
      {
        currentOffset = samplesPerBase - 1;
        ++currentBase;
      }
 
      return result;
    }
 
    SampleIterator& operator+=(unsigned int x)
    {
      const int   offset = samplesPerBase - 1 - currentOffset + x;
      const div_t d      = div(offset, samplesPerBase);
      currentBase += d.quot;
      currentOffset = samplesPerBase - 1 - d.rem;
 
      return *this;
    }
 
    Base operator*() { return (*currentBase >> (currentOffset * pixelOffset)) & pixelMask; }
 
    bool operator==(const SampleIterator<ConstBase>& other) const
    {
      return currentBase == other.currentBase && currentOffset == other.currentOffset && bps == other.bps;
    }
  };
 
} // namespace Scroom::Bitmap