OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2013 Google Inc. | 2 * Copyright 2013 Google Inc. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license that can be | 4 * Use of this source code is governed by a BSD-style license that can be |
5 * found in the LICENSE file. | 5 * found in the LICENSE file. |
6 */ | 6 */ |
7 | 7 |
8 #include "SkBitmap.h" | 8 #include "SkBitmap.h" |
9 #include "SkBitmapDevice.h" | 9 #include "SkBitmapDevice.h" |
10 #include "SkBitmapSource.h" | 10 #include "SkBitmapSource.h" |
(...skipping 246 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
257 0xFFFFFFFF, SK_Scalar1, SK_Scalar1, SK_Scalar1, | 257 0xFFFFFFFF, SK_Scalar1, SK_Scalar1, SK_Scalar1, |
258 bmSrc))->unref(); | 258 bmSrc))->unref(); |
259 SkCanvas canvas(result); | 259 SkCanvas canvas(result); |
260 SkRect r = SkRect::MakeWH(SkIntToScalar(kBitmapSize), | 260 SkRect r = SkRect::MakeWH(SkIntToScalar(kBitmapSize), |
261 SkIntToScalar(kBitmapSize)); | 261 SkIntToScalar(kBitmapSize)); |
262 canvas.drawRect(r, paint); | 262 canvas.drawRect(r, paint); |
263 } | 263 } |
264 } | 264 } |
265 } | 265 } |
266 | 266 |
267 static void test_crop_rects(SkBaseDevice* device, skiatest::Reporter* reporter)
{ | 267 static void test_crop_rects(SkImageFilter::Proxy* proxy, skiatest::Reporter* rep
orter) { |
268 // Check that all filters offset to their absolute crop rect, | 268 // Check that all filters offset to their absolute crop rect, |
269 // unaffected by the input crop rect. | 269 // unaffected by the input crop rect. |
270 // Tests pass by not asserting. | 270 // Tests pass by not asserting. |
271 SkBitmap bitmap; | 271 SkBitmap bitmap; |
272 bitmap.allocN32Pixels(100, 100); | 272 bitmap.allocN32Pixels(100, 100); |
273 bitmap.eraseARGB(0, 0, 0, 0); | 273 bitmap.eraseARGB(0, 0, 0, 0); |
274 SkImageFilter::Proxy proxy(device, SkSurfaceProps(SkSurfaceProps::kLegacyFon
tHost_InitType)); | |
275 | 274 |
276 SkImageFilter::CropRect inputCropRect(SkRect::MakeXYWH(8, 13, 80, 80)); | 275 SkImageFilter::CropRect inputCropRect(SkRect::MakeXYWH(8, 13, 80, 80)); |
277 SkImageFilter::CropRect cropRect(SkRect::MakeXYWH(20, 30, 60, 60)); | 276 SkImageFilter::CropRect cropRect(SkRect::MakeXYWH(20, 30, 60, 60)); |
278 SkAutoTUnref<SkImageFilter> input(make_grayscale(NULL, &inputCropRect)); | 277 SkAutoTUnref<SkImageFilter> input(make_grayscale(NULL, &inputCropRect)); |
279 | 278 |
280 SkAutoTUnref<SkColorFilter> cf(SkColorFilter::CreateModeFilter(SK_ColorRED,
SkXfermode::kSrcIn_Mode)); | 279 SkAutoTUnref<SkColorFilter> cf(SkColorFilter::CreateModeFilter(SK_ColorRED,
SkXfermode::kSrcIn_Mode)); |
281 SkPoint3 location(0, 0, SK_Scalar1); | 280 SkPoint3 location(0, 0, SK_Scalar1); |
282 SkPoint3 target(SK_Scalar1, SK_Scalar1, SK_Scalar1); | 281 SkPoint3 target(SK_Scalar1, SK_Scalar1, SK_Scalar1); |
283 SkScalar kernel[9] = { | 282 SkScalar kernel[9] = { |
284 SkIntToScalar( 1), SkIntToScalar( 1), SkIntToScalar( 1), | 283 SkIntToScalar( 1), SkIntToScalar( 1), SkIntToScalar( 1), |
(...skipping 24 matching lines...) Expand all Loading... |
309 SkXfermodeImageFilter::Create(SkXfermode::Create(SkXfermode::kSrcOver_Mo
de), input.get(), input.get(), &cropRect), | 308 SkXfermodeImageFilter::Create(SkXfermode::Create(SkXfermode::kSrcOver_Mo
de), input.get(), input.get(), &cropRect), |
310 }; | 309 }; |
311 | 310 |
312 for (size_t i = 0; i < SK_ARRAY_COUNT(filters); ++i) { | 311 for (size_t i = 0; i < SK_ARRAY_COUNT(filters); ++i) { |
313 SkImageFilter* filter = filters[i]; | 312 SkImageFilter* filter = filters[i]; |
314 SkBitmap result; | 313 SkBitmap result; |
315 SkIPoint offset; | 314 SkIPoint offset; |
316 SkString str; | 315 SkString str; |
317 str.printf("filter %d", static_cast<int>(i)); | 316 str.printf("filter %d", static_cast<int>(i)); |
318 SkImageFilter::Context ctx(SkMatrix::I(), SkIRect::MakeLargest(), NULL); | 317 SkImageFilter::Context ctx(SkMatrix::I(), SkIRect::MakeLargest(), NULL); |
319 REPORTER_ASSERT_MESSAGE(reporter, filter->filterImage(&proxy, bitmap, ct
x, | 318 REPORTER_ASSERT_MESSAGE(reporter, filter->filterImage(proxy, bitmap, ctx
, |
320 &result, &offset), str.c_str()); | 319 &result, &offset), str.c_str()); |
321 REPORTER_ASSERT_MESSAGE(reporter, offset.fX == 20 && offset.fY == 30, st
r.c_str()); | 320 REPORTER_ASSERT_MESSAGE(reporter, offset.fX == 20 && offset.fY == 30, st
r.c_str()); |
322 } | 321 } |
323 | 322 |
324 for (size_t i = 0; i < SK_ARRAY_COUNT(filters); ++i) { | 323 for (size_t i = 0; i < SK_ARRAY_COUNT(filters); ++i) { |
325 SkSafeUnref(filters[i]); | 324 SkSafeUnref(filters[i]); |
326 } | 325 } |
327 } | 326 } |
328 | 327 |
329 static SkBitmap make_gradient_circle(int width, int height) { | 328 static SkBitmap make_gradient_circle(int width, int height) { |
(...skipping 10 matching lines...) Expand all Loading... |
340 SkAutoTUnref<SkShader> shader( | 339 SkAutoTUnref<SkShader> shader( |
341 SkGradientShader::CreateRadial(SkPoint::Make(x, y), radius, colors, NULL
, 2, | 340 SkGradientShader::CreateRadial(SkPoint::Make(x, y), radius, colors, NULL
, 2, |
342 SkShader::kClamp_TileMode) | 341 SkShader::kClamp_TileMode) |
343 ); | 342 ); |
344 SkPaint paint; | 343 SkPaint paint; |
345 paint.setShader(shader); | 344 paint.setShader(shader); |
346 canvas.drawCircle(x, y, radius, paint); | 345 canvas.drawCircle(x, y, radius, paint); |
347 return bitmap; | 346 return bitmap; |
348 } | 347 } |
349 | 348 |
350 static void test_negative_blur_sigma(SkBaseDevice* device, skiatest::Reporter* r
eporter) { | 349 static void test_negative_blur_sigma(SkImageFilter::Proxy* proxy, skiatest::Repo
rter* reporter) { |
351 // Check that SkBlurImageFilter will accept a negative sigma, either in | 350 // Check that SkBlurImageFilter will accept a negative sigma, either in |
352 // the given arguments or after CTM application. | 351 // the given arguments or after CTM application. |
353 int width = 32, height = 32; | 352 int width = 32, height = 32; |
354 SkImageFilter::Proxy proxy(device, SkSurfaceProps(SkSurfaceProps::kLegacyFon
tHost_InitType)); | |
355 SkScalar five = SkIntToScalar(5); | 353 SkScalar five = SkIntToScalar(5); |
356 | 354 |
357 SkAutoTUnref<SkBlurImageFilter> positiveFilter( | 355 SkAutoTUnref<SkBlurImageFilter> positiveFilter( |
358 SkBlurImageFilter::Create(five, five) | 356 SkBlurImageFilter::Create(five, five) |
359 ); | 357 ); |
360 | 358 |
361 SkAutoTUnref<SkBlurImageFilter> negativeFilter( | 359 SkAutoTUnref<SkBlurImageFilter> negativeFilter( |
362 SkBlurImageFilter::Create(-five, five) | 360 SkBlurImageFilter::Create(-five, five) |
363 ); | 361 ); |
364 | 362 |
365 SkBitmap gradient = make_gradient_circle(width, height); | 363 SkBitmap gradient = make_gradient_circle(width, height); |
366 SkBitmap positiveResult1, negativeResult1; | 364 SkBitmap positiveResult1, negativeResult1; |
367 SkBitmap positiveResult2, negativeResult2; | 365 SkBitmap positiveResult2, negativeResult2; |
368 SkIPoint offset; | 366 SkIPoint offset; |
369 SkImageFilter::Context ctx(SkMatrix::I(), SkIRect::MakeLargest(), NULL); | 367 SkImageFilter::Context ctx(SkMatrix::I(), SkIRect::MakeLargest(), NULL); |
370 positiveFilter->filterImage(&proxy, gradient, ctx, &positiveResult1, &offset
); | 368 positiveFilter->filterImage(proxy, gradient, ctx, &positiveResult1, &offset)
; |
371 negativeFilter->filterImage(&proxy, gradient, ctx, &negativeResult1, &offset
); | 369 negativeFilter->filterImage(proxy, gradient, ctx, &negativeResult1, &offset)
; |
372 SkMatrix negativeScale; | 370 SkMatrix negativeScale; |
373 negativeScale.setScale(-SK_Scalar1, SK_Scalar1); | 371 negativeScale.setScale(-SK_Scalar1, SK_Scalar1); |
374 SkImageFilter::Context negativeCTX(negativeScale, SkIRect::MakeLargest(), NU
LL); | 372 SkImageFilter::Context negativeCTX(negativeScale, SkIRect::MakeLargest(), NU
LL); |
375 positiveFilter->filterImage(&proxy, gradient, negativeCTX, &negativeResult2,
&offset); | 373 positiveFilter->filterImage(proxy, gradient, negativeCTX, &negativeResult2,
&offset); |
376 negativeFilter->filterImage(&proxy, gradient, negativeCTX, &positiveResult2,
&offset); | 374 negativeFilter->filterImage(proxy, gradient, negativeCTX, &positiveResult2,
&offset); |
377 SkAutoLockPixels lockP1(positiveResult1); | 375 SkAutoLockPixels lockP1(positiveResult1); |
378 SkAutoLockPixels lockP2(positiveResult2); | 376 SkAutoLockPixels lockP2(positiveResult2); |
379 SkAutoLockPixels lockN1(negativeResult1); | 377 SkAutoLockPixels lockN1(negativeResult1); |
380 SkAutoLockPixels lockN2(negativeResult2); | 378 SkAutoLockPixels lockN2(negativeResult2); |
381 for (int y = 0; y < height; y++) { | 379 for (int y = 0; y < height; y++) { |
382 int diffs = memcmp(positiveResult1.getAddr32(0, y), negativeResult1.getA
ddr32(0, y), positiveResult1.rowBytes()); | 380 int diffs = memcmp(positiveResult1.getAddr32(0, y), negativeResult1.getA
ddr32(0, y), positiveResult1.rowBytes()); |
383 REPORTER_ASSERT(reporter, !diffs); | 381 REPORTER_ASSERT(reporter, !diffs); |
384 if (diffs) { | 382 if (diffs) { |
385 break; | 383 break; |
386 } | 384 } |
387 diffs = memcmp(positiveResult1.getAddr32(0, y), negativeResult2.getAddr3
2(0, y), positiveResult1.rowBytes()); | 385 diffs = memcmp(positiveResult1.getAddr32(0, y), negativeResult2.getAddr3
2(0, y), positiveResult1.rowBytes()); |
388 REPORTER_ASSERT(reporter, !diffs); | 386 REPORTER_ASSERT(reporter, !diffs); |
389 if (diffs) { | 387 if (diffs) { |
390 break; | 388 break; |
391 } | 389 } |
392 diffs = memcmp(positiveResult1.getAddr32(0, y), positiveResult2.getAddr3
2(0, y), positiveResult1.rowBytes()); | 390 diffs = memcmp(positiveResult1.getAddr32(0, y), positiveResult2.getAddr3
2(0, y), positiveResult1.rowBytes()); |
393 REPORTER_ASSERT(reporter, !diffs); | 391 REPORTER_ASSERT(reporter, !diffs); |
394 if (diffs) { | 392 if (diffs) { |
395 break; | 393 break; |
396 } | 394 } |
397 } | 395 } |
398 } | 396 } |
399 | 397 |
400 DEF_TEST(TestNegativeBlurSigma, reporter) { | 398 DEF_TEST(TestNegativeBlurSigma, reporter) { |
401 SkBitmap temp; | 399 const SkImageInfo info = SkImageInfo::MakeN32Premul(100, 100); |
402 temp.allocN32Pixels(100, 100); | 400 const SkSurfaceProps props(SkSurfaceProps::kLegacyFontHost_InitType); |
403 SkBitmapDevice device(temp); | 401 |
404 test_negative_blur_sigma(&device, reporter); | 402 SkAutoTUnref<SkBaseDevice> device(SkBitmapDevice::Create(info, props)); |
| 403 SkImageFilter::Proxy proxy(device, props); |
| 404 |
| 405 test_negative_blur_sigma(&proxy, reporter); |
405 } | 406 } |
406 | 407 |
407 DEF_TEST(ImageFilterDrawTiled, reporter) { | 408 DEF_TEST(ImageFilterDrawTiled, reporter) { |
408 // Check that all filters when drawn tiled (with subsequent clip rects) exac
tly | 409 // Check that all filters when drawn tiled (with subsequent clip rects) exac
tly |
409 // match the same filters drawn with a single full-canvas bitmap draw. | 410 // match the same filters drawn with a single full-canvas bitmap draw. |
410 // Tests pass by not asserting. | 411 // Tests pass by not asserting. |
411 | 412 |
412 SkAutoTUnref<SkColorFilter> cf(SkColorFilter::CreateModeFilter(SK_ColorRED,
SkXfermode::kSrcIn_Mode)); | 413 SkAutoTUnref<SkColorFilter> cf(SkColorFilter::CreateModeFilter(SK_ColorRED,
SkXfermode::kSrcIn_Mode)); |
413 SkPoint3 location(0, 0, SK_Scalar1); | 414 SkPoint3 location(0, 0, SK_Scalar1); |
414 SkPoint3 target(SK_Scalar1, SK_Scalar1, SK_Scalar1); | 415 SkPoint3 target(SK_Scalar1, SK_Scalar1, SK_Scalar1); |
(...skipping 346 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
761 filterPaint.setImageFilter(filter); | 762 filterPaint.setImageFilter(filter); |
762 SkRect bounds = SkRect::MakeWH(1, 10); | 763 SkRect bounds = SkRect::MakeWH(1, 10); |
763 SkRect rect = SkRect::Make(SkIRect::MakeWH(width, height)); | 764 SkRect rect = SkRect::Make(SkIRect::MakeWH(width, height)); |
764 SkPaint rectPaint; | 765 SkPaint rectPaint; |
765 canvas.saveLayer(&bounds, &filterPaint); | 766 canvas.saveLayer(&bounds, &filterPaint); |
766 canvas.drawRect(rect, rectPaint); | 767 canvas.drawRect(rect, rectPaint); |
767 canvas.restore(); | 768 canvas.restore(); |
768 } | 769 } |
769 | 770 |
770 DEF_TEST(ImageFilterCropRect, reporter) { | 771 DEF_TEST(ImageFilterCropRect, reporter) { |
771 SkBitmap temp; | 772 const SkImageInfo info = SkImageInfo::MakeN32Premul(100, 100); |
772 temp.allocN32Pixels(100, 100); | 773 const SkSurfaceProps props(SkSurfaceProps::kLegacyFontHost_InitType); |
773 SkBitmapDevice device(temp); | 774 |
774 test_crop_rects(&device, reporter); | 775 SkAutoTUnref<SkBaseDevice> device(SkBitmapDevice::Create(info, props)); |
| 776 SkImageFilter::Proxy proxy(device, props); |
| 777 |
| 778 test_crop_rects(&proxy, reporter); |
775 } | 779 } |
776 | 780 |
777 DEF_TEST(ImageFilterMatrix, reporter) { | 781 DEF_TEST(ImageFilterMatrix, reporter) { |
778 SkBitmap temp; | 782 SkBitmap temp; |
779 temp.allocN32Pixels(100, 100); | 783 temp.allocN32Pixels(100, 100); |
780 SkBitmapDevice device(temp); | 784 SkCanvas canvas(temp); |
781 SkCanvas canvas(&device); | |
782 canvas.scale(SkIntToScalar(2), SkIntToScalar(2)); | 785 canvas.scale(SkIntToScalar(2), SkIntToScalar(2)); |
783 | 786 |
784 SkMatrix expectedMatrix = canvas.getTotalMatrix(); | 787 SkMatrix expectedMatrix = canvas.getTotalMatrix(); |
785 | 788 |
786 SkRTreeFactory factory; | 789 SkRTreeFactory factory; |
787 SkPictureRecorder recorder; | 790 SkPictureRecorder recorder; |
788 SkCanvas* recordingCanvas = recorder.beginRecording(100, 100, &factory, 0); | 791 SkCanvas* recordingCanvas = recorder.beginRecording(100, 100, &factory, 0); |
789 | 792 |
790 SkPaint paint; | 793 SkPaint paint; |
791 SkAutoTUnref<MatrixTestImageFilter> imageFilter( | 794 SkAutoTUnref<MatrixTestImageFilter> imageFilter( |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
826 SkPictureRecorder outerRecorder; | 829 SkPictureRecorder outerRecorder; |
827 SkCanvas* outerCanvas = outerRecorder.beginRecording(1, 1, &factory, 0); | 830 SkCanvas* outerCanvas = outerRecorder.beginRecording(1, 1, &factory, 0); |
828 SkPaint redPaintWithFilter; | 831 SkPaint redPaintWithFilter; |
829 redPaintWithFilter.setColor(SK_ColorRED); | 832 redPaintWithFilter.setColor(SK_ColorRED); |
830 redPaintWithFilter.setImageFilter(imageFilter.get()); | 833 redPaintWithFilter.setImageFilter(imageFilter.get()); |
831 outerCanvas->drawRect(SkRect::Make(SkIRect::MakeWH(1, 1)), redPaintWithFilte
r); | 834 outerCanvas->drawRect(SkRect::Make(SkIRect::MakeWH(1, 1)), redPaintWithFilte
r); |
832 SkAutoTUnref<SkPicture> outerPicture(outerRecorder.endRecording()); | 835 SkAutoTUnref<SkPicture> outerPicture(outerRecorder.endRecording()); |
833 | 836 |
834 SkBitmap bitmap; | 837 SkBitmap bitmap; |
835 bitmap.allocN32Pixels(1, 1); | 838 bitmap.allocN32Pixels(1, 1); |
836 SkBitmapDevice device(bitmap); | 839 SkCanvas canvas(bitmap); |
837 SkCanvas canvas(&device); | |
838 | 840 |
839 // The result here should be green, since the filter replaces the primitive'
s red interior. | 841 // The result here should be green, since the filter replaces the primitive'
s red interior. |
840 canvas.clear(0x0); | 842 canvas.clear(0x0); |
841 canvas.drawPicture(outerPicture); | 843 canvas.drawPicture(outerPicture); |
842 uint32_t pixel = *bitmap.getAddr32(0, 0); | 844 uint32_t pixel = *bitmap.getAddr32(0, 0); |
843 REPORTER_ASSERT(reporter, pixel == SK_ColorGREEN); | 845 REPORTER_ASSERT(reporter, pixel == SK_ColorGREEN); |
844 | 846 |
845 // Check that, for now, SkPictureImageFilter does not serialize or | 847 // Check that, for now, SkPictureImageFilter does not serialize or |
846 // deserialize its contained picture when the filter is serialized | 848 // deserialize its contained picture when the filter is serialized |
847 // cross-process. Do this by "laundering" it through SkValidatingReadBuffer. | 849 // cross-process. Do this by "laundering" it through SkValidatingReadBuffer. |
(...skipping 21 matching lines...) Expand all Loading... |
869 SkRTreeFactory factory; | 871 SkRTreeFactory factory; |
870 SkPictureRecorder recorder; | 872 SkPictureRecorder recorder; |
871 SkCanvas* recordingCanvas = recorder.beginRecording(1, 1, &factory, 0); | 873 SkCanvas* recordingCanvas = recorder.beginRecording(1, 1, &factory, 0); |
872 | 874 |
873 // Create an SkPicture which simply draws a green 1x1 rectangle. | 875 // Create an SkPicture which simply draws a green 1x1 rectangle. |
874 SkPaint greenPaint; | 876 SkPaint greenPaint; |
875 greenPaint.setColor(SK_ColorGREEN); | 877 greenPaint.setColor(SK_ColorGREEN); |
876 recordingCanvas->drawRect(SkRect::Make(SkIRect::MakeWH(1, 1)), greenPaint); | 878 recordingCanvas->drawRect(SkRect::Make(SkIRect::MakeWH(1, 1)), greenPaint); |
877 SkAutoTUnref<SkPicture> picture(recorder.endRecording()); | 879 SkAutoTUnref<SkPicture> picture(recorder.endRecording()); |
878 | 880 |
879 SkAutoTUnref<SkImageFilter> imageFilter( | 881 SkAutoTUnref<SkImageFilter> imageFilter(SkPictureImageFilter::Create(picture
.get())); |
880 SkPictureImageFilter::Create(picture.get())); | |
881 | 882 |
882 SkBitmap result; | 883 SkBitmap result; |
883 SkIPoint offset; | 884 SkIPoint offset; |
884 SkImageFilter::Context ctx(SkMatrix::I(), SkIRect::MakeXYWH(1, 1, 1, 1), NUL
L); | 885 SkImageFilter::Context ctx(SkMatrix::I(), SkIRect::MakeXYWH(1, 1, 1, 1), NUL
L); |
885 SkBitmap bitmap; | 886 SkBitmap bitmap; |
886 bitmap.allocN32Pixels(2, 2); | 887 bitmap.allocN32Pixels(2, 2); |
887 SkBitmapDevice device(bitmap); | 888 SkBitmapDevice device(bitmap, SkSurfaceProps(SkSurfaceProps::kLegacyFontHost
_InitType)); |
888 SkImageFilter::Proxy proxy(&device, SkSurfaceProps(SkSurfaceProps::kLegacyFo
ntHost_InitType)); | 889 SkImageFilter::Proxy proxy(&device, SkSurfaceProps(SkSurfaceProps::kLegacyFo
ntHost_InitType)); |
889 REPORTER_ASSERT(reporter, !imageFilter->filterImage(&proxy, bitmap, ctx, &re
sult, &offset)); | 890 REPORTER_ASSERT(reporter, !imageFilter->filterImage(&proxy, bitmap, ctx, &re
sult, &offset)); |
890 } | 891 } |
891 | 892 |
892 DEF_TEST(ImageFilterEmptySaveLayer, reporter) { | 893 DEF_TEST(ImageFilterEmptySaveLayer, reporter) { |
893 // Even when there's an empty saveLayer()/restore(), ensure that an image | 894 // Even when there's an empty saveLayer()/restore(), ensure that an image |
894 // filter or color filter which affects transparent black still draws. | 895 // filter or color filter which affects transparent black still draws. |
895 | 896 |
896 SkBitmap bitmap; | 897 SkBitmap bitmap; |
897 bitmap.allocN32Pixels(10, 10); | 898 bitmap.allocN32Pixels(10, 10); |
898 SkBitmapDevice device(bitmap); | 899 SkCanvas canvas(bitmap); |
899 SkCanvas canvas(&device); | |
900 | 900 |
901 SkRTreeFactory factory; | 901 SkRTreeFactory factory; |
902 SkPictureRecorder recorder; | 902 SkPictureRecorder recorder; |
903 | 903 |
904 SkAutoTUnref<SkColorFilter> green( | 904 SkAutoTUnref<SkColorFilter> green( |
905 SkColorFilter::CreateModeFilter(SK_ColorGREEN, SkXfermode::kSrc_Mode)); | 905 SkColorFilter::CreateModeFilter(SK_ColorGREEN, SkXfermode::kSrc_Mode)); |
906 SkAutoTUnref<SkColorFilterImageFilter> imageFilter( | 906 SkAutoTUnref<SkColorFilterImageFilter> imageFilter( |
907 SkColorFilterImageFilter::Create(green.get())); | 907 SkColorFilterImageFilter::Create(green.get())); |
908 SkPaint imageFilterPaint; | 908 SkPaint imageFilterPaint; |
909 imageFilterPaint.setImageFilter(imageFilter.get()); | 909 imageFilterPaint.setImageFilter(imageFilter.get()); |
(...skipping 26 matching lines...) Expand all Loading... |
936 recordingCanvas->saveLayer(&bounds, &colorFilterPaint); | 936 recordingCanvas->saveLayer(&bounds, &colorFilterPaint); |
937 recordingCanvas->restore(); | 937 recordingCanvas->restore(); |
938 SkAutoTUnref<SkPicture> picture3(recorder.endRecording()); | 938 SkAutoTUnref<SkPicture> picture3(recorder.endRecording()); |
939 | 939 |
940 canvas.clear(0); | 940 canvas.clear(0); |
941 canvas.drawPicture(picture3); | 941 canvas.drawPicture(picture3); |
942 pixel = *bitmap.getAddr32(0, 0); | 942 pixel = *bitmap.getAddr32(0, 0); |
943 REPORTER_ASSERT(reporter, pixel == SK_ColorGREEN); | 943 REPORTER_ASSERT(reporter, pixel == SK_ColorGREEN); |
944 } | 944 } |
945 | 945 |
946 static void test_huge_blur(SkBaseDevice* device, skiatest::Reporter* reporter) { | 946 static void test_huge_blur(SkCanvas* canvas, skiatest::Reporter* reporter) { |
947 SkCanvas canvas(device); | |
948 | |
949 SkBitmap bitmap; | 947 SkBitmap bitmap; |
950 bitmap.allocN32Pixels(100, 100); | 948 bitmap.allocN32Pixels(100, 100); |
951 bitmap.eraseARGB(0, 0, 0, 0); | 949 bitmap.eraseARGB(0, 0, 0, 0); |
952 | 950 |
953 // Check that a blur with an insane radius does not crash or assert. | 951 // Check that a blur with an insane radius does not crash or assert. |
954 SkAutoTUnref<SkImageFilter> blur(SkBlurImageFilter::Create(SkIntToScalar(1<<
30), SkIntToScalar(1<<30))); | 952 SkAutoTUnref<SkImageFilter> blur(SkBlurImageFilter::Create(SkIntToScalar(1<<
30), SkIntToScalar(1<<30))); |
955 | 953 |
956 SkPaint paint; | 954 SkPaint paint; |
957 paint.setImageFilter(blur); | 955 paint.setImageFilter(blur); |
958 canvas.drawSprite(bitmap, 0, 0, &paint); | 956 canvas->drawSprite(bitmap, 0, 0, &paint); |
959 } | 957 } |
960 | 958 |
961 DEF_TEST(HugeBlurImageFilter, reporter) { | 959 DEF_TEST(HugeBlurImageFilter, reporter) { |
962 SkBitmap temp; | 960 SkBitmap temp; |
963 temp.allocN32Pixels(100, 100); | 961 temp.allocN32Pixels(100, 100); |
964 SkBitmapDevice device(temp); | 962 SkCanvas canvas(temp); |
965 test_huge_blur(&device, reporter); | 963 test_huge_blur(&canvas, reporter); |
966 } | 964 } |
967 | 965 |
968 DEF_TEST(MatrixConvolutionSanityTest, reporter) { | 966 DEF_TEST(MatrixConvolutionSanityTest, reporter) { |
969 SkScalar kernel[1] = { 0 }; | 967 SkScalar kernel[1] = { 0 }; |
970 SkScalar gain = SK_Scalar1, bias = 0; | 968 SkScalar gain = SK_Scalar1, bias = 0; |
971 SkIPoint kernelOffset = SkIPoint::Make(1, 1); | 969 SkIPoint kernelOffset = SkIPoint::Make(1, 1); |
972 | 970 |
973 // Check that an enormous (non-allocatable) kernel gives a NULL filter. | 971 // Check that an enormous (non-allocatable) kernel gives a NULL filter. |
974 SkAutoTUnref<SkImageFilter> conv(SkMatrixConvolutionImageFilter::Create( | 972 SkAutoTUnref<SkImageFilter> conv(SkMatrixConvolutionImageFilter::Create( |
975 SkISize::Make(1<<30, 1<<30), | 973 SkISize::Make(1<<30, 1<<30), |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1012 kernel, | 1010 kernel, |
1013 gain, | 1011 gain, |
1014 bias, | 1012 bias, |
1015 kernelOffset, | 1013 kernelOffset, |
1016 SkMatrixConvolutionImageFilter::kRepeat_TileMode, | 1014 SkMatrixConvolutionImageFilter::kRepeat_TileMode, |
1017 false)); | 1015 false)); |
1018 | 1016 |
1019 REPORTER_ASSERT(reporter, NULL == conv.get()); | 1017 REPORTER_ASSERT(reporter, NULL == conv.get()); |
1020 } | 1018 } |
1021 | 1019 |
1022 static void test_xfermode_cropped_input(SkBaseDevice* device, skiatest::Reporter
* reporter) { | 1020 static void test_xfermode_cropped_input(SkCanvas* canvas, skiatest::Reporter* re
porter) { |
1023 SkCanvas canvas(device); | 1021 canvas->clear(0); |
1024 canvas.clear(0); | |
1025 | 1022 |
1026 SkBitmap bitmap; | 1023 SkBitmap bitmap; |
1027 bitmap.allocN32Pixels(1, 1); | 1024 bitmap.allocN32Pixels(1, 1); |
1028 bitmap.eraseARGB(255, 255, 255, 255); | 1025 bitmap.eraseARGB(255, 255, 255, 255); |
1029 | 1026 |
1030 SkAutoTUnref<SkColorFilter> green( | 1027 SkAutoTUnref<SkColorFilter> green( |
1031 SkColorFilter::CreateModeFilter(SK_ColorGREEN, SkXfermode::kSrcIn_Mode))
; | 1028 SkColorFilter::CreateModeFilter(SK_ColorGREEN, SkXfermode::kSrcIn_Mode))
; |
1032 SkAutoTUnref<SkColorFilterImageFilter> greenFilter( | 1029 SkAutoTUnref<SkColorFilterImageFilter> greenFilter( |
1033 SkColorFilterImageFilter::Create(green.get())); | 1030 SkColorFilterImageFilter::Create(green.get())); |
1034 SkImageFilter::CropRect cropRect(SkRect::MakeEmpty()); | 1031 SkImageFilter::CropRect cropRect(SkRect::MakeEmpty()); |
1035 SkAutoTUnref<SkColorFilterImageFilter> croppedOut( | 1032 SkAutoTUnref<SkColorFilterImageFilter> croppedOut( |
1036 SkColorFilterImageFilter::Create(green.get(), NULL, &cropRect)); | 1033 SkColorFilterImageFilter::Create(green.get(), NULL, &cropRect)); |
1037 | 1034 |
1038 // Check that an xfermode image filter whose input has been cropped out stil
l draws the other | 1035 // Check that an xfermode image filter whose input has been cropped out stil
l draws the other |
1039 // input. Also check that drawing with both inputs cropped out doesn't cause
a GPU warning. | 1036 // input. Also check that drawing with both inputs cropped out doesn't cause
a GPU warning. |
1040 SkXfermode* mode = SkXfermode::Create(SkXfermode::kSrcOver_Mode); | 1037 SkXfermode* mode = SkXfermode::Create(SkXfermode::kSrcOver_Mode); |
1041 SkAutoTUnref<SkImageFilter> xfermodeNoFg( | 1038 SkAutoTUnref<SkImageFilter> xfermodeNoFg( |
1042 SkXfermodeImageFilter::Create(mode, greenFilter, croppedOut)); | 1039 SkXfermodeImageFilter::Create(mode, greenFilter, croppedOut)); |
1043 SkAutoTUnref<SkImageFilter> xfermodeNoBg( | 1040 SkAutoTUnref<SkImageFilter> xfermodeNoBg( |
1044 SkXfermodeImageFilter::Create(mode, croppedOut, greenFilter)); | 1041 SkXfermodeImageFilter::Create(mode, croppedOut, greenFilter)); |
1045 SkAutoTUnref<SkImageFilter> xfermodeNoFgNoBg( | 1042 SkAutoTUnref<SkImageFilter> xfermodeNoFgNoBg( |
1046 SkXfermodeImageFilter::Create(mode, croppedOut, croppedOut)); | 1043 SkXfermodeImageFilter::Create(mode, croppedOut, croppedOut)); |
1047 | 1044 |
1048 SkPaint paint; | 1045 SkPaint paint; |
1049 paint.setImageFilter(xfermodeNoFg); | 1046 paint.setImageFilter(xfermodeNoFg); |
1050 canvas.drawSprite(bitmap, 0, 0, &paint); | 1047 canvas->drawSprite(bitmap, 0, 0, &paint); |
1051 | 1048 |
1052 uint32_t pixel; | 1049 uint32_t pixel; |
1053 SkImageInfo info = SkImageInfo::Make(1, 1, kBGRA_8888_SkColorType, kUnpremul
_SkAlphaType); | 1050 SkImageInfo info = SkImageInfo::Make(1, 1, kBGRA_8888_SkColorType, kUnpremul
_SkAlphaType); |
1054 canvas.readPixels(info, &pixel, 4, 0, 0); | 1051 canvas->readPixels(info, &pixel, 4, 0, 0); |
1055 REPORTER_ASSERT(reporter, pixel == SK_ColorGREEN); | 1052 REPORTER_ASSERT(reporter, pixel == SK_ColorGREEN); |
1056 | 1053 |
1057 paint.setImageFilter(xfermodeNoBg); | 1054 paint.setImageFilter(xfermodeNoBg); |
1058 canvas.drawSprite(bitmap, 0, 0, &paint); | 1055 canvas->drawSprite(bitmap, 0, 0, &paint); |
1059 canvas.readPixels(info, &pixel, 4, 0, 0); | 1056 canvas->readPixels(info, &pixel, 4, 0, 0); |
1060 REPORTER_ASSERT(reporter, pixel == SK_ColorGREEN); | 1057 REPORTER_ASSERT(reporter, pixel == SK_ColorGREEN); |
1061 | 1058 |
1062 paint.setImageFilter(xfermodeNoFgNoBg); | 1059 paint.setImageFilter(xfermodeNoFgNoBg); |
1063 canvas.drawSprite(bitmap, 0, 0, &paint); | 1060 canvas->drawSprite(bitmap, 0, 0, &paint); |
1064 canvas.readPixels(info, &pixel, 4, 0, 0); | 1061 canvas->readPixels(info, &pixel, 4, 0, 0); |
1065 REPORTER_ASSERT(reporter, pixel == SK_ColorGREEN); | 1062 REPORTER_ASSERT(reporter, pixel == SK_ColorGREEN); |
1066 } | 1063 } |
1067 | 1064 |
1068 DEF_TEST(ImageFilterNestedSaveLayer, reporter) { | 1065 DEF_TEST(ImageFilterNestedSaveLayer, reporter) { |
1069 SkBitmap temp; | 1066 SkBitmap temp; |
1070 temp.allocN32Pixels(50, 50); | 1067 temp.allocN32Pixels(50, 50); |
1071 SkBitmapDevice device(temp); | 1068 SkCanvas canvas(temp); |
1072 SkCanvas canvas(&device); | |
1073 canvas.clear(0x0); | 1069 canvas.clear(0x0); |
1074 | 1070 |
1075 SkBitmap bitmap; | 1071 SkBitmap bitmap; |
1076 bitmap.allocN32Pixels(10, 10); | 1072 bitmap.allocN32Pixels(10, 10); |
1077 bitmap.eraseColor(SK_ColorGREEN); | 1073 bitmap.eraseColor(SK_ColorGREEN); |
1078 | 1074 |
1079 SkMatrix matrix; | 1075 SkMatrix matrix; |
1080 matrix.setScale(SkIntToScalar(2), SkIntToScalar(2)); | 1076 matrix.setScale(SkIntToScalar(2), SkIntToScalar(2)); |
1081 matrix.postTranslate(SkIntToScalar(-20), SkIntToScalar(-20)); | 1077 matrix.postTranslate(SkIntToScalar(-20), SkIntToScalar(-20)); |
1082 SkAutoTUnref<SkImageFilter> matrixFilter( | 1078 SkAutoTUnref<SkImageFilter> matrixFilter( |
(...skipping 29 matching lines...) Expand all Loading... |
1112 canvas.drawSprite(bitmap, 20, 20, &filterPaint); | 1108 canvas.drawSprite(bitmap, 20, 20, &filterPaint); |
1113 canvas.restore(); | 1109 canvas.restore(); |
1114 | 1110 |
1115 canvas.readPixels(info, &pixel, 4, 25, 25); | 1111 canvas.readPixels(info, &pixel, 4, 25, 25); |
1116 REPORTER_ASSERT(reporter, pixel == SK_ColorGREEN); | 1112 REPORTER_ASSERT(reporter, pixel == SK_ColorGREEN); |
1117 } | 1113 } |
1118 | 1114 |
1119 DEF_TEST(XfermodeImageFilterCroppedInput, reporter) { | 1115 DEF_TEST(XfermodeImageFilterCroppedInput, reporter) { |
1120 SkBitmap temp; | 1116 SkBitmap temp; |
1121 temp.allocN32Pixels(100, 100); | 1117 temp.allocN32Pixels(100, 100); |
1122 SkBitmapDevice device(temp); | 1118 SkCanvas canvas(temp); |
1123 test_xfermode_cropped_input(&device, reporter); | 1119 test_xfermode_cropped_input(&canvas, reporter); |
1124 } | 1120 } |
1125 | 1121 |
1126 DEF_TEST(ComposedImageFilterOffset, reporter) { | 1122 DEF_TEST(ComposedImageFilterOffset, reporter) { |
1127 SkBitmap bitmap; | 1123 SkBitmap bitmap; |
1128 bitmap.allocN32Pixels(100, 100); | 1124 bitmap.allocN32Pixels(100, 100); |
1129 bitmap.eraseARGB(0, 0, 0, 0); | 1125 bitmap.eraseARGB(0, 0, 0, 0); |
1130 SkBitmapDevice device(bitmap); | 1126 SkBitmapDevice device(bitmap, SkSurfaceProps(SkSurfaceProps::kLegacyFontHost
_InitType)); |
1131 SkImageFilter::Proxy proxy(&device, SkSurfaceProps(SkSurfaceProps::kLegacyFo
ntHost_InitType)); | 1127 SkImageFilter::Proxy proxy(&device, SkSurfaceProps(SkSurfaceProps::kLegacyFo
ntHost_InitType)); |
1132 | 1128 |
1133 SkImageFilter::CropRect cropRect(SkRect::MakeXYWH(1, 0, 20, 20)); | 1129 SkImageFilter::CropRect cropRect(SkRect::MakeXYWH(1, 0, 20, 20)); |
1134 SkAutoTUnref<SkImageFilter> offsetFilter(SkOffsetImageFilter::Create(0, 0, N
ULL, &cropRect)); | 1130 SkAutoTUnref<SkImageFilter> offsetFilter(SkOffsetImageFilter::Create(0, 0, N
ULL, &cropRect)); |
1135 SkAutoTUnref<SkImageFilter> blurFilter(makeBlur()); | 1131 SkAutoTUnref<SkImageFilter> blurFilter(makeBlur()); |
1136 SkAutoTUnref<SkImageFilter> composedFilter(SkComposeImageFilter::Create(blur
Filter, offsetFilter.get())); | 1132 SkAutoTUnref<SkImageFilter> composedFilter(SkComposeImageFilter::Create(blur
Filter, offsetFilter.get())); |
1137 SkBitmap result; | 1133 SkBitmap result; |
1138 SkIPoint offset; | 1134 SkIPoint offset; |
1139 SkImageFilter::Context ctx(SkMatrix::I(), SkIRect::MakeLargest(), NULL); | 1135 SkImageFilter::Context ctx(SkMatrix::I(), SkIRect::MakeLargest(), NULL); |
1140 REPORTER_ASSERT(reporter, composedFilter->filterImage(&proxy, bitmap, ctx, &
result, &offset)); | 1136 REPORTER_ASSERT(reporter, composedFilter->filterImage(&proxy, bitmap, ctx, &
result, &offset)); |
1141 REPORTER_ASSERT(reporter, offset.fX == 1 && offset.fY == 0); | 1137 REPORTER_ASSERT(reporter, offset.fX == 1 && offset.fY == 0); |
1142 } | 1138 } |
1143 | 1139 |
1144 #if SK_SUPPORT_GPU | 1140 #if SK_SUPPORT_GPU |
1145 const SkSurfaceProps gProps = SkSurfaceProps(SkSurfaceProps::kLegacyFontHost_Ini
tType); | 1141 const SkSurfaceProps gProps = SkSurfaceProps(SkSurfaceProps::kLegacyFontHost_Ini
tType); |
1146 | 1142 |
1147 DEF_GPUTEST(ImageFilterCropRectGPU, reporter, factory) { | 1143 DEF_GPUTEST(ImageFilterCropRectGPU, reporter, factory) { |
1148 GrContext* context = factory->get(static_cast<GrContextFactory::GLContextTyp
e>(0)); | 1144 GrContext* context = factory->get(static_cast<GrContextFactory::GLContextTyp
e>(0)); |
1149 if (NULL == context) { | 1145 if (NULL == context) { |
1150 return; | 1146 return; |
1151 } | 1147 } |
1152 SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(context, | 1148 SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(context, |
1153 SkSurface::kNo_Budgeted
, | 1149 SkSurface::kNo_Budgeted
, |
1154 SkImageInfo::MakeN32Pre
mul(100, 100), | 1150 SkImageInfo::MakeN32Pre
mul(100, 100), |
1155 0, | 1151 0, |
1156 &gProps)); | 1152 &gProps)); |
1157 test_crop_rects(device, reporter); | 1153 SkImageFilter::Proxy proxy(device, gProps); |
| 1154 |
| 1155 test_crop_rects(&proxy, reporter); |
1158 } | 1156 } |
1159 | 1157 |
1160 DEF_GPUTEST(HugeBlurImageFilterGPU, reporter, factory) { | 1158 DEF_GPUTEST(HugeBlurImageFilterGPU, reporter, factory) { |
1161 GrContext* context = factory->get(static_cast<GrContextFactory::GLContextTyp
e>(0)); | 1159 GrContext* context = factory->get(static_cast<GrContextFactory::GLContextTyp
e>(0)); |
1162 if (NULL == context) { | 1160 if (NULL == context) { |
1163 return; | 1161 return; |
1164 } | 1162 } |
1165 SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(context, | 1163 SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(context, |
1166 SkSurface::kNo_Budgeted
, | 1164 SkSurface::kNo_Budgeted
, |
1167 SkImageInfo::MakeN32Pre
mul(100, 100), | 1165 SkImageInfo::MakeN32Pre
mul(100, 100), |
1168 0, | 1166 0, |
1169 &gProps)); | 1167 &gProps)); |
1170 test_huge_blur(device, reporter); | 1168 SkCanvas canvas(device); |
| 1169 |
| 1170 test_huge_blur(&canvas, reporter); |
1171 } | 1171 } |
1172 | 1172 |
1173 DEF_GPUTEST(XfermodeImageFilterCroppedInputGPU, reporter, factory) { | 1173 DEF_GPUTEST(XfermodeImageFilterCroppedInputGPU, reporter, factory) { |
1174 GrContext* context = factory->get(static_cast<GrContextFactory::GLContextTyp
e>(0)); | 1174 GrContext* context = factory->get(static_cast<GrContextFactory::GLContextTyp
e>(0)); |
1175 if (NULL == context) { | 1175 if (NULL == context) { |
1176 return; | 1176 return; |
1177 } | 1177 } |
1178 SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(context, | 1178 SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(context, |
1179 SkSurface::kNo_Budgeted
, | 1179 SkSurface::kNo_Budgeted
, |
1180 SkImageInfo::MakeN32Pre
mul(1, 1), | 1180 SkImageInfo::MakeN32Pre
mul(1, 1), |
1181 0, | 1181 0, |
1182 &gProps)); | 1182 &gProps)); |
1183 test_xfermode_cropped_input(device, reporter); | 1183 SkCanvas canvas(device); |
| 1184 |
| 1185 test_xfermode_cropped_input(&canvas, reporter); |
1184 } | 1186 } |
1185 | 1187 |
1186 DEF_GPUTEST(TestNegativeBlurSigmaGPU, reporter, factory) { | 1188 DEF_GPUTEST(TestNegativeBlurSigmaGPU, reporter, factory) { |
1187 GrContext* context = factory->get(static_cast<GrContextFactory::GLContextTyp
e>(0)); | 1189 GrContext* context = factory->get(static_cast<GrContextFactory::GLContextTyp
e>(0)); |
1188 if (NULL == context) { | 1190 if (NULL == context) { |
1189 return; | 1191 return; |
1190 } | 1192 } |
1191 SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(context, | 1193 SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(context, |
1192 SkSurface::kNo_Budgeted
, | 1194 SkSurface::kNo_Budgeted
, |
1193 SkImageInfo::MakeN32Pre
mul(1, 1), | 1195 SkImageInfo::MakeN32Pre
mul(1, 1), |
1194 0, | 1196 0, |
1195 &gProps)); | 1197 &gProps)); |
1196 test_negative_blur_sigma(device, reporter); | 1198 SkImageFilter::Proxy proxy(device, gProps); |
| 1199 |
| 1200 test_negative_blur_sigma(&proxy, reporter); |
1197 } | 1201 } |
1198 #endif | 1202 #endif |
OLD | NEW |