xref: /haiku/src/servers/app/drawing/AlphaMaskCache.h (revision b54b3ae511adea2783e1668ad5674c7584b753b4)

/*
 * Copyright 2015 Julian Harnath <julian.harnath@rwth-aachen.de>
 * All rights reserved. Distributed under the terms of the MIT license.
 */
#ifndef ALPHA_MASK_CACHE_H
#define ALPHA_MASK_CACHE_H

#include <set>

#include "ShapePrivate.h"
#include <Locker.h>
#include <kernel/OS.h>


class AlphaMask;
class ShapeAlphaMask;


class AlphaMaskCache {
private:
	enum {
		kMaxCacheBytes = 8 * 1024 * 1024 // 8 MiB
	};

public:
								AlphaMaskCache();
								~AlphaMaskCache();

	static	AlphaMaskCache*		Default();

			status_t			Put(ShapeAlphaMask* mask);
			ShapeAlphaMask*		Get(const shape_data& shape,
									AlphaMask* previousMask,
									bool inverse);

			void				Clear();

private:
			size_t				_FindUncachedPreviousMasks(AlphaMask* mask,
									bool reference);
			void				_PrintAndResetStatistics();

private:
	struct ShapeMaskElement {
		ShapeMaskElement(const shape_data* shape,
			ShapeAlphaMask* mask, AlphaMask* previousMask,
			bool inverse)
			:
			fShape(shape),
			fInverse(inverse),
			fMask(mask),
			fPreviousMask(previousMask)
		{
		}

		bool operator<(const ShapeMaskElement& other) const
		{
			if (fInverse != other.fInverse)
				return fInverse < other.fInverse;
			if (fPreviousMask != other.fPreviousMask)
				return fPreviousMask < other.fPreviousMask;

			// compare shapes
			if (fShape->ptCount != other.fShape->ptCount)
				return fShape->ptCount < other.fShape->ptCount;
			if (fShape->opCount != other.fShape->opCount)
				return fShape->opCount < other.fShape->opCount;
			int diff = memcmp(fShape->ptList, other.fShape->ptList,
				fShape->ptSize);
			if (diff != 0)
				return diff < 0;
			diff = memcmp(fShape->opList, other.fShape->opList,
				fShape->opSize);
			if (diff != 0)
				return diff < 0;

			// equal
			return false;
		}

		const shape_data*	fShape;
		bool				fInverse;
		ShapeAlphaMask*		fMask;
		AlphaMask*			fPreviousMask;
	};

private:
	typedef std::set<ShapeMaskElement> ShapeMaskSet;

	static	AlphaMaskCache		sDefaultInstance;

			BLocker				fLock;

			size_t				fCurrentCacheBytes;
			ShapeMaskSet		fShapeMasks;

			// Statistics counters
			uint32				fTooLargeMaskCount;
			uint32				fMasksReplacedCount;
			uint32				fHitCount;
			uint32				fMissCount;
			uint32				fLowerMaskReferencedCount;
};


#endif // ALPHA_MASK_CACHE_H