OLD | NEW |
(Empty) | |
| 1 |
| 2 /* |
| 3 * Copyright 2013 Google Inc. |
| 4 * |
| 5 * Use of this source code is governed by a BSD-style license that can be |
| 6 * found in the LICENSE file. |
| 7 */ |
| 8 #include "SampleCode.h" |
| 9 #include "SkBicubicImageFilter.h" |
| 10 #include "SkBitmapSource.h" |
| 11 #include "SkBlurImageFilter.h" |
| 12 #include "SkCanvas.h" |
| 13 #include "SkColorFilter.h" |
| 14 #include "SkColorFilterImageFilter.h" |
| 15 #include "SkComposeImageFilter.h" |
| 16 #include "SkDevice.h" |
| 17 #include "SkDisplacementMapEffect.h" |
| 18 #include "SkDropShadowImageFilter.h" |
| 19 #include "SkFlattenableSerialization.h" |
| 20 #include "SkLightingImageFilter.h" |
| 21 #include "SkMagnifierImageFilter.h" |
| 22 #include "SkMergeImageFilter.h" |
| 23 #include "SkMorphologyImageFilter.h" |
| 24 #include "SkOffsetImageFilter.h" |
| 25 #include "SkPerlinNoiseShader.h" |
| 26 #include "SkRandom.h" |
| 27 #include "SkRectShaderImageFilter.h" |
| 28 #include "SkView.h" |
| 29 #include "SkXfermodeImageFilter.h" |
| 30 |
| 31 static const uint32_t kSeed = 1; |
| 32 static SkRandom gRand(kSeed); |
| 33 static bool return_large = false; |
| 34 static bool return_undef = false; |
| 35 |
| 36 static const int kBitmapSize = 24; |
| 37 |
| 38 static int R(float x) { |
| 39 return (int)floor(SkScalarToFloat(gRand.nextUScalar1()) * x); |
| 40 } |
| 41 |
| 42 #if defined _WIN32 |
| 43 #pragma warning ( push ) |
| 44 // we are intentionally causing an overflow here |
| 45 // (warning C4756: overflow in constant arithmetic) |
| 46 #pragma warning ( disable : 4756 ) |
| 47 #endif |
| 48 |
| 49 static float huge() { |
| 50 double d = 1e100; |
| 51 float f = (float)d; |
| 52 return f; |
| 53 } |
| 54 |
| 55 #if defined _WIN32 |
| 56 #pragma warning ( pop ) |
| 57 #endif |
| 58 |
| 59 static float make_number(bool positiveOnly) { |
| 60 float f = positiveOnly ? 1 : 0; |
| 61 float v = f; |
| 62 int sel; |
| 63 |
| 64 if (return_large) sel = R(6); else sel = R(4); |
| 65 if (!return_undef && sel == 0) sel = 1; |
| 66 |
| 67 if (R(2) == 1) v = (float)(R(100)+f); else |
| 68 |
| 69 switch (sel) { |
| 70 case 0: break; |
| 71 case 1: v = f; break; |
| 72 case 2: v = 0.000001f; break; |
| 73 case 3: v = 10000; break; |
| 74 case 4: v = 2000000000; break; |
| 75 case 5: v = huge(); break; |
| 76 } |
| 77 |
| 78 if (!positiveOnly && (R(4) == 1)) v = -v; |
| 79 return v; |
| 80 } |
| 81 |
| 82 static SkScalar make_scalar(bool positiveOnly = false) { |
| 83 return SkFloatToScalar(make_number(positiveOnly)); |
| 84 } |
| 85 |
| 86 static SkRect make_rect(int offset = 1) { |
| 87 return SkRect::MakeWH(SkIntToScalar(R(kBitmapSize)+offset), |
| 88 SkIntToScalar(R(kBitmapSize)+offset)); |
| 89 } |
| 90 |
| 91 static SkXfermode::Mode make_xfermode() { |
| 92 return static_cast<SkXfermode::Mode>(R(SkXfermode::kLastMode+1)); |
| 93 } |
| 94 |
| 95 static SkColor make_color() { |
| 96 return (R(2) == 1) ? 0xFFC0F0A0 : 0xFF000090; |
| 97 } |
| 98 |
| 99 static SkPoint3 make_point() { |
| 100 return SkPoint3(make_scalar(), make_scalar(), make_scalar(true)); |
| 101 } |
| 102 |
| 103 static SkDisplacementMapEffect::ChannelSelectorType make_channel_selector_type()
{ |
| 104 return static_cast<SkDisplacementMapEffect::ChannelSelectorType>(R(4)+1); |
| 105 } |
| 106 |
| 107 static void make_g_bitmap(SkBitmap& bitmap) { |
| 108 bitmap.setConfig(SkBitmap::kARGB_8888_Config, kBitmapSize, kBitmapSize); |
| 109 bitmap.allocPixels(); |
| 110 SkDevice device(bitmap); |
| 111 SkCanvas canvas(&device); |
| 112 canvas.clear(0x00000000); |
| 113 SkPaint paint; |
| 114 paint.setAntiAlias(true); |
| 115 paint.setColor(0xFF884422); |
| 116 paint.setTextSize(SkIntToScalar(kBitmapSize/2)); |
| 117 const char* str = "g"; |
| 118 canvas.drawText(str, strlen(str), SkIntToScalar(kBitmapSize/8), |
| 119 SkIntToScalar(kBitmapSize/4), paint); |
| 120 } |
| 121 |
| 122 static void make_checkerboard_bitmap(SkBitmap& bitmap) { |
| 123 bitmap.setConfig(SkBitmap::kARGB_8888_Config, kBitmapSize, kBitmapSize); |
| 124 bitmap.allocPixels(); |
| 125 SkDevice device(bitmap); |
| 126 SkCanvas canvas(&device); |
| 127 canvas.clear(0x00000000); |
| 128 SkPaint darkPaint; |
| 129 darkPaint.setColor(0xFF804020); |
| 130 SkPaint lightPaint; |
| 131 lightPaint.setColor(0xFF244484); |
| 132 const int i = kBitmapSize / 8; |
| 133 for (int y = 0; y < kBitmapSize; y += i) { |
| 134 for (int x = 0; x < kBitmapSize; x += i) { |
| 135 canvas.save(); |
| 136 canvas.translate(SkIntToScalar(x), SkIntToScalar(y)); |
| 137 canvas.drawRect(SkRect::MakeXYWH(0, 0, i, i), darkPaint); |
| 138 canvas.drawRect(SkRect::MakeXYWH(i, 0, i, i), lightPaint); |
| 139 canvas.drawRect(SkRect::MakeXYWH(0, i, i, i), lightPaint); |
| 140 canvas.drawRect(SkRect::MakeXYWH(i, i, i, i), darkPaint); |
| 141 canvas.restore(); |
| 142 } |
| 143 } |
| 144 } |
| 145 |
| 146 static const SkBitmap& make_bitmap() { |
| 147 static SkBitmap bitmap[2]; |
| 148 static bool initialized = false; |
| 149 if (!initialized) { |
| 150 make_g_bitmap(bitmap[0]); |
| 151 make_checkerboard_bitmap(bitmap[1]); |
| 152 initialized = true; |
| 153 } |
| 154 return bitmap[R(2)]; |
| 155 } |
| 156 |
| 157 static SkImageFilter* make_image_filter(bool canBeNull = true) { |
| 158 SkImageFilter* filter = 0; |
| 159 |
| 160 // Add a 1 in 3 chance to get a NULL input |
| 161 if (canBeNull && (R(3) == 1)) { return filter; } |
| 162 |
| 163 enum { BICUBIC, MERGE, COLOR, BLUR, MAGNIFIER, XFERMODE, OFFSET, COMPOSE, |
| 164 DISTANT_LIGHT, POINT_LIGHT, SPOT_LIGHT, NOISE, DROP_SHADOW, |
| 165 MORPHOLOGY, BITMAP, DISPLACE, NUM_FILTERS }; |
| 166 |
| 167 switch (R(NUM_FILTERS)) { |
| 168 case BICUBIC: |
| 169 // Scale is set to 1 here so that it can fit in the DAG without resizing
the output |
| 170 filter = SkBicubicImageFilter::CreateMitchell(SkSize::Make(1, 1), make_i
mage_filter()); |
| 171 break; |
| 172 case MERGE: |
| 173 filter = new SkMergeImageFilter(make_image_filter(), make_image_filter()
, make_xfermode()); |
| 174 break; |
| 175 case COLOR: |
| 176 { |
| 177 SkAutoTUnref<SkColorFilter> cf((R(2) == 1) ? |
| 178 SkColorFilter::CreateModeFilter(make_color(), make_xfermode())
: |
| 179 SkColorFilter::CreateLightingFilter(make_color(), make_color())
); |
| 180 filter = cf.get() ? SkColorFilterImageFilter::Create(cf, make_image_filt
er()) : 0; |
| 181 } |
| 182 break; |
| 183 case BLUR: |
| 184 filter = new SkBlurImageFilter(make_scalar(true), make_scalar(true), mak
e_image_filter()); |
| 185 break; |
| 186 case MAGNIFIER: |
| 187 filter = new SkMagnifierImageFilter(make_rect(0), make_scalar(true)); |
| 188 break; |
| 189 case XFERMODE: |
| 190 { |
| 191 SkAutoTUnref<SkXfermode> mode(SkXfermode::Create(make_xfermode())); |
| 192 filter = new SkXfermodeImageFilter(mode, make_image_filter(), make_image
_filter()); |
| 193 } |
| 194 break; |
| 195 case OFFSET: |
| 196 filter = new SkOffsetImageFilter(make_scalar(), make_scalar(), make_imag
e_filter()); |
| 197 break; |
| 198 case COMPOSE: |
| 199 filter = new SkComposeImageFilter(make_image_filter(), make_image_filter
()); |
| 200 break; |
| 201 case DISTANT_LIGHT: |
| 202 filter = (R(2) == 1) ? |
| 203 SkLightingImageFilter::CreateDistantLitDiffuse(make_point(), |
| 204 make_color(), make_scalar(), make_scalar(), make_image_filter()
) : |
| 205 SkLightingImageFilter::CreateDistantLitSpecular(make_point(), |
| 206 make_color(), make_scalar(), make_scalar(), SkIntToScalar(R(10)
), |
| 207 make_image_filter()); |
| 208 break; |
| 209 case POINT_LIGHT: |
| 210 filter = (R(2) == 1) ? |
| 211 SkLightingImageFilter::CreatePointLitDiffuse(make_point(), |
| 212 make_color(), make_scalar(), make_scalar(), make_image_filter()
) : |
| 213 SkLightingImageFilter::CreatePointLitSpecular(make_point(), |
| 214 make_color(), make_scalar(), make_scalar(), SkIntToScalar(R(10)
), |
| 215 make_image_filter()); |
| 216 break; |
| 217 case SPOT_LIGHT: |
| 218 filter = (R(2) == 1) ? |
| 219 SkLightingImageFilter::CreateSpotLitDiffuse(SkPoint3(0, 0, 0), |
| 220 make_point(), make_scalar(), make_scalar(), make_color(), |
| 221 make_scalar(), make_scalar(), make_image_filter()) : |
| 222 SkLightingImageFilter::CreateSpotLitSpecular(SkPoint3(0, 0, 0), |
| 223 make_point(), make_scalar(), make_scalar(), make_color(), |
| 224 make_scalar(), make_scalar(), SkIntToScalar(R(10)), make_image_
filter()); |
| 225 break; |
| 226 case NOISE: |
| 227 { |
| 228 SkAutoTUnref<SkShader> shader((R(2) == 1) ? |
| 229 SkPerlinNoiseShader::CreateFractalNoise( |
| 230 make_scalar(true), make_scalar(true), R(10), make_scalar()) : |
| 231 SkPerlinNoiseShader::CreateTubulence( |
| 232 make_scalar(true), make_scalar(true), R(10), make_scalar())); |
| 233 filter = SkRectShaderImageFilter::Create(shader, SkRect::MakeWH(kBitmapS
ize, kBitmapSize)); |
| 234 } |
| 235 break; |
| 236 case DROP_SHADOW: |
| 237 filter = new SkDropShadowImageFilter(make_scalar(), make_scalar(), |
| 238 make_scalar(true), make_color(), make_image_filter()); |
| 239 break; |
| 240 case MORPHOLOGY: |
| 241 if (R(2) == 1) |
| 242 filter = new SkDilateImageFilter(R(kBitmapSize), R(kBitmapSize), mak
e_image_filter()); |
| 243 else |
| 244 filter = new SkErodeImageFilter(R(kBitmapSize), R(kBitmapSize), make
_image_filter()); |
| 245 break; |
| 246 case BITMAP: |
| 247 filter = new SkBitmapSource(make_bitmap()); |
| 248 break; |
| 249 case DISPLACE: |
| 250 filter = new SkDisplacementMapEffect(make_channel_selector_type(), |
| 251 make_channel_selector_type(), make_scalar(), |
| 252 make_image_filter(false), make_image_filter()); |
| 253 break; |
| 254 default: |
| 255 break; |
| 256 } |
| 257 return (filter || canBeNull) ? filter : make_image_filter(canBeNull); |
| 258 } |
| 259 |
| 260 void drawClippedBitmap(SkCanvas* canvas, int x, int y, const SkPaint& paint) { |
| 261 canvas->save(); |
| 262 canvas->clipRect(SkRect::MakeXYWH(SkIntToScalar(x), SkIntToScalar(y), |
| 263 SkIntToScalar(kBitmapSize), SkIntToScalar(kBitmapSize))); |
| 264 canvas->drawBitmap(make_bitmap(), SkIntToScalar(x), SkIntToScalar(y), &paint
); |
| 265 canvas->restore(); |
| 266 } |
| 267 |
| 268 static void do_fuzz(SkCanvas* canvas) { |
| 269 SkPaint paint; |
| 270 paint.setImageFilter(make_image_filter()); |
| 271 drawClippedBitmap(canvas, 0, 0, paint); |
| 272 } |
| 273 |
| 274 ////////////////////////////////////////////////////////////////////////////// |
| 275 |
| 276 class ImageFilterFuzzView : public SampleView { |
| 277 public: |
| 278 ImageFilterFuzzView() { |
| 279 this->setBGColor(0xFFDDDDDD); |
| 280 } |
| 281 |
| 282 protected: |
| 283 // overrides from SkEventSink |
| 284 virtual bool onQuery(SkEvent* evt) { |
| 285 if (SampleCode::TitleQ(*evt)) { |
| 286 SampleCode::TitleR(evt, "ImageFilterFuzzer"); |
| 287 return true; |
| 288 } |
| 289 return this->INHERITED::onQuery(evt); |
| 290 } |
| 291 |
| 292 void drawBG(SkCanvas* canvas) { |
| 293 canvas->drawColor(0xFFDDDDDD); |
| 294 } |
| 295 |
| 296 virtual void onDrawContent(SkCanvas* canvas) { |
| 297 do_fuzz(canvas); |
| 298 this->inval(0); |
| 299 } |
| 300 |
| 301 private: |
| 302 typedef SkView INHERITED; |
| 303 }; |
| 304 |
| 305 ////////////////////////////////////////////////////////////////////////////// |
| 306 |
| 307 static SkView* MyFactory() { return new ImageFilterFuzzView; } |
| 308 static SkViewRegister reg(MyFactory); |
OLD | NEW |