#include "Sk64.h"
#include "SkColor.h"
+#include "SkColorTable.h"
#include "SkPoint.h"
#include "SkRefCnt.h"
static SkFixed ComputeMipLevel(SkFixed sx, SkFixed dy);
};
-/** \class SkColorTable
-
- SkColorTable holds an array SkPMColors (premultiplied 32-bit colors) used by
- 8-bit bitmaps, where the bitmap bytes are interpreted as indices into the colortable.
-*/
-class SkColorTable : public SkRefCnt {
-public:
- /** Makes a deep copy of colors.
- */
- SkColorTable(const SkColorTable& src);
- /** Preallocates the colortable to have 'count' colors, which
- * are initially set to 0.
- */
- explicit SkColorTable(int count);
- explicit SkColorTable(SkFlattenableReadBuffer&);
- SkColorTable(const SkPMColor colors[], int count);
- virtual ~SkColorTable();
-
- enum Flags {
- kColorsAreOpaque_Flag = 0x01 //!< if set, all of the colors in the table are opaque (alpha==0xFF)
- };
- /** Returns the flag bits for the color table. These can be changed with setFlags().
- */
- unsigned getFlags() const { return fFlags; }
- /** Set the flags for the color table. See the Flags enum for possible values.
- */
- void setFlags(unsigned flags);
-
- bool isOpaque() const { return (fFlags & kColorsAreOpaque_Flag) != 0; }
- void setIsOpaque(bool isOpaque);
-
- /** Returns the number of colors in the table.
- */
- int count() const { return fCount; }
-
- /** Returns the specified color from the table. In the debug build, this asserts that
- the index is in range (0 <= index < count).
- */
- SkPMColor operator[](int index) const {
- SkASSERT(fColors != NULL && (unsigned)index < fCount);
- return fColors[index];
- }
-
- /** Specify the number of colors in the color table. This does not initialize the colors
- to any value, just allocates memory for them. To initialize the values, either call
- setColors(array, count), or follow setCount(count) with a call to
- lockColors()/{set the values}/unlockColors(true).
- */
-// void setColors(int count) { this->setColors(NULL, count); }
-// void setColors(const SkPMColor[], int count);
-
- /** Return the array of colors for reading and/or writing. This must be
- balanced by a call to unlockColors(changed?), telling the colortable if
- the colors were changed during the lock.
- */
- SkPMColor* lockColors() {
- SkDEBUGCODE(fColorLockCount += 1;)
- return fColors;
- }
- /** Balancing call to lockColors(). If the colors have been changed, pass true.
- */
- void unlockColors(bool changed);
-
- /** Similar to lockColors(), lock16BitCache() returns the array of
- RGB16 colors that mirror the 32bit colors. However, this function
- will return null if kColorsAreOpaque_Flag is not set.
- Also, unlike lockColors(), the returned array here cannot be modified.
- */
- const uint16_t* lock16BitCache();
- /** Balancing call to lock16BitCache().
- */
- void unlock16BitCache() {
- SkASSERT(f16BitCacheLockCount > 0);
- SkDEBUGCODE(f16BitCacheLockCount -= 1);
- }
-
- void flatten(SkFlattenableWriteBuffer&) const;
-
-private:
- SkPMColor* fColors;
- uint16_t* f16BitCache;
- uint16_t fCount;
- uint8_t fFlags;
- SkDEBUGCODE(int fColorLockCount;)
- SkDEBUGCODE(int f16BitCacheLockCount;)
-
- void inval16BitCache();
-};
-
class SkAutoLockPixels : public SkNoncopyable {
public:
SkAutoLockPixels(const SkBitmap& bm, bool doLock = true) : fBitmap(bm) {
--- /dev/null
+
+/*
+ * Copyright 2012 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+
+#ifndef SkColorTable_DEFINED
+#define SkColorTable_DEFINED
+
+#include "SkColor.h"
+#include "SkFlattenable.h"
+
+/** \class SkColorTable
+
+ SkColorTable holds an array SkPMColors (premultiplied 32-bit colors) used by
+ 8-bit bitmaps, where the bitmap bytes are interpreted as indices into the colortable.
+*/
+class SkColorTable : public SkFlattenable {
+public:
+ /** Makes a deep copy of colors.
+ */
+ SkColorTable(const SkColorTable& src);
+ /** Preallocates the colortable to have 'count' colors, which
+ * are initially set to 0.
+ */
+ explicit SkColorTable(int count);
+ SkColorTable(const SkPMColor colors[], int count);
+ virtual ~SkColorTable();
+
+ enum Flags {
+ kColorsAreOpaque_Flag = 0x01 //!< if set, all of the colors in the table are opaque (alpha==0xFF)
+ };
+ /** Returns the flag bits for the color table. These can be changed with setFlags().
+ */
+ unsigned getFlags() const { return fFlags; }
+ /** Set the flags for the color table. See the Flags enum for possible values.
+ */
+ void setFlags(unsigned flags);
+
+ bool isOpaque() const { return (fFlags & kColorsAreOpaque_Flag) != 0; }
+ void setIsOpaque(bool isOpaque);
+
+ /** Returns the number of colors in the table.
+ */
+ int count() const { return fCount; }
+
+ /** Returns the specified color from the table. In the debug build, this asserts that
+ the index is in range (0 <= index < count).
+ */
+ SkPMColor operator[](int index) const {
+ SkASSERT(fColors != NULL && (unsigned)index < fCount);
+ return fColors[index];
+ }
+
+ /** Specify the number of colors in the color table. This does not initialize the colors
+ to any value, just allocates memory for them. To initialize the values, either call
+ setColors(array, count), or follow setCount(count) with a call to
+ lockColors()/{set the values}/unlockColors(true).
+ */
+// void setColors(int count) { this->setColors(NULL, count); }
+// void setColors(const SkPMColor[], int count);
+
+ /** Return the array of colors for reading and/or writing. This must be
+ balanced by a call to unlockColors(changed?), telling the colortable if
+ the colors were changed during the lock.
+ */
+ SkPMColor* lockColors() {
+ SkDEBUGCODE(fColorLockCount += 1;)
+ return fColors;
+ }
+ /** Balancing call to lockColors(). If the colors have been changed, pass true.
+ */
+ void unlockColors(bool changed);
+
+ /** Similar to lockColors(), lock16BitCache() returns the array of
+ RGB16 colors that mirror the 32bit colors. However, this function
+ will return null if kColorsAreOpaque_Flag is not set.
+ Also, unlike lockColors(), the returned array here cannot be modified.
+ */
+ const uint16_t* lock16BitCache();
+ /** Balancing call to lock16BitCache().
+ */
+ void unlock16BitCache() {
+ SkASSERT(f16BitCacheLockCount > 0);
+ SkDEBUGCODE(f16BitCacheLockCount -= 1);
+ }
+
+ SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkColorTable)
+
+protected:
+ explicit SkColorTable(SkFlattenableReadBuffer&);
+ void flatten(SkFlattenableWriteBuffer&) const;
+
+private:
+ SkPMColor* fColors;
+ uint16_t* f16BitCache;
+ uint16_t fCount;
+ uint8_t fFlags;
+ SkDEBUGCODE(int fColorLockCount;)
+ SkDEBUGCODE(int f16BitCacheLockCount;)
+
+ void inval16BitCache();
+
+ typedef SkFlattenable INHERITED;
+};
+
+#endif
#define SkFlattenable_DEFINED
#include "SkRefCnt.h"
-#include "SkBitmap.h"
-#include "SkPath.h"
-#include "SkPoint.h"
#include "SkReader32.h"
#include "SkTDArray.h"
#include "SkWriter32.h"
+class SkBitmap;
class SkFlattenableReadBuffer;
class SkFlattenableWriteBuffer;
+class SkPath;
+class SkPoint;
class SkString;
#if SK_ALLOW_STATIC_GLOBAL_INITIALIZERS
#ifndef SkSfntUtils_DEFINED
#define SkSfntUtils_DEFINED
+#include "Sk64.h"
#include "SkFontHost.h"
struct SkSfntTable_head {
} else if (fPixels) {
if (fColorTable) {
buffer.write8(SERIALIZE_PIXELTYPE_RAW_WITH_CTABLE);
- fColorTable->flatten(buffer);
+ buffer.writeFlattenable(fColorTable);
} else {
buffer.write8(SERIALIZE_PIXELTYPE_RAW_NO_CTABLE);
}
case SERIALIZE_PIXELTYPE_RAW_NO_CTABLE: {
SkColorTable* ctable = NULL;
if (SERIALIZE_PIXELTYPE_RAW_WITH_CTABLE == reftype) {
- ctable = SkNEW_ARGS(SkColorTable, (buffer));
+ ctable = static_cast<SkColorTable*>(buffer.readFlattenable());
}
size_t size = this->getSize();
if (this->allocPixels(ctable)) {
*/
-#include "SkBitmap.h"
-#include "SkFlattenable.h"
+#include "SkColorTable.h"
#include "SkStream.h"
#include "SkTemplates.h"
SkDEBUGCODE(f16BitCacheLockCount = 0;)
}
-// call SkRefCnt's constructor explicitly, to avoid warning
-SkColorTable::SkColorTable(const SkColorTable& src) : SkRefCnt() {
+SkColorTable::SkColorTable(const SkColorTable& src) : INHERITED() {
f16BitCache = NULL;
fFlags = src.fFlags;
int count = src.count();
buffer.writeMul4(fColors, count * sizeof(SkPMColor));
}
+SK_DEFINE_FLATTENABLE_REGISTRAR(SkColorTable)
buffer.writePad(fStorage, fSize);
if (fCTable) {
buffer.writeBool(true);
- fCTable->flatten(buffer);
+ buffer.writeFlattenable(fCTable);
} else {
buffer.writeBool(false);
}
fStorage = sk_malloc_throw(fSize);
buffer.read(fStorage, fSize);
if (buffer.readBool()) {
- fCTable = SkNEW_ARGS(SkColorTable, (buffer));
+ fCTable = static_cast<SkColorTable*>(buffer.readFlattenable());
} else {
fCTable = NULL;
}
* found in the LICENSE file.
*/
+#include "SkBitmap.h"
#include "SkBlurImageFilter.h"
#include "SkColorPriv.h"
*/
#include "SkMorphologyImageFilter.h"
+#include "SkBitmap.h"
#include "SkColorPriv.h"
SkMorphologyImageFilter::SkMorphologyImageFilter(SkFlattenableReadBuffer& buffer)
projects / platform / upstream / libSkiaSharp.git / commitdiff