bitmap-helpers.hh

Go to the documentation of this file.

/*
 * Scroom - Generic viewer for 2D data
 * Copyright (C) 2009-2026 Kees-Jan Dijkzeul
 *
 * SPDX-License-Identifier: LGPL-2.1
 */
 
#pragma once
 
#include <memory>
#include <type_traits>
 
#include <boost/operators.hpp>
#include <boost/utility.hpp>
 
#include <cairo.h>
 
#include <scroom/global.hh>
 
namespace Scroom::Bitmap
{
  class BitmapSurface
  {
  public:
    using Ptr = std::shared_ptr<BitmapSurface>;
 
  private:
    cairo_surface_t* const surface;
    std::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, std::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, std::shared_ptr<unsigned char> const& data);
  };
 
  // SampleIterator
 
  template <typename ConstBase>
  class SampleIterator : public boost::addable2<SampleIterator<ConstBase>, unsigned int>
  {
  public:
    using Base = std::remove_const_t<ConstBase>;
 
    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;
    }
 
    bool operator!=(const SampleIterator<ConstBase>& other) const { return !(*this == other); }
  };
 
} // namespace Scroom::Bitmap