Begin making SkPerlinNoiseShader const.

src/effects/SkPerlinNoiseShader.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkDither.h"
 #include "SkPerlinNoiseShader.h"
 #include "SkColorFilter.h"
 #include "SkReadBuffer.h"
+#include "SkShader.h"
+#include "SkString.h"
+#include "SkThread.h"
+#include "SkUnPreMultiply.h"
 #include "SkWriteBuffer.h"
-#include "SkShader.h"
-#include "SkUnPreMultiply.h"
-#include "SkString.h"
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #include "GrCoordTransform.h"
 #include "gl/GrGLEffect.h"
 #include "GrTBackendEffectFactory.h"
 #include "SkGr.h"
 #endif
 
 static const int kBlockSize = 256;
@@ skipping 48 matching lines @@
                fWrapY == other.fWrapY;
     }
 
     int fWidth; // How much to subtract to wrap for stitching.
     int fWrapX; // Minimum value to wrap.
     int fHeight;
     int fWrapY;
 };
 
 struct SkPerlinNoiseShader::PaintingData {
-    PaintingData(const SkISize& tileSize)
-      : fSeed(0)
-      , fTileSize(tileSize)
+    PaintingData(const SkISize& tileSize, SkScalar seed,
+                 SkScalar baseFrequencyX, SkScalar baseFrequencyY)
+      : fTileSize(tileSize)
+      , fBaseFrequency(SkPoint::Make(baseFrequencyX, baseFrequencyY))
       , fPermutationsBitmap(NULL)
       , fNoiseBitmap(NULL)
-    {}
+    {
+        this->init(seed);
+        if (!fTileSize.isEmpty()) {
+            this->stitch();
+        }
+    }
 
     ~PaintingData()
     {
         SkDELETE(fPermutationsBitmap);
         SkDELETE(fNoiseBitmap);
     }
 
     int         fSeed;
     uint8_t     fLatticeSelector[kBlockSize];
     uint16_t    fNoise[4][kBlockSize][2];
     SkPoint     fGradient[4][kBlockSize];
     SkISize     fTileSize;
     SkVector    fBaseFrequency;
     StitchData  fStitchDataInit;
 
 private:
 
     SkBitmap*    fPermutationsBitmap;
     SkBitmap*    fNoiseBitmap;
 
-public:
+    // Guards for the bitmap caches.
+    SkMutex      fPermutationsMutex;
+    SkMutex      fNoiseMutex;
 
     inline int random()  {
         static const int gRandAmplitude = 16807; // 7**5; primitive root of m
         static const int gRandQ = 127773; // m / a
         static const int gRandR = 2836; // m % a
 
         int result = gRandAmplitude * (fSeed % gRandQ) - gRandR * (fSeed / gRandQ);
         if (result <= 0)
             result += kRandMaximum;
         fSeed = result;
         return result;
     }
 
+    // Only called once. Could be part of the constructor.
     void init(SkScalar seed)
     {
         static const SkScalar gInvBlockSizef = SkScalarInvert(SkIntToScalar(kBlockSize));
 
         // According to the SVG spec, we must truncate (not round) the seed value.
         fSeed = SkScalarTruncToInt(seed);
         // The seed value clamp to the range [1, kRandMaximum - 1].
         if (fSeed <= 0) {
             fSeed = -(fSeed % (kRandMaximum - 1)) + 1;
         }
@@ skipping 49 matching lines @@
                     SkScalarMul(SkIntToScalar(fNoise[channel][i][1] - kBlockSize),
                                 gInvBlockSizef));
                 fGradient[channel][i].normalize();
                 // Put the normalized gradient back into the noise data
                 fNoise[channel][i][0] = SkScalarRoundToInt(SkScalarMul(
                     fGradient[channel][i].fX + SK_Scalar1, gHalfMax16bits));
                 fNoise[channel][i][1] = SkScalarRoundToInt(SkScalarMul(
                     fGradient[channel][i].fY + SK_Scalar1, gHalfMax16bits));
             }
         }
-
-        // Invalidate bitmaps
-        SkDELETE(fPermutationsBitmap);
-        fPermutationsBitmap = NULL;
-        SkDELETE(fNoiseBitmap);
-        fNoiseBitmap = NULL;
     }
 
+    // Only called once. Could be part of the constructor.
     void stitch() {
         SkScalar tileWidth  = SkIntToScalar(fTileSize.width());
         SkScalar tileHeight = SkIntToScalar(fTileSize.height());
         SkASSERT(tileWidth > 0 && tileHeight > 0);
         // When stitching tiled turbulence, the frequencies must be adjusted
         // so that the tile borders will be continuous.
         if (fBaseFrequency.fX) {
             SkScalar lowFrequencx =
                 SkScalarFloorToScalar(tileWidth * fBaseFrequency.fX) / tileWidth;
             SkScalar highFrequencx =
@@ skipping 20 matching lines @@
         }
         // Set up TurbulenceInitial stitch values.
         fStitchDataInit.fWidth  =
             SkScalarRoundToInt(tileWidth * fBaseFrequency.fX);
         fStitchDataInit.fWrapX  = kPerlinNoise + fStitchDataInit.fWidth;
         fStitchDataInit.fHeight =
             SkScalarRoundToInt(tileHeight * fBaseFrequency.fY);
         fStitchDataInit.fWrapY  = kPerlinNoise + fStitchDataInit.fHeight;
     }
 
+public:
+
     SkBitmap* getPermutationsBitmap()
     {
         if (!fPermutationsBitmap) {
-            fPermutationsBitmap = SkNEW(SkBitmap);
-            fPermutationsBitmap->allocPixels(SkImageInfo::MakeA8(kBlockSize, 1));
-            uint8_t* bitmapPixels = fPermutationsBitmap->getAddr8(0, 0);
-            memcpy(bitmapPixels, fLatticeSelector, sizeof(uint8_t) * kBlockSize);
+            SkAutoMutexAcquire autoMutex(fPermutationsMutex);

[Stephen White, 2014/03/05 21:37:50]

Maybe I'm being dense, but can these bitmaps just be created in the constructor,
obviating the need for a mutex? Do they have any parameters which must be
computed at processing time?

+            if (!fPermutationsBitmap) {
+                fPermutationsBitmap = SkNEW(SkBitmap);
+                fPermutationsBitmap->allocPixels(SkImageInfo::MakeA8(kBlockSize, 1));
+                uint8_t* bitmapPixels = fPermutationsBitmap->getAddr8(0, 0);
+                memcpy(bitmapPixels, fLatticeSelector, sizeof(uint8_t) * kBlockSize);
+            }
         }
         return fPermutationsBitmap;
     }
 
     SkBitmap* getNoiseBitmap()
     {
         if (!fNoiseBitmap) {
-            fNoiseBitmap = SkNEW(SkBitmap);
-            fNoiseBitmap->allocPixels(SkImageInfo::MakeN32Premul(kBlockSize, 4));
-            uint32_t* bitmapPixels = fNoiseBitmap->getAddr32(0, 0);
-            memcpy(bitmapPixels, fNoise[0][0], sizeof(uint16_t) * kBlockSize * 4 * 2);
+            SkAutoMutexAcquire autoMutex(fNoiseMutex);
+            if (!fNoiseBitmap) {
+                fNoiseBitmap = SkNEW(SkBitmap);
+                fNoiseBitmap->allocPixels(SkImageInfo::MakeN32Premul(kBlockSize, 4));
+                uint32_t* bitmapPixels = fNoiseBitmap->getAddr32(0, 0);
+                memcpy(bitmapPixels, fNoise[0][0], sizeof(uint16_t) * kBlockSize * 4 * 2);
+            }
         }
         return fNoiseBitmap;
     }
 };
 
 SkShader* SkPerlinNoiseShader::CreateFractalNoise(SkScalar baseFrequencyX, SkScalar baseFrequencyY,
                                                   int numOctaves, SkScalar seed,
                                                   const SkISize* tileSize) {
     return SkNEW_ARGS(SkPerlinNoiseShader, (kFractalNoise_Type, baseFrequencyX, baseFrequencyY,
                                             numOctaves, seed, tileSize));
@@ skipping 10 matching lines @@
                                          SkScalar baseFrequencyX,
                                          SkScalar baseFrequencyY,
                                          int numOctaves,
                                          SkScalar seed,
                                          const SkISize* tileSize)
   : fType(type)
   , fBaseFrequencyX(baseFrequencyX)
   , fBaseFrequencyY(baseFrequencyY)
   , fNumOctaves(numOctaves > 255 ? 255 : numOctaves/*[0,255] octaves allowed*/)
   , fSeed(seed)
-  , fStitchTiles((tileSize != NULL) && !tileSize->isEmpty())
-  , fPaintingData(NULL)
+  , fTileSize(NULL == tileSize ? SkISize::Make(0, 0) : *tileSize)
+  , fStitchTiles(!fTileSize.isEmpty())
 {
     SkASSERT(numOctaves >= 0 && numOctaves < 256);
-    setTileSize(fStitchTiles ? *tileSize : SkISize::Make(0,0));
     fMatrix.reset();
+    fPaintingData = SkNEW_ARGS(PaintingData, (fTileSize, fSeed, fBaseFrequencyX, fBaseFrequencyY));
 }
 
-SkPerlinNoiseShader::SkPerlinNoiseShader(SkReadBuffer& buffer) :
-        INHERITED(buffer), fPaintingData(NULL) {
+SkPerlinNoiseShader::SkPerlinNoiseShader(SkReadBuffer& buffer)
+    : INHERITED(buffer)
+{
     fType           = (SkPerlinNoiseShader::Type) buffer.readInt();
     fBaseFrequencyX = buffer.readScalar();
     fBaseFrequencyY = buffer.readScalar();
     fNumOctaves     = buffer.readInt();
     fSeed           = buffer.readScalar();
     fStitchTiles    = buffer.readBool();
     fTileSize.fWidth  = buffer.readInt();
     fTileSize.fHeight = buffer.readInt();
-    setTileSize(fTileSize);
     fMatrix.reset();
+    fPaintingData = SkNEW_ARGS(PaintingData, (fTileSize, fSeed, fBaseFrequencyX, fBaseFrequencyY));
     buffer.validate(perlin_noise_type_is_valid(fType) &&
-                    (fNumOctaves >= 0) && (fNumOctaves <= 255));
+                    (fNumOctaves >= 0) && (fNumOctaves <= 255) &&
+                    (fStitchTiles != fTileSize.isEmpty()));
 }
 
 SkPerlinNoiseShader::~SkPerlinNoiseShader() {
     // Safety, should have been done in endContext()
     SkDELETE(fPaintingData);
 }
 
 void SkPerlinNoiseShader::flatten(SkWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
     buffer.writeInt((int) fType);
     buffer.writeScalar(fBaseFrequencyX);
     buffer.writeScalar(fBaseFrequencyY);
     buffer.writeInt(fNumOctaves);
     buffer.writeScalar(fSeed);
     buffer.writeBool(fStitchTiles);
     buffer.writeInt(fTileSize.fWidth);
     buffer.writeInt(fTileSize.fHeight);
 }
 
-void SkPerlinNoiseShader::initPaint(PaintingData& paintingData)
-{
-    paintingData.init(fSeed);
-
-    // Set frequencies to original values
-    paintingData.fBaseFrequency.set(fBaseFrequencyX, fBaseFrequencyY);
-    // Adjust frequecies based on size if stitching is enabled
-    if (fStitchTiles) {
-        paintingData.stitch();
-    }
-}
-
-void SkPerlinNoiseShader::setTileSize(const SkISize& tileSize) {
-    fTileSize = tileSize;
-
-    if (NULL == fPaintingData) {
-        fPaintingData = SkNEW_ARGS(PaintingData, (fTileSize));
-        initPaint(*fPaintingData);
-    } else {
-        // Set Size
-        fPaintingData->fTileSize = fTileSize;
-        // Set frequencies to original values
-        fPaintingData->fBaseFrequency.set(fBaseFrequencyX, fBaseFrequencyY);
-        // Adjust frequecies based on size if stitching is enabled
-        if (fStitchTiles) {
-            fPaintingData->stitch();
-        }
-    }
-}
-
 SkScalar SkPerlinNoiseShader::noise2D(int channel, const PaintingData& paintingData,
-                                     const StitchData& stitchData, const SkPoint& noiseVector)
-{
+                                      const StitchData& stitchData,
+                                      const SkPoint& noiseVector) const {
     struct Noise {
         int noisePositionIntegerValue;
         SkScalar noisePositionFractionValue;
         Noise(SkScalar component)
         {
             SkScalar position = component + kPerlinNoise;
             noisePositionIntegerValue = SkScalarFloorToInt(position);
             noisePositionFractionValue = position - SkIntToScalar(noisePositionIntegerValue);
         }
     };
@@ skipping 25 matching lines @@
     v = paintingData.fGradient[channel][nextLatticeIndex & kBlockMask].dot(fractionValue);
     SkScalar a = SkScalarInterp(u, v, sx);
     fractionValue.fY -= SK_Scalar1; // Offset (-1,-1)
     v = paintingData.fGradient[channel][(nextLatticeIndex + 1) & kBlockMask].dot(fractionValue);
     fractionValue.fX = noiseX.noisePositionFractionValue; // Offset (0,-1)
     u = paintingData.fGradient[channel][(latticeIndex + 1) & kBlockMask].dot(fractionValue);
     SkScalar b = SkScalarInterp(u, v, sx);
     return SkScalarInterp(a, b, sy);
 }
 
-SkScalar SkPerlinNoiseShader::calculateTurbulenceValueForPoint(
-    int channel, const PaintingData& paintingData, StitchData& stitchData, const SkPoint& point)
-{
+SkScalar SkPerlinNoiseShader::calculateTurbulenceValueForPoint(int channel,
+                                                               const PaintingData& paintingData,
+                                                               StitchData& stitchData,
+                                                               const SkPoint& point) const {
     if (fStitchTiles) {
         // Set up TurbulenceInitial stitch values.
         stitchData = paintingData.fStitchDataInit;
     }
     SkScalar turbulenceFunctionResult = 0;
     SkPoint noiseVector(SkPoint::Make(SkScalarMul(point.x(), paintingData.fBaseFrequency.fX),
                                       SkScalarMul(point.y(), paintingData.fBaseFrequency.fY)));
     SkScalar ratio = SK_Scalar1;
     for (int octave = 0; octave < fNumOctaves; ++octave) {
         SkScalar noise = noise2D(channel, paintingData, stitchData, noiseVector);
@@ skipping 20 matching lines @@
 
     if (channel == 3) { // Scale alpha by paint value
         turbulenceFunctionResult = SkScalarMul(turbulenceFunctionResult,
             SkScalarDiv(SkIntToScalar(getPaintAlpha()), SkIntToScalar(255)));
     }
 
     // Clamp result
     return SkScalarPin(turbulenceFunctionResult, 0, SK_Scalar1);
 }
 
-SkPMColor SkPerlinNoiseShader::shade(const SkPoint& point, StitchData& stitchData) {
+SkPMColor SkPerlinNoiseShader::shade(const SkPoint& point, StitchData& stitchData) const {
     SkMatrix matrix = fMatrix;
     matrix.postConcat(getLocalMatrix());
     SkMatrix invMatrix;
     if (!matrix.invert(&invMatrix)) {
         invMatrix.reset();
     } else {
         invMatrix.postConcat(invMatrix); // Square the matrix
     }
     // This (1,1) translation is due to WebKit's 1 based coordinates for the noise
     // (as opposed to 0 based, usually). The same adjustment is in the setData() function.
@@ skipping 924 matching lines @@
     str->append(" seed: ");
     str->appendScalar(fSeed);
     str->append(" stitch tiles: ");
     str->append(fStitchTiles ? "true " : "false ");
 
     this->INHERITED::toString(str);
 
     str->append(")");
 }
 #endif