OperationsColormapped Class Reference

#include <layeroperations.hh>

Inheritance diagram for OperationsColormapped:

Collaboration diagram for OperationsColormapped:

Public Member Functions
	OperationsColormapped (ColormapProvider::Ptr colormapProvider, int bpp)
int	getBpp () override
Scroom::Utils::Stuff	cache (const ConstTile::Ptr &tile) override
void	reduce (Tile::Ptr target, ConstTile::Ptr source, int x, int y) override
Public Member Functions inherited from Operations
	Operations (ColormapProvider::Ptr colormapProvider, int bpp)
void	draw (cairo_t *cr, const ConstTile::Ptr &tile, Scroom::Utils::Rectangle< double > tileArea, Scroom::Utils::Rectangle< double > viewArea, int zoom, Scroom::Utils::Stuff cache) override
Public Member Functions inherited from CommonOperations
void	initializeCairo (cairo_t *cr) override
void	drawState (cairo_t *cr, TileState s, Scroom::Utils::Rectangle< double > viewArea) override
Scroom::Utils::Stuff	cacheZoom (const ConstTile::Ptr &tile, int zoom, Scroom::Utils::Stuff &cache) override

Static Public Member Functions
static Ptr	create (ColormapProvider::Ptr colormapProvider, int bpp)
Static Public Member Functions inherited from Operations
static Ptr	create (ColormapProvider::Ptr colormapProvider, int bpp)
Static Public Member Functions inherited from CommonOperations
static void	drawPixelValue (cairo_t *cr, int x, int y, int size, int value)
static void	drawPixelValue (cairo_t *cr, int x, int y, int size, int value, Color const &bgColor)

Additional Inherited Members
Public Types inherited from LayerOperations
using	Ptr = boost::shared_ptr< LayerOperations >
Protected Attributes inherited from Operations
ColormapProvider::Ptr	colormapProvider
const unsigned	bpp
const unsigned	pixelsPerByte
const unsigned	pixelOffset
const unsigned	pixelMask

Constructor & Destructor Documentation

OperationsColormapped()

OperationsColormapped::OperationsColormapped	(	ColormapProvider::Ptr	colormapProvider,
		int	bpp
	)

  : Operations(std::move(colormapProvider_), bpp_)
{
}

Referenced by create().

Here is the caller graph for this function:

Member Function Documentation

cache()

Scroom::Utils::Stuff OperationsColormapped::cache ( const ConstTile::Ptr &  tile )

overridevirtual

Cache data for use during later cacheZoom() calls.

This function is called for a given tile, and then the results are passed to the cacheZoom() function. Because draw() is called relatively frequently (i.e. when scrolling), it is recommended to do cpu-intensive work in the cache() and cacheZoom() functions, and then re-use the data to make the draw() faster.

The default implementation returns an empty reference, meaning nothing is cached. As a result, the draw() function will receive an empty reference.

Parameters

tile	the Tile for which caching is requested

Reimplemented from Operations.

{
  const int                              stride     = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, tile->width);
  boost::shared_ptr<unsigned char> const data       = shared_malloc(stride * tile->height);
  Colormap::Ptr const                    colormap   = colormapProvider->getColormap();
  const int                              multiplier = 2; // data is 2*bpp, containing 2 colors
 
  unsigned char* row = data.get();
  for(int j = 0; j < tile->height; j++, row += stride)
  {
    SampleIterator<const uint16_t> pixelIn(
      reinterpret_cast<uint16_t const*>(tile->data.get() + j * multiplier * tile->width / pixelsPerByte), 0, multiplier * bpp);
    auto* pixelOut = reinterpret_cast<uint32_t*>(row);
    for(int i = 0; i < tile->width; i++)
    {
      *pixelOut = mix(colormap->colors[*pixelIn & pixelMask], colormap->colors[*pixelIn >> pixelOffset], 0.5).getARGB32();
 
      pixelOut++;
      ++pixelIn;
    }
  }
 
  return BitmapSurface::create(tile->width, tile->height, CAIRO_FORMAT_ARGB32, stride, data);
}

Here is the call graph for this function:

create()

LayerOperations::Ptr OperationsColormapped::create ( ColormapProvider::Ptr  colormapProvider, int  bpp  )

static

{
  return Ptr(new OperationsColormapped(std::move(colormapProvider), bpp));
}

Referenced by Scroom::TiledBitmap::ColormappedBitmap(), Scroom::TiledBitmap::GreyscaleBitmap(), setupTest2bpp(), setupTest4bpp(), and setupTest8bppColormapped().

Here is the call graph for this function:

Here is the caller graph for this function:

getBpp()

int OperationsColormapped::getBpp ( )

overridevirtual

Return the number of bits per pixel that the layer will use.

This number will be used to compute the amount of memory required to store one tile

Reimplemented from Operations.

{ return 2 * bpp; }

reduce()

void OperationsColormapped::reduce ( Tile::Ptr  target, ConstTile::Ptr  source, int  x, int  y  )

overridevirtual

Reduce the source tile by a factor of 8

The target tile will contain data for 8*8 source tiles. Offsets x and y indicate which of those 64 source tiles is currently being processed

Parameters

target	Tile that will contain the reduced bitmap
source	Tile that is to be reduced
x	x-offset (0..7) of the source tile in the target tile
y	y-offset (0..7) of the source tile in the target tile

Note

The target tile belongs to a different layer, and hence possibly has a different bpp than the current one, depending on the LayerSpec given to createTiledBitmap()

Reimplemented from Operations.

{
  // Reducing by a factor 8. Source and target both 2*bpp, containing 2 colors
  const int   multiplier   = 2; // data is 2*bpp, containing 2 colors
  const int   sourceStride = multiplier * source->width / pixelsPerByte;
  const byte* sourceBase   = source->data.get();
 
  const int targetStride = multiplier * target->width / pixelsPerByte;
  byte*     targetBase =
    target->data.get() + target->height * y * targetStride / 8 + multiplier * target->width * x / 8 / pixelsPerByte;
 
  for(int j = 0; j < source->height / 8; j++, targetBase += targetStride, sourceBase += sourceStride * 8)
  {
    // Iterate vertically over target
    const byte*              sourcePtr = sourceBase;
    SampleIterator<uint16_t> targetPtr(reinterpret_cast<uint16_t*>(targetBase), 0, multiplier * bpp);
 
    for(int i = 0; i < source->width / 8; i++, sourcePtr += 8 * multiplier / pixelsPerByte, ++targetPtr)
    {
      // Iterate horizontally over target
 
      // Goal is to determine which value occurs most often in a 8*8
      // rectangle, and pick that value.
      const byte* base = sourcePtr;
      byte        lookup[pixelMask + 1];
      memset(lookup, 0, sizeof(lookup));
 
      for(int k = 0; k < 8; k++, base += sourceStride)
      {
        SampleIterator<const uint16_t> current(reinterpret_cast<uint16_t const*>(base), 0, multiplier * bpp);
        for(int l = 0; l < 8; l++, ++current)
        {
          ++lookup[*current & pixelMask];
          ++lookup[*current >> pixelOffset];
        }
      }
      unsigned first  = 0;
      unsigned second = 1;
      if(lookup[1] > lookup[0])
      {
        first  = 1;
        second = 0;
      }
      for(unsigned c = 2; c < pixelMask + 1; c++)
      {
        if(lookup[c] > lookup[first])
        {
          second = first;
          first  = c;
        }
        else if(lookup[c] > lookup[second])
        {
          second = c;
        }
      }
      if(lookup[second] == 0)
      {
        second = first;
      }
 
      targetPtr.set(first << pixelOffset | second);
    }
  }
}

Here is the call graph for this function:

---

The documentation for this class was generated from the following files:

• inc/scroom/layeroperations.hh
• libs/tiled-bitmap/src/layeroperations.cc