Adding color cube to fuzzer

samplecode/SampleFilterFuzz.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 "SampleCode.h"
 #include "SkAlphaThresholdFilter.h"
 #include "SkBitmapSource.h"
 #include "SkBlurImageFilter.h"
 #include "SkCanvas.h"
+#include "SkColorCubeFilter.h"
 #include "SkColorFilter.h"
 #include "SkColorFilterImageFilter.h"
 #include "SkComposeImageFilter.h"
 #include "SkData.h"
 #include "SkDisplacementMapEffect.h"
 #include "SkDropShadowImageFilter.h"
 #include "SkFlattenableSerialization.h"
 #include "SkLightingImageFilter.h"
 #include "SkMagnifierImageFilter.h"
 #include "SkMatrixImageFilter.h"
@@ skipping 181 matching lines @@
     static SkBitmap bitmap[2];
     static bool initialized = false;
     if (!initialized) {
         make_g_bitmap(bitmap[0]);
         make_checkerboard_bitmap(bitmap[1]);
         initialized = true;
     }
     return bitmap[R(2)];
 }
 
+static SkData* make_3Dlut(int* cubeDimension, bool invR, bool invG, bool invB) {
+    int size = 4;
+    switch (R(5)) {

[Stephen White, 2014/10/24 22:48:37]

Nit: couldn't this also be

int size = 4 << R(5) ?

[sugoi1, 2014/10/27 14:55:32]

Done.

+    case 4:
+        size *= 2; // 64
+    case 3:
+        size *= 2; // 32
+    case 2:
+        size *= 2; // 16
+    case 1:
+        size *= 2; // 8
+    default:
+        break;
+    }
+
+    SkData* data = SkData::NewUninitialized(sizeof(SkColor) * size * size * size);

[Stephen White, 2014/10/24 22:48:38]

Should we also be trying to give the fuzzer truncated buffers (ie., buffer <
size^3 in memory)? Or will the fuzzer hit that case automatically?

[sugoi1, 2014/10/27 14:55:32]

Yeah, the fuzzer should take care of that case automatically.

+    SkColor* pixels = (SkColor*)(data->writable_data());
+    SkAutoMalloc lutMemory(size);
+    SkAutoMalloc invLutMemory(size);
+    uint8_t* lut = (uint8_t*)lutMemory.get();
+    uint8_t* invLut = (uint8_t*)invLutMemory.get();
+    const int maxIndex = size - 1;
+    for (int i = 0; i < size; i++) {
+        lut[i] = (i * 255) / maxIndex;
+        invLut[i] = ((maxIndex - i) * 255) / maxIndex;
+    }
+    for (int r = 0; r < size; ++r) {
+        for (int g = 0; g < size; ++g) {
+            for (int b = 0; b < size; ++b) {
+                pixels[(size * ((size * b) + g)) + r] = SkColorSetARGB(0xFF,
+                        invR ? invLut[r] : lut[r],
+                        invG ? invLut[g] : lut[g],
+                        invB ? invLut[b] : lut[b]);
+            }
+        }
+    }
+    if (cubeDimension) {
+        *cubeDimension = size;
+    }
+    return data;
+}
+
 static void drawSomething(SkCanvas* canvas) {
     SkPaint paint;
 
     canvas->save();
     canvas->scale(0.5f, 0.5f);
     canvas->drawBitmap(make_bitmap(), 0, 0, NULL);
     canvas->restore();
 
     const char beforeStr[] = "before circle";
     const char afterStr[] = "after circle";
 
     paint.setAntiAlias(true);
 
     paint.setColor(SK_ColorRED);
     canvas->drawData(beforeStr, sizeof(beforeStr));
     canvas->drawCircle(SkIntToScalar(kBitmapSize/2), SkIntToScalar(kBitmapSize/2), SkIntToScalar(kBitmapSize/3), paint);
     canvas->drawData(afterStr, sizeof(afterStr));
     paint.setColor(SK_ColorBLACK);
     paint.setTextSize(SkIntToScalar(kBitmapSize/3));
     canvas->drawText("Picture", 7, SkIntToScalar(kBitmapSize/2), SkIntToScalar(kBitmapSize/4), paint);
 }
 
 static SkImageFilter* make_image_filter(bool canBeNull = true) {
     SkImageFilter* filter = 0;
 
     // Add a 1 in 3 chance to get a NULL input
     if (canBeNull && (R(3) == 1)) { return filter; }
 
-    enum { ALPHA_THRESHOLD, MERGE, COLOR, BLUR, MAGNIFIER,
+    enum { ALPHA_THRESHOLD, MERGE, COLOR, LUT3D, BLUR, MAGNIFIER,
            DOWN_SAMPLE, XFERMODE, OFFSET, MATRIX, MATRIX_CONVOLUTION, COMPOSE,
            DISTANT_LIGHT, POINT_LIGHT, SPOT_LIGHT, NOISE, DROP_SHADOW,
            MORPHOLOGY, BITMAP, DISPLACE, TILE, PICTURE, NUM_FILTERS };
 
     switch (R(NUM_FILTERS)) {
     case ALPHA_THRESHOLD:
         filter = SkAlphaThresholdFilter::Create(make_region(), make_scalar(), make_scalar());
         break;
     case MERGE:
         filter = SkMergeImageFilter::Create(make_image_filter(), make_image_filter(), make_xfermode());
         break;
     case COLOR:
     {
         SkAutoTUnref<SkColorFilter> cf((R(2) == 1) ?
                  SkColorFilter::CreateModeFilter(make_color(), make_xfermode()) :
                  SkColorFilter::CreateLightingFilter(make_color(), make_color()));
         filter = cf.get() ? SkColorFilterImageFilter::Create(cf, make_image_filter()) : 0;
     }
         break;
+    case LUT3D:
+    {
+        int cubeDimension;
+        SkAutoDataUnref lut3D(make_3Dlut(&cubeDimension, (R(2) == 1), (R(2) == 1), (R(2) == 1)));
+        SkAutoTUnref<SkColorFilter> cf(SkColorCubeFilter::Create(lut3D, cubeDimension));
+        filter = cf.get() ? SkColorFilterImageFilter::Create(cf, make_image_filter()) : 0;
+    }
+        break;
     case BLUR:
         filter = SkBlurImageFilter::Create(make_scalar(true), make_scalar(true), make_image_filter());
         break;
     case MAGNIFIER:
         filter = SkMagnifierImageFilter::Create(make_rect(), make_scalar(true));
         break;
     case DOWN_SAMPLE:
         filter = SkDownSampleImageFilter::Create(make_scalar());
         break;
     case XFERMODE:
@@ skipping 210 matching lines @@
     }
 
 private:
     typedef SkView INHERITED;
 };
 
 //////////////////////////////////////////////////////////////////////////////
 
 static SkView* MyFactory() { return new ImageFilterFuzzView; }
 static SkViewRegister reg(MyFactory);