Adding new filters 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 "SkBicubicImageFilter.h"
 #include "SkBitmapDevice.h"
 #include "SkBitmapSource.h"
 #include "SkBlurImageFilter.h"
 #include "SkCanvas.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"
+#include "SkMatrixConvolutionImageFilter.h"
 #include "SkMergeImageFilter.h"
 #include "SkMorphologyImageFilter.h"
 #include "SkOffsetImageFilter.h"
 #include "SkPerlinNoiseShader.h"
 #include "SkPictureImageFilter.h"
 #include "SkRandom.h"
 #include "SkRectShaderImageFilter.h"
+#include "SkTestImageFilters.h"
 #include "SkTileImageFilter.h"
 #include "SkView.h"
 #include "SkXfermodeImageFilter.h"
 #include <stdio.h>
 #include <time.h>
 
 //#define SK_ADD_RANDOM_BIT_FLIPS
 //#define SK_FUZZER_IS_VERBOSE
 
 static const uint32_t kSeed = (uint32_t)(time(NULL));
@@ skipping 49 matching lines @@
 
 static SkScalar make_scalar(bool positiveOnly = false) {
     return make_number(positiveOnly);
 }
 
 static SkRect make_rect() {
     return SkRect::MakeWH(SkIntToScalar(R(static_cast<float>(kBitmapSize))),
                           SkIntToScalar(R(static_cast<float>(kBitmapSize))));
 }
 
+static SkRegion make_region() {
+    SkIRect iRegion = SkIRect::MakeXYWH(SkIntToScalar(R(static_cast<float>(kBitmapSize))),
+                                        SkIntToScalar(R(static_cast<float>(kBitmapSize))),
+                                        SkIntToScalar(R(static_cast<float>(kBitmapSize))),
+                                        SkIntToScalar(R(static_cast<float>(kBitmapSize))));
+    return SkRegion(iRegion);
+}
+
+static SkMatrix make_matrix() {
+    SkMatrix m;
+    for (int i = 0; i < 9; ++i) {
+        m[i] = make_scalar();
+    }
+    return m;
+}
+
 static SkXfermode::Mode make_xfermode() {
     return static_cast<SkXfermode::Mode>(R(SkXfermode::kLastMode+1));
 }
 
 static SkColor make_color() {
     return (R(2) == 1) ? 0xFFC0F0A0 : 0xFF000090;
 }
 
 static SkPoint3 make_point() {
     return SkPoint3(make_scalar(), make_scalar(), make_scalar(true));
@@ skipping 101 matching lines @@
     canvas->drawText("Picture", 7, SkIntToScalar(kBitmapSize/2), SkIntToScalar(kBitmapSize/4), paint);
 }
 #endif
 
 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 { BICUBIC, MERGE, COLOR, BLUR, MAGNIFIER, XFERMODE, OFFSET, COMPOSE,
+    enum { ALPHA_THRESHOLD, BICUBIC, MERGE, COLOR, 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 BICUBIC:
         // Scale is set to 1 here so that it can fit in the DAG without resizing the output
         filter = SkBicubicImageFilter::CreateMitchell(SkSize::Make(1, 1), make_image_filter());
         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 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:
     {
         SkAutoTUnref<SkXfermode> mode(SkXfermode::Create(make_xfermode()));
         filter = SkXfermodeImageFilter::Create(mode, make_image_filter(), make_image_filter());
     }
         break;
     case OFFSET:
         filter = SkOffsetImageFilter::Create(make_scalar(), make_scalar(), make_image_filter());
         break;
+    case MATRIX:
+        filter = SkMatrixImageFilter::Create(make_matrix(),
+                                             (SkPaint::FilterLevel)R(4),
+                                             make_image_filter());
+        break;
+    case MATRIX_CONVOLUTION:
+    {
+        SkImageFilter::CropRect cropR(SkRect::MakeWH(SkIntToScalar(kBitmapSize),
+                                                     SkIntToScalar(kBitmapSize)));
+        SkISize size = SkISize::Make(R(10)+1, R(10)+1);
+        int arraySize = size.width() * size.height();
+        SkTArray<SkScalar> kernel(arraySize);
+        for (int i = 0; i < arraySize; ++i) {
+            kernel.push_back() = make_scalar();
+        }
+        SkIPoint kernelOffset = SkIPoint::Make(R(size.width()), R(size.height()));
+        filter = SkMatrixConvolutionImageFilter::Create(size,
+                                                        kernel.begin(),
+                                                        make_scalar(),
+                                                        make_scalar(),
+                                                        kernelOffset,
+                                                        (SkMatrixConvolutionImageFilter::TileMode)R(3),
+                                                        R(2) == 1,
+                                                        make_image_filter(),
+                                                        &cropR);
+    }
+        break;
     case COMPOSE:
         filter = SkComposeImageFilter::Create(make_image_filter(), make_image_filter());
         break;
     case DISTANT_LIGHT:
         filter = (R(2) == 1) ?
                  SkLightingImageFilter::CreateDistantLitDiffuse(make_point(),
                  make_color(), make_scalar(), make_scalar(), make_image_filter()) :
                  SkLightingImageFilter::CreateDistantLitSpecular(make_point(),
                  make_color(), make_scalar(), make_scalar(), SkIntToScalar(R(10)),
                  make_image_filter());
@@ skipping 163 matching lines @@
     }
 
 private:
     typedef SkView INHERITED;
 };
 
 //////////////////////////////////////////////////////////////////////////////
 
 static SkView* MyFactory() { return new ImageFilterFuzzView; }
 static SkViewRegister reg(MyFactory);