OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2012 The Android Open Source Project | 2 * Copyright 2012 The Android Open Source Project |
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 "SkMatrixConvolutionImageFilter.h" | 8 #include "SkMatrixConvolutionImageFilter.h" |
9 #include "SkBitmap.h" | 9 #include "SkBitmap.h" |
10 #include "SkColorPriv.h" | 10 #include "SkColorPriv.h" |
11 #include "SkReadBuffer.h" | 11 #include "SkReadBuffer.h" |
12 #include "SkWriteBuffer.h" | 12 #include "SkWriteBuffer.h" |
13 #include "SkRect.h" | 13 #include "SkRect.h" |
14 #include "SkUnPreMultiply.h" | 14 #include "SkUnPreMultiply.h" |
15 | 15 |
16 #if SK_SUPPORT_GPU | 16 #if SK_SUPPORT_GPU |
17 #include "effects/GrMatrixConvolutionEffect.h" | 17 #include "effects/GrMatrixConvolutionEffect.h" |
18 #endif | 18 #endif |
19 | 19 |
| 20 // We need to be able to read at most SK_MaxS32 bytes, so divide that |
| 21 // by the size of a scalar to know how many scalars we can read. |
| 22 static const int32_t gMaxKernelSize = SK_MaxS32 / sizeof(SkScalar); |
| 23 |
20 SkMatrixConvolutionImageFilter::SkMatrixConvolutionImageFilter( | 24 SkMatrixConvolutionImageFilter::SkMatrixConvolutionImageFilter( |
21 const SkISize& kernelSize, | 25 const SkISize& kernelSize, |
22 const SkScalar* kernel, | 26 const SkScalar* kernel, |
23 SkScalar gain, | 27 SkScalar gain, |
24 SkScalar bias, | 28 SkScalar bias, |
25 const SkIPoint& kernelOffset, | 29 const SkIPoint& kernelOffset, |
26 TileMode tileMode, | 30 TileMode tileMode, |
27 bool convolveAlpha, | 31 bool convolveAlpha, |
28 SkImageFilter* input, | 32 SkImageFilter* input, |
29 const CropRect* cropRect, | 33 const CropRect* cropRect, |
30 uint32_t uniqueID) | 34 uint32_t uniqueID) |
31 : INHERITED(1, &input, cropRect, uniqueID), | 35 : INHERITED(1, &input, cropRect, uniqueID), |
32 fKernelSize(kernelSize), | 36 fKernelSize(kernelSize), |
33 fGain(gain), | 37 fGain(gain), |
34 fBias(bias), | 38 fBias(bias), |
35 fKernelOffset(kernelOffset), | 39 fKernelOffset(kernelOffset), |
36 fTileMode(tileMode), | 40 fTileMode(tileMode), |
37 fConvolveAlpha(convolveAlpha) { | 41 fConvolveAlpha(convolveAlpha) { |
38 uint32_t size = fKernelSize.fWidth * fKernelSize.fHeight; | 42 size_t size = (size_t) sk_64_mul(fKernelSize.width(), fKernelSize.height()); |
39 fKernel = SkNEW_ARRAY(SkScalar, size); | 43 fKernel = SkNEW_ARRAY(SkScalar, size); |
40 memcpy(fKernel, kernel, size * sizeof(SkScalar)); | 44 memcpy(fKernel, kernel, size * sizeof(SkScalar)); |
41 SkASSERT(kernelSize.fWidth >= 1 && kernelSize.fHeight >= 1); | 45 SkASSERT(kernelSize.fWidth >= 1 && kernelSize.fHeight >= 1); |
42 SkASSERT(kernelOffset.fX >= 0 && kernelOffset.fX < kernelSize.fWidth); | 46 SkASSERT(kernelOffset.fX >= 0 && kernelOffset.fX < kernelSize.fWidth); |
43 SkASSERT(kernelOffset.fY >= 0 && kernelOffset.fY < kernelSize.fHeight); | 47 SkASSERT(kernelOffset.fY >= 0 && kernelOffset.fY < kernelSize.fHeight); |
44 } | 48 } |
45 | 49 |
| 50 SkMatrixConvolutionImageFilter* SkMatrixConvolutionImageFilter::Create( |
| 51 const SkISize& kernelSize, |
| 52 const SkScalar* kernel, |
| 53 SkScalar gain, |
| 54 SkScalar bias, |
| 55 const SkIPoint& kernelOffset, |
| 56 TileMode tileMode, |
| 57 bool convolveAlpha, |
| 58 SkImageFilter* input, |
| 59 const CropRect* cropRect, |
| 60 uint32_t uniqueID) { |
| 61 if (kernelSize.width() < 1 || kernelSize.height() < 1) { |
| 62 return NULL; |
| 63 } |
| 64 if (gMaxKernelSize / kernelSize.fWidth < kernelSize.fHeight) { |
| 65 return NULL; |
| 66 } |
| 67 if (!kernel) { |
| 68 return NULL; |
| 69 } |
| 70 return SkNEW_ARGS(SkMatrixConvolutionImageFilter, (kernelSize, kernel, gain,
bias, |
| 71 kernelOffset, tileMode, c
onvolveAlpha, |
| 72 input, cropRect, uniqueID
)); |
| 73 } |
| 74 |
46 #ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING | 75 #ifdef SK_SUPPORT_LEGACY_DEEPFLATTENING |
47 static bool tile_mode_is_valid(SkMatrixConvolutionImageFilter::TileMode tileMode
) { | 76 static bool tile_mode_is_valid(SkMatrixConvolutionImageFilter::TileMode tileMode
) { |
48 switch (tileMode) { | 77 switch (tileMode) { |
49 case SkMatrixConvolutionImageFilter::kClamp_TileMode: | 78 case SkMatrixConvolutionImageFilter::kClamp_TileMode: |
50 case SkMatrixConvolutionImageFilter::kRepeat_TileMode: | 79 case SkMatrixConvolutionImageFilter::kRepeat_TileMode: |
51 case SkMatrixConvolutionImageFilter::kClampToBlack_TileMode: | 80 case SkMatrixConvolutionImageFilter::kClampToBlack_TileMode: |
52 return true; | 81 return true; |
53 default: | 82 default: |
54 break; | 83 break; |
55 } | 84 } |
56 return false; | 85 return false; |
57 } | 86 } |
58 | 87 |
59 SkMatrixConvolutionImageFilter::SkMatrixConvolutionImageFilter(SkReadBuffer& buf
fer) | 88 SkMatrixConvolutionImageFilter::SkMatrixConvolutionImageFilter(SkReadBuffer& buf
fer) |
60 : INHERITED(1, buffer) { | 89 : INHERITED(1, buffer) { |
61 // We need to be able to read at most SK_MaxS32 bytes, so divide that | |
62 // by the size of a scalar to know how many scalars we can read. | |
63 static const int32_t kMaxSize = SK_MaxS32 / sizeof(SkScalar); | |
64 fKernelSize.fWidth = buffer.readInt(); | 90 fKernelSize.fWidth = buffer.readInt(); |
65 fKernelSize.fHeight = buffer.readInt(); | 91 fKernelSize.fHeight = buffer.readInt(); |
66 if ((fKernelSize.fWidth >= 1) && (fKernelSize.fHeight >= 1) && | 92 if ((fKernelSize.fWidth >= 1) && (fKernelSize.fHeight >= 1) && |
67 // Make sure size won't be larger than a signed int, | 93 // Make sure size won't be larger than a signed int, |
68 // which would still be extremely large for a kernel, | 94 // which would still be extremely large for a kernel, |
69 // but we don't impose a hard limit for kernel size | 95 // but we don't impose a hard limit for kernel size |
70 (kMaxSize / fKernelSize.fWidth >= fKernelSize.fHeight)) { | 96 (gMaxKernelSize / fKernelSize.fWidth >= fKernelSize.fHeight)) { |
71 size_t size = fKernelSize.fWidth * fKernelSize.fHeight; | 97 size_t size = fKernelSize.fWidth * fKernelSize.fHeight; |
72 fKernel = SkNEW_ARRAY(SkScalar, size); | 98 fKernel = SkNEW_ARRAY(SkScalar, size); |
73 SkDEBUGCODE(bool success =) buffer.readScalarArray(fKernel, size); | 99 SkDEBUGCODE(bool success =) buffer.readScalarArray(fKernel, size); |
74 SkASSERT(success); | 100 SkASSERT(success); |
75 } else { | 101 } else { |
76 fKernel = 0; | 102 fKernel = 0; |
77 } | 103 } |
78 fGain = buffer.readScalar(); | 104 fGain = buffer.readScalar(); |
79 fBias = buffer.readScalar(); | 105 fBias = buffer.readScalar(); |
80 fKernelOffset.fX = buffer.readInt(); | 106 fKernelOffset.fX = buffer.readInt(); |
(...skipping 295 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
376 fKernelSize, | 402 fKernelSize, |
377 fKernel, | 403 fKernel, |
378 fGain, | 404 fGain, |
379 fBias, | 405 fBias, |
380 fKernelOffset, | 406 fKernelOffset, |
381 convert_tilemodes(fTileMode), | 407 convert_tilemodes(fTileMode), |
382 fConvolveAlpha); | 408 fConvolveAlpha); |
383 return true; | 409 return true; |
384 } | 410 } |
385 #endif | 411 #endif |
OLD | NEW |