OLD | NEW |
1 /* | 1 /* |
2 * Copyright 2011 The Android Open Source Project | 2 * Copyright 2011 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 "SkBitmap.h" | 8 #include "SkBitmap.h" |
9 #include "SkBlurImageFilter.h" | 9 #include "SkBlurImageFilter.h" |
10 #include "SkColorPriv.h" | 10 #include "SkColorPriv.h" |
11 #include "SkFlattenableBuffers.h" | 11 #include "SkFlattenableBuffers.h" |
12 #include "SkGpuBlurUtils.h" | 12 #include "SkGpuBlurUtils.h" |
13 #if SK_SUPPORT_GPU | 13 #if SK_SUPPORT_GPU |
14 #include "GrContext.h" | 14 #include "GrContext.h" |
15 #include "SkImageFilterUtils.h" | 15 #include "SkImageFilterUtils.h" |
16 #endif | 16 #endif |
17 | 17 |
18 SkBlurImageFilter::SkBlurImageFilter(SkFlattenableReadBuffer& buffer) | 18 SkBlurImageFilter::SkBlurImageFilter(SkFlattenableReadBuffer& buffer) |
19 : INHERITED(buffer) { | 19 : INHERITED(buffer) { |
20 fSigma.fWidth = buffer.readScalar(); | 20 fSigma.fWidth = buffer.readScalar(); |
21 fSigma.fHeight = buffer.readScalar(); | 21 fSigma.fHeight = buffer.readScalar(); |
22 } | 22 } |
23 | 23 |
24 SkBlurImageFilter::SkBlurImageFilter(SkScalar sigmaX, SkScalar sigmaY, SkImageFi
lter* input) | 24 SkBlurImageFilter::SkBlurImageFilter(SkScalar sigmaX, |
25 : INHERITED(input), fSigma(SkSize::Make(sigmaX, sigmaY)) { | 25 SkScalar sigmaY, |
| 26 SkImageFilter* input, |
| 27 const SkIRect* cropRect) |
| 28 : INHERITED(input, cropRect), fSigma(SkSize::Make(sigmaX, sigmaY)) { |
26 SkASSERT(sigmaX >= 0 && sigmaY >= 0); | 29 SkASSERT(sigmaX >= 0 && sigmaY >= 0); |
27 } | 30 } |
28 | 31 |
29 void SkBlurImageFilter::flatten(SkFlattenableWriteBuffer& buffer) const { | 32 void SkBlurImageFilter::flatten(SkFlattenableWriteBuffer& buffer) const { |
30 this->INHERITED::flatten(buffer); | 33 this->INHERITED::flatten(buffer); |
31 buffer.writeScalar(fSigma.fWidth); | 34 buffer.writeScalar(fSigma.fWidth); |
32 buffer.writeScalar(fSigma.fHeight); | 35 buffer.writeScalar(fSigma.fHeight); |
33 } | 36 } |
34 | 37 |
35 static void boxBlurX(const SkBitmap& src, SkBitmap* dst, int kernelSize, | 38 static void boxBlurX(const SkBitmap& src, SkBitmap* dst, int kernelSize, |
36 int leftOffset, int rightOffset) | 39 int leftOffset, int rightOffset, const SkIRect& bounds) |
37 { | 40 { |
38 int width = src.width(), height = src.height(); | 41 int width = bounds.width(), height = bounds.height(); |
39 int rightBorder = SkMin32(rightOffset + 1, width); | 42 int rightBorder = SkMin32(rightOffset + 1, width); |
40 for (int y = 0; y < height; ++y) { | 43 for (int y = 0; y < height; ++y) { |
41 int sumA = 0, sumR = 0, sumG = 0, sumB = 0; | 44 int sumA = 0, sumR = 0, sumG = 0, sumB = 0; |
42 SkPMColor* p = src.getAddr32(0, y); | 45 SkPMColor* p = src.getAddr32(bounds.fLeft, y + bounds.fTop); |
43 for (int i = 0; i < rightBorder; ++i) { | 46 for (int i = 0; i < rightBorder; ++i) { |
44 sumA += SkGetPackedA32(*p); | 47 sumA += SkGetPackedA32(*p); |
45 sumR += SkGetPackedR32(*p); | 48 sumR += SkGetPackedR32(*p); |
46 sumG += SkGetPackedG32(*p); | 49 sumG += SkGetPackedG32(*p); |
47 sumB += SkGetPackedB32(*p); | 50 sumB += SkGetPackedB32(*p); |
48 p++; | 51 p++; |
49 } | 52 } |
50 | 53 |
51 const SkColor* sptr = src.getAddr32(0, y); | 54 const SkColor* sptr = src.getAddr32(bounds.fLeft, bounds.fTop + y); |
52 SkColor* dptr = dst->getAddr32(0, y); | 55 SkColor* dptr = dst->getAddr32(0, y); |
53 for (int x = 0; x < width; ++x) { | 56 for (int x = 0; x < width; ++x) { |
54 *dptr = SkPackARGB32(sumA / kernelSize, | 57 *dptr = SkPackARGB32(sumA / kernelSize, |
55 sumR / kernelSize, | 58 sumR / kernelSize, |
56 sumG / kernelSize, | 59 sumG / kernelSize, |
57 sumB / kernelSize); | 60 sumB / kernelSize); |
58 if (x >= leftOffset) { | 61 if (x >= leftOffset) { |
59 SkColor l = *(sptr - leftOffset); | 62 SkColor l = *(sptr - leftOffset); |
60 sumA -= SkGetPackedA32(l); | 63 sumA -= SkGetPackedA32(l); |
61 sumR -= SkGetPackedR32(l); | 64 sumR -= SkGetPackedR32(l); |
62 sumG -= SkGetPackedG32(l); | 65 sumG -= SkGetPackedG32(l); |
63 sumB -= SkGetPackedB32(l); | 66 sumB -= SkGetPackedB32(l); |
64 } | 67 } |
65 if (x + rightOffset + 1 < width) { | 68 if (x + rightOffset + 1 < width) { |
66 SkColor r = *(sptr + rightOffset + 1); | 69 SkColor r = *(sptr + rightOffset + 1); |
67 sumA += SkGetPackedA32(r); | 70 sumA += SkGetPackedA32(r); |
68 sumR += SkGetPackedR32(r); | 71 sumR += SkGetPackedR32(r); |
69 sumG += SkGetPackedG32(r); | 72 sumG += SkGetPackedG32(r); |
70 sumB += SkGetPackedB32(r); | 73 sumB += SkGetPackedB32(r); |
71 } | 74 } |
72 sptr++; | 75 sptr++; |
73 dptr++; | 76 dptr++; |
74 } | 77 } |
75 } | 78 } |
76 } | 79 } |
77 | 80 |
78 static void boxBlurY(const SkBitmap& src, SkBitmap* dst, int kernelSize, | 81 static void boxBlurY(const SkBitmap& src, SkBitmap* dst, int kernelSize, |
79 int topOffset, int bottomOffset) | 82 int topOffset, int bottomOffset, const SkIRect& bounds) |
80 { | 83 { |
81 int width = src.width(), height = src.height(); | 84 int width = bounds.width(), height = bounds.height(); |
82 int bottomBorder = SkMin32(bottomOffset + 1, height); | 85 int bottomBorder = SkMin32(bottomOffset + 1, height); |
83 int srcStride = src.rowBytesAsPixels(); | 86 int srcStride = src.rowBytesAsPixels(); |
84 int dstStride = dst->rowBytesAsPixels(); | 87 int dstStride = dst->rowBytesAsPixels(); |
85 for (int x = 0; x < width; ++x) { | 88 for (int x = 0; x < width; ++x) { |
86 int sumA = 0, sumR = 0, sumG = 0, sumB = 0; | 89 int sumA = 0, sumR = 0, sumG = 0, sumB = 0; |
87 SkColor* p = src.getAddr32(x, 0); | 90 SkColor* p = src.getAddr32(bounds.fLeft + x, bounds.fTop); |
88 for (int i = 0; i < bottomBorder; ++i) { | 91 for (int i = 0; i < bottomBorder; ++i) { |
89 sumA += SkGetPackedA32(*p); | 92 sumA += SkGetPackedA32(*p); |
90 sumR += SkGetPackedR32(*p); | 93 sumR += SkGetPackedR32(*p); |
91 sumG += SkGetPackedG32(*p); | 94 sumG += SkGetPackedG32(*p); |
92 sumB += SkGetPackedB32(*p); | 95 sumB += SkGetPackedB32(*p); |
93 p += srcStride; | 96 p += srcStride; |
94 } | 97 } |
95 | 98 |
96 const SkColor* sptr = src.getAddr32(x, 0); | 99 const SkColor* sptr = src.getAddr32(bounds.fLeft + x, bounds.fTop); |
97 SkColor* dptr = dst->getAddr32(x, 0); | 100 SkColor* dptr = dst->getAddr32(x, 0); |
98 for (int y = 0; y < height; ++y) { | 101 for (int y = 0; y < height; ++y) { |
99 *dptr = SkPackARGB32(sumA / kernelSize, | 102 *dptr = SkPackARGB32(sumA / kernelSize, |
100 sumR / kernelSize, | 103 sumR / kernelSize, |
101 sumG / kernelSize, | 104 sumG / kernelSize, |
102 sumB / kernelSize); | 105 sumB / kernelSize); |
103 if (y >= topOffset) { | 106 if (y >= topOffset) { |
104 SkColor l = *(sptr - topOffset * srcStride); | 107 SkColor l = *(sptr - topOffset * srcStride); |
105 sumA -= SkGetPackedA32(l); | 108 sumA -= SkGetPackedA32(l); |
106 sumR -= SkGetPackedR32(l); | 109 sumR -= SkGetPackedR32(l); |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
146 | 149 |
147 if (src.config() != SkBitmap::kARGB_8888_Config) { | 150 if (src.config() != SkBitmap::kARGB_8888_Config) { |
148 return false; | 151 return false; |
149 } | 152 } |
150 | 153 |
151 SkAutoLockPixels alp(src); | 154 SkAutoLockPixels alp(src); |
152 if (!src.getPixels()) { | 155 if (!src.getPixels()) { |
153 return false; | 156 return false; |
154 } | 157 } |
155 | 158 |
156 dst->setConfig(src.config(), src.width(), src.height()); | 159 SkIRect srcBounds, dstBounds; |
| 160 src.getBounds(&srcBounds); |
| 161 if (!this->applyCropRect(&srcBounds)) { |
| 162 return false; |
| 163 } |
| 164 |
| 165 dst->setConfig(src.config(), srcBounds.width(), srcBounds.height()); |
| 166 dst->getBounds(&dstBounds); |
157 dst->allocPixels(); | 167 dst->allocPixels(); |
158 int kernelSizeX, kernelSizeX3, lowOffsetX, highOffsetX; | 168 int kernelSizeX, kernelSizeX3, lowOffsetX, highOffsetX; |
159 int kernelSizeY, kernelSizeY3, lowOffsetY, highOffsetY; | 169 int kernelSizeY, kernelSizeY3, lowOffsetY, highOffsetY; |
160 getBox3Params(fSigma.width(), &kernelSizeX, &kernelSizeX3, &lowOffsetX, &hig
hOffsetX); | 170 getBox3Params(fSigma.width(), &kernelSizeX, &kernelSizeX3, &lowOffsetX, &hig
hOffsetX); |
161 getBox3Params(fSigma.height(), &kernelSizeY, &kernelSizeY3, &lowOffsetY, &hi
ghOffsetY); | 171 getBox3Params(fSigma.height(), &kernelSizeY, &kernelSizeY3, &lowOffsetY, &hi
ghOffsetY); |
162 | 172 |
163 if (kernelSizeX < 0 || kernelSizeY < 0) { | 173 if (kernelSizeX < 0 || kernelSizeY < 0) { |
164 return false; | 174 return false; |
165 } | 175 } |
166 | 176 |
167 if (kernelSizeX == 0 && kernelSizeY == 0) { | 177 if (kernelSizeX == 0 && kernelSizeY == 0) { |
168 src.copyTo(dst, dst->config()); | 178 src.copyTo(dst, dst->config()); |
169 return true; | 179 return true; |
170 } | 180 } |
171 | 181 |
172 SkBitmap temp; | 182 SkBitmap temp; |
173 temp.setConfig(dst->config(), dst->width(), dst->height()); | 183 temp.setConfig(dst->config(), dst->width(), dst->height()); |
174 if (!temp.allocPixels()) { | 184 if (!temp.allocPixels()) { |
175 return false; | 185 return false; |
176 } | 186 } |
177 | 187 |
178 if (kernelSizeX > 0 && kernelSizeY > 0) { | 188 if (kernelSizeX > 0 && kernelSizeY > 0) { |
179 boxBlurX(src, &temp, kernelSizeX, lowOffsetX, highOffsetX); | 189 boxBlurX(src, &temp, kernelSizeX, lowOffsetX, highOffsetX, srcBounds)
; |
180 boxBlurY(temp, dst, kernelSizeY, lowOffsetY, highOffsetY); | 190 boxBlurY(temp, dst, kernelSizeY, lowOffsetY, highOffsetY, dstBounds)
; |
181 boxBlurX(*dst, &temp, kernelSizeX, highOffsetX, lowOffsetX); | 191 boxBlurX(*dst, &temp, kernelSizeX, highOffsetX, lowOffsetX, dstBounds); |
182 boxBlurY(temp, dst, kernelSizeY, highOffsetY, lowOffsetY); | 192 boxBlurY(temp, dst, kernelSizeY, highOffsetY, lowOffsetY, dstBounds); |
183 boxBlurX(*dst, &temp, kernelSizeX3, highOffsetX, highOffsetX); | 193 boxBlurX(*dst, &temp, kernelSizeX3, highOffsetX, highOffsetX, dstBounds)
; |
184 boxBlurY(temp, dst, kernelSizeY3, highOffsetY, highOffsetY); | 194 boxBlurY(temp, dst, kernelSizeY3, highOffsetY, highOffsetY, dstBounds)
; |
185 } else if (kernelSizeX > 0) { | 195 } else if (kernelSizeX > 0) { |
186 boxBlurX(src, dst, kernelSizeX, lowOffsetX, highOffsetX); | 196 boxBlurX(src, dst, kernelSizeX, lowOffsetX, highOffsetX, srcBounds)
; |
187 boxBlurX(*dst, &temp, kernelSizeX, highOffsetX, lowOffsetX); | 197 boxBlurX(*dst, &temp, kernelSizeX, highOffsetX, lowOffsetX, dstBounds); |
188 boxBlurX(temp, dst, kernelSizeX3, highOffsetX, highOffsetX); | 198 boxBlurX(temp, dst, kernelSizeX3, highOffsetX, highOffsetX, dstBounds)
; |
189 } else if (kernelSizeY > 0) { | 199 } else if (kernelSizeY > 0) { |
190 boxBlurY(src, dst, kernelSizeY, lowOffsetY, highOffsetY); | 200 boxBlurY(src, dst, kernelSizeY, lowOffsetY, highOffsetY, srcBounds)
; |
191 boxBlurY(*dst, &temp, kernelSizeY, highOffsetY, lowOffsetY); | 201 boxBlurY(*dst, &temp, kernelSizeY, highOffsetY, lowOffsetY, dstBounds); |
192 boxBlurY(temp, dst, kernelSizeY3, highOffsetY, highOffsetY); | 202 boxBlurY(temp, dst, kernelSizeY3, highOffsetY, highOffsetY, dstBounds)
; |
193 } | 203 } |
| 204 offset->fX += srcBounds.fLeft; |
| 205 offset->fY += srcBounds.fTop; |
194 return true; | 206 return true; |
195 } | 207 } |
196 | 208 |
197 bool SkBlurImageFilter::filterImageGPU(Proxy* proxy, const SkBitmap& src, SkBitm
ap* result, | 209 bool SkBlurImageFilter::filterImageGPU(Proxy* proxy, const SkBitmap& src, SkBitm
ap* result, |
198 SkIPoint* offset) { | 210 SkIPoint* offset) { |
199 #if SK_SUPPORT_GPU | 211 #if SK_SUPPORT_GPU |
200 SkBitmap input; | 212 SkBitmap input; |
201 if (!SkImageFilterUtils::GetInputResultGPU(getInput(0), proxy, src, &input,
offset)) { | 213 if (!SkImageFilterUtils::GetInputResultGPU(getInput(0), proxy, src, &input,
offset)) { |
202 return false; | 214 return false; |
203 } | 215 } |
204 GrTexture* source = input.getTexture(); | 216 GrTexture* source = input.getTexture(); |
205 SkRect rect; | 217 SkIRect rect; |
206 src.getBounds(&rect); | 218 src.getBounds(&rect); |
| 219 if (!this->applyCropRect(&rect)) { |
| 220 return false; |
| 221 } |
207 SkAutoTUnref<GrTexture> tex(SkGpuBlurUtils::GaussianBlur(source->getContext(
), | 222 SkAutoTUnref<GrTexture> tex(SkGpuBlurUtils::GaussianBlur(source->getContext(
), |
208 source, false, rect
, | 223 source, |
209 fSigma.width(), fSi
gma.height())); | 224 false, |
210 return SkImageFilterUtils::WrapTexture(tex, src.width(), src.height(), resul
t); | 225 SkRect::Make(rect), |
| 226 true, |
| 227 fSigma.width(), |
| 228 fSigma.height())); |
| 229 offset->fX += rect.fLeft; |
| 230 offset->fY += rect.fTop; |
| 231 return SkImageFilterUtils::WrapTexture(tex, rect.width(), rect.height(), res
ult); |
211 #else | 232 #else |
212 SkDEBUGFAIL("Should not call in GPU-less build"); | 233 SkDEBUGFAIL("Should not call in GPU-less build"); |
213 return false; | 234 return false; |
214 #endif | 235 #endif |
215 } | 236 } |
OLD | NEW |