always store bitfields along with dirty in FlatteningTraits

src/core/SkPaint.cpp

 
 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkPaint.h"
 #include "SkAnnotation.h"
@@ skipping 18 matching lines @@
 #include "SkShader.h"
 #include "SkStringUtils.h"
 #include "SkStroke.h"
 #include "SkTextFormatParams.h"
 #include "SkTextToPathIter.h"
 #include "SkTLazy.h"
 #include "SkTypeface.h"
 #include "SkXfermode.h"
 
 enum {
     kColor_DirtyBit               = 1 <<  0,

[robertphillips, 2014/04/16 15:39:33]

Just delete?

[mtklein, 2014/04/16 15:53:23]

Or // Bit 1 is safe to reuse.

[mtklein, 2014/04/16 15:54:43]

Actually.  Hold on.  Let's just shift everyone down.
So we can write // Each of bottom 6 bits ... and mask with 63 instead of 127,
etc.

We can change this enum freely without breaking picture version.

-    kBitfields_DirtyBit           = 1 <<  1,
+//    kBitfields_DirtyBit           = 1 <<  1,
     kTextSize_DirtyBit            = 1 <<  2,
     kTextScaleX_DirtyBit          = 1 <<  3,
     kTextSkewX_DirtyBit           = 1 <<  4,
     kStrokeWidth_DirtyBit         = 1 <<  5,
     kStrokeMiter_DirtyBit         = 1 <<  6,
     kPathEffect_DirtyBit          = 1 <<  7,
     kShader_DirtyBit              = 1 <<  8,
     kXfermode_DirtyBit            = 1 <<  9,
     kMaskFilter_DirtyBit          = 1 << 10,
     kColorFilter_DirtyBit         = 1 << 11,
@@ skipping 196 matching lines @@
         fPaintOptionsAndroid = options;
         GEN_ID_INC;
         fDirtyBits |= kPaintOptionsAndroid_DirtyBit;
     }
 }
 #endif
 
 void SkPaint::setFilterLevel(FilterLevel level) {
     GEN_ID_INC_EVAL((unsigned) level != fFilterLevel);
     fFilterLevel = level;
-    fDirtyBits |= kBitfields_DirtyBit;
 }
 
 void SkPaint::setHinting(Hinting hintingLevel) {
     GEN_ID_INC_EVAL((unsigned) hintingLevel != fHinting);
     fHinting = hintingLevel;
-    fDirtyBits |= kBitfields_DirtyBit;
 }
 
 void SkPaint::setFlags(uint32_t flags) {
     GEN_ID_INC_EVAL(fFlags != flags);
     fFlags = flags;
-    fDirtyBits |= kBitfields_DirtyBit;
 }
 
 void SkPaint::setAntiAlias(bool doAA) {
     this->setFlags(SkSetClearMask(fFlags, doAA, kAntiAlias_Flag));
 }
 
 void SkPaint::setDither(bool doDither) {
     this->setFlags(SkSetClearMask(fFlags, doDither, kDither_Flag));
 }
 
@@ skipping 38 matching lines @@
 }
 
 void SkPaint::setDistanceFieldTextTEMP(bool doDistanceFieldText) {
     this->setFlags(SkSetClearMask(fFlags, doDistanceFieldText, kDistanceFieldTextTEMP_Flag));
 }
 
 void SkPaint::setStyle(Style style) {
     if ((unsigned)style < kStyleCount) {
         GEN_ID_INC_EVAL((unsigned)style != fStyle);
         fStyle = style;
-        fDirtyBits |= kBitfields_DirtyBit;
     } else {
 #ifdef SK_REPORT_API_RANGE_CHECK
         SkDebugf("SkPaint::setStyle(%d) out of range\n", style);
 #endif
     }
 }
 
 void SkPaint::setColor(SkColor color) {
     GEN_ID_INC_EVAL(color != fColor);
     fColor = color;
@@ skipping 30 matching lines @@
 #ifdef SK_REPORT_API_RANGE_CHECK
         SkDebugf("SkPaint::setStrokeMiter() called with negative value\n");
 #endif
     }
 }
 
 void SkPaint::setStrokeCap(Cap ct) {
     if ((unsigned)ct < kCapCount) {
         GEN_ID_INC_EVAL((unsigned)ct != fCapType);
         fCapType = SkToU8(ct);
-        fDirtyBits |= kBitfields_DirtyBit;
     } else {
 #ifdef SK_REPORT_API_RANGE_CHECK
         SkDebugf("SkPaint::setStrokeCap(%d) out of range\n", ct);
 #endif
     }
 }
 
 void SkPaint::setStrokeJoin(Join jt) {
     if ((unsigned)jt < kJoinCount) {
         GEN_ID_INC_EVAL((unsigned)jt != fJoinType);
         fJoinType = SkToU8(jt);
-        fDirtyBits |= kBitfields_DirtyBit;
     } else {
 #ifdef SK_REPORT_API_RANGE_CHECK
         SkDebugf("SkPaint::setStrokeJoin(%d) out of range\n", jt);
 #endif
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkPaint::setTextAlign(Align align) {
     if ((unsigned)align < kAlignCount) {
         GEN_ID_INC_EVAL((unsigned)align != fTextAlign);
         fTextAlign = SkToU8(align);
-        fDirtyBits |= kBitfields_DirtyBit;
     } else {
 #ifdef SK_REPORT_API_RANGE_CHECK
         SkDebugf("SkPaint::setTextAlign(%d) out of range\n", align);
 #endif
     }
 }
 
 void SkPaint::setTextSize(SkScalar ts) {
     if (ts >= 0) {
         GEN_ID_INC_EVAL(ts != fTextSize);
@@ skipping 15 matching lines @@
 void SkPaint::setTextSkewX(SkScalar skewX) {
     GEN_ID_INC_EVAL(skewX != fTextSkewX);
     fTextSkewX = skewX;
     fDirtyBits |= kTextSkewX_DirtyBit;
 }
 
 void SkPaint::setTextEncoding(TextEncoding encoding) {
     if ((unsigned)encoding <= kGlyphID_TextEncoding) {
         GEN_ID_INC_EVAL((unsigned)encoding != fTextEncoding);
         fTextEncoding = encoding;
-        fDirtyBits |= kBitfields_DirtyBit;
     } else {
 #ifdef SK_REPORT_API_RANGE_CHECK
         SkDebugf("SkPaint::setTextEncoding(%d) out of range\n", encoding);
 #endif
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 // Returns dst with the given bitmask enabled or disabled, depending on value.
@@ skipping 2191 matching lines @@
                 return true;
             default:
                 break;
         }
     }
     return false;
 }
 
 void SkPaint::setBitfields(uint32_t bitfields) {
     fBitfields = bitfields;
-    fDirtyBits |= kBitfields_DirtyBit;
 }
 
 inline static unsigned popcount(uint8_t x) {
     // As in Hacker's delight, adapted for just 8 bits.
     x = (x & 0x55) + ((x >> 1) & 0x55);  // a b c d w x y z -> a+b c+d w+x y+z
     x = (x & 0x33) + ((x >> 2) & 0x33);  // a+b c+d w+x y+z -> a+b+c+d w+x+y+z
     x = (x & 0x0F) + ((x >> 4) & 0x0F);  // a+b+c+d w+x+y+z -> a+b+c+d+w+x+y+z
     return x;
 }
 
 void SkPaint::FlatteningTraits::Flatten(SkWriteBuffer& buffer, const SkPaint& paint) {
     const uint32_t dirty = paint.fDirtyBits;
 
-    // Each of the low 7 dirty bits corresponds to a 4-byte flat value, plus one for the dirty bits.
-    const size_t flatBytes = 4 * (popcount(dirty & 127) + 1);
+    // Each of the low 7 dirty bits corresponds to a 4-byte flat value,

[mtklein, 2014/04/16 15:53:23]

// Each of bits 0,2,3,4,5, and 6 corresponds to a 4-byte flat value, 

+    // plus one for the dirty bits and one for the bitfields
+    const size_t flatBytes = 4 * (popcount(dirty & 127) + 2);
     SkASSERT(flatBytes <= 32);
     uint32_t* u32 = buffer.reserve(flatBytes);
     *u32++ = dirty;

[robertphillips, 2014/04/16 15:39:33]

This is minor but, would it make more sense to read/write the bitfields before
the dirty word?

-    if (dirty == 0) {
+    *u32++ = paint.getBitfields();
+    if (0 == dirty) {
         return;
     }
 
 #define F(dst, field) if (dirty & k##field##_DirtyBit) *dst++ = paint.get##field()
     F(u32, Color);
-    F(u32, Bitfields);
     SkScalar* f32 = reinterpret_cast<SkScalar*>(u32);
     F(f32, TextSize);
     F(f32, TextScaleX);
     F(f32, TextSkewX);
     F(f32, StrokeWidth);
     F(f32, StrokeMiter);
 #undef F
 #define F(field) if (dirty & k##field##_DirtyBit) buffer.writeFlattenable(paint.get##field())
     F(PathEffect);
     F(Shader);
     F(Xfermode);
     F(MaskFilter);
     F(ColorFilter);
     F(Rasterizer);
     F(Looper);
     F(ImageFilter);
 #undef F
     if (dirty & kTypeface_DirtyBit) buffer.writeTypeface(paint.getTypeface());
     if (dirty & kAnnotation_DirtyBit) paint.getAnnotation()->writeToBuffer(buffer);
 #ifdef SK_BUILD_FOR_ANDROID
     if (dirty & kPaintOptionsAndroid_DirtyBit) paint.getPaintOptionsAndroid().flatten(buffer);
 #endif
 }
 
 void SkPaint::FlatteningTraits::Unflatten(SkReadBuffer& buffer, SkPaint* paint) {
     const uint32_t dirty = buffer.readUInt();
+    paint->setBitfields(buffer.readUInt());
     if (dirty == 0) {
         return;
     }
 #define F(field, reader) if (dirty & k##field##_DirtyBit) paint->set##field(buffer.reader())
 // Same function, except it unrefs the object newly set on the paint:
 #define F_UNREF(field, reader)                      \
     if (dirty & k##field##_DirtyBit)                \
         paint->set##field(buffer.reader())->unref()
 
     F(Color,       readUInt);
-    F(Bitfields,   readUInt);
     F(TextSize,    readScalar);
     F(TextScaleX,  readScalar);
     F(TextSkewX,   readScalar);
     F(StrokeWidth, readScalar);
     F(StrokeMiter, readScalar);
     F_UNREF(PathEffect,  readPathEffect);
     F_UNREF(Shader,      readShader);
     F_UNREF(Xfermode,    readXfermode);
     F_UNREF(MaskFilter,  readMaskFilter);
     F_UNREF(ColorFilter, readColorFilter);
     F_UNREF(Rasterizer,  readRasterizer);
     F_UNREF(Looper,      readDrawLooper);
     F_UNREF(ImageFilter, readImageFilter);
     F(Typeface,    readTypeface);
 #undef F
 #undef F_UNREF
     if (dirty & kAnnotation_DirtyBit) {
         paint->setAnnotation(SkAnnotation::Create(buffer))->unref();
     }
 #ifdef SK_BUILD_FOR_ANDROID
     if (dirty & kPaintOptionsAndroid_DirtyBit) {
         SkPaintOptionsAndroid options;
         options.unflatten(buffer);
         paint->setPaintOptionsAndroid(options);
     }
 #endif
     SkASSERT(dirty == paint->fDirtyBits);
 }