The Tor Browser / file comparison

comparison: gfx/2d/DrawTargetSkia.cpp

gfx/2d/DrawTargetSkia.cpp

branch
TOR_BUG_9701
changeset 8
97036ab72558
equal deleted inserted replaced
-1:000000000000 0:027f54d39a89
1 /* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
2 * This Source Code Form is subject to the terms of the Mozilla Public
3 * License, v. 2.0. If a copy of the MPL was not distributed with this
4 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
5
6 #include "DrawTargetSkia.h"
7 #include "SourceSurfaceSkia.h"
8 #include "ScaledFontBase.h"
9 #include "ScaledFontCairo.h"
10 #include "skia/SkGpuDevice.h"
11 #include "skia/SkBitmapDevice.h"
12 #include "FilterNodeSoftware.h"
13
14 #ifdef USE_SKIA_GPU
15 #include "skia/SkGpuDevice.h"
16 #include "skia/GrGLInterface.h"
17 #endif
18
19 #include "skia/SkTypeface.h"
20 #include "skia/SkGradientShader.h"
21 #include "skia/SkBlurDrawLooper.h"
22 #include "skia/SkBlurMaskFilter.h"
23 #include "skia/SkColorFilter.h"
24 #include "skia/SkDropShadowImageFilter.h"
25 #include "skia/SkLayerRasterizer.h"
26 #include "skia/SkLayerDrawLooper.h"
27 #include "skia/SkDashPathEffect.h"
28 #include "Logging.h"
29 #include "HelpersSkia.h"
30 #include "Tools.h"
31 #include "DataSurfaceHelpers.h"
32 #include <algorithm>
33
34 namespace mozilla {
35 namespace gfx {
36
37 class GradientStopsSkia : public GradientStops
38 {
39 public:
40 MOZ_DECLARE_REFCOUNTED_VIRTUAL_TYPENAME(GradientStopsSkia)
41 GradientStopsSkia(const std::vector<GradientStop>& aStops, uint32_t aNumStops, ExtendMode aExtendMode)
42 : mCount(aNumStops)
43 , mExtendMode(aExtendMode)
44 {
45 if (mCount == 0) {
46 return;
47 }
48
49 // Skia gradients always require a stop at 0.0 and 1.0, insert these if
50 // we don't have them.
51 uint32_t shift = 0;
52 if (aStops[0].offset != 0) {
53 mCount++;
54 shift = 1;
55 }
56 if (aStops[aNumStops-1].offset != 1) {
57 mCount++;
58 }
59 mColors.resize(mCount);
60 mPositions.resize(mCount);
61 if (aStops[0].offset != 0) {
62 mColors[0] = ColorToSkColor(aStops[0].color, 1.0);
63 mPositions[0] = 0;
64 }
65 for (uint32_t i = 0; i < aNumStops; i++) {
66 mColors[i + shift] = ColorToSkColor(aStops[i].color, 1.0);
67 mPositions[i + shift] = SkFloatToScalar(aStops[i].offset);
68 }
69 if (aStops[aNumStops-1].offset != 1) {
70 mColors[mCount-1] = ColorToSkColor(aStops[aNumStops-1].color, 1.0);
71 mPositions[mCount-1] = SK_Scalar1;
72 }
73 }
74
75 BackendType GetBackendType() const { return BackendType::SKIA; }
76
77 std::vector<SkColor> mColors;
78 std::vector<SkScalar> mPositions;
79 int mCount;
80 ExtendMode mExtendMode;
81 };
82
83 /**
84 * When constructing a temporary SkBitmap via GetBitmapForSurface, we may also
85 * have to construct a temporary DataSourceSurface, which must live as long as
86 * the SkBitmap. So we return a pair of the SkBitmap and the (optional)
87 * temporary surface.
88 */
89 struct TempBitmap
90 {
91 SkBitmap mBitmap;
92 RefPtr<SourceSurface> mTmpSurface;
93 };
94
95 static TempBitmap
96 GetBitmapForSurface(SourceSurface* aSurface)
97 {
98 TempBitmap result;
99
100 if (aSurface->GetType() == SurfaceType::SKIA) {
101 result.mBitmap = static_cast<SourceSurfaceSkia*>(aSurface)->GetBitmap();
102 return result;
103 }
104
105 RefPtr<DataSourceSurface> surf = aSurface->GetDataSurface();
106 if (!surf) {
107 MOZ_CRASH("Non-skia SourceSurfaces need to be DataSourceSurfaces");
108 }
109
110 result.mBitmap.setConfig(GfxFormatToSkiaConfig(surf->GetFormat()),
111 surf->GetSize().width, surf->GetSize().height,
112 surf->Stride());
113 result.mBitmap.setPixels(surf->GetData());
114 result.mTmpSurface = surf.forget();
115 return result;
116 }
117
118 DrawTargetSkia::DrawTargetSkia()
119 : mTexture(0), mSnapshot(nullptr)
120 {
121 }
122
123 DrawTargetSkia::~DrawTargetSkia()
124 {
125 }
126
127 TemporaryRef<SourceSurface>
128 DrawTargetSkia::Snapshot()
129 {
130 RefPtr<SourceSurfaceSkia> snapshot = mSnapshot;
131 if (!snapshot) {
132 snapshot = new SourceSurfaceSkia();
133 mSnapshot = snapshot;
134 if (!snapshot->InitFromCanvas(mCanvas.get(), mFormat, this))
135 return nullptr;
136 }
137
138 return snapshot;
139 }
140
141 static void
142 SetPaintPattern(SkPaint& aPaint, const Pattern& aPattern, TempBitmap& aTmpBitmap,
143 Float aAlpha = 1.0)
144 {
145 switch (aPattern.GetType()) {
146 case PatternType::COLOR: {
147 Color color = static_cast<const ColorPattern&>(aPattern).mColor;
148 aPaint.setColor(ColorToSkColor(color, aAlpha));
149 break;
150 }
151 case PatternType::LINEAR_GRADIENT: {
152 const LinearGradientPattern& pat = static_cast<const LinearGradientPattern&>(aPattern);
153 GradientStopsSkia *stops = static_cast<GradientStopsSkia*>(pat.mStops.get());
154 SkShader::TileMode mode = ExtendModeToTileMode(stops->mExtendMode);
155
156 if (stops->mCount >= 2) {
157 SkPoint points[2];
158 points[0] = SkPoint::Make(SkFloatToScalar(pat.mBegin.x), SkFloatToScalar(pat.mBegin.y));
159 points[1] = SkPoint::Make(SkFloatToScalar(pat.mEnd.x), SkFloatToScalar(pat.mEnd.y));
160
161 SkShader* shader = SkGradientShader::CreateLinear(points,
162 &stops->mColors.front(),
163 &stops->mPositions.front(),
164 stops->mCount,
165 mode);
166
167 if (shader) {
168 SkMatrix mat;
169 GfxMatrixToSkiaMatrix(pat.mMatrix, mat);
170 shader->setLocalMatrix(mat);
171 SkSafeUnref(aPaint.setShader(shader));
172 }
173
174 } else {
175 aPaint.setColor(SkColorSetARGB(0, 0, 0, 0));
176 }
177 break;
178 }
179 case PatternType::RADIAL_GRADIENT: {
180 const RadialGradientPattern& pat = static_cast<const RadialGradientPattern&>(aPattern);
181 GradientStopsSkia *stops = static_cast<GradientStopsSkia*>(pat.mStops.get());
182 SkShader::TileMode mode = ExtendModeToTileMode(stops->mExtendMode);
183
184 if (stops->mCount >= 2) {
185 SkPoint points[2];
186 points[0] = SkPoint::Make(SkFloatToScalar(pat.mCenter1.x), SkFloatToScalar(pat.mCenter1.y));
187 points[1] = SkPoint::Make(SkFloatToScalar(pat.mCenter2.x), SkFloatToScalar(pat.mCenter2.y));
188
189 SkShader* shader = SkGradientShader::CreateTwoPointConical(points[0],
190 SkFloatToScalar(pat.mRadius1),
191 points[1],
192 SkFloatToScalar(pat.mRadius2),
193 &stops->mColors.front(),
194 &stops->mPositions.front(),
195 stops->mCount,
196 mode);
197 if (shader) {
198 SkMatrix mat;
199 GfxMatrixToSkiaMatrix(pat.mMatrix, mat);
200 shader->setLocalMatrix(mat);
201 SkSafeUnref(aPaint.setShader(shader));
202 }
203
204 } else {
205 aPaint.setColor(SkColorSetARGB(0, 0, 0, 0));
206 }
207 break;
208 }
209 case PatternType::SURFACE: {
210 const SurfacePattern& pat = static_cast<const SurfacePattern&>(aPattern);
211 aTmpBitmap = GetBitmapForSurface(pat.mSurface);
212 const SkBitmap& bitmap = aTmpBitmap.mBitmap;
213
214 SkShader::TileMode mode = ExtendModeToTileMode(pat.mExtendMode);
215 SkShader* shader = SkShader::CreateBitmapShader(bitmap, mode, mode);
216 SkMatrix mat;
217 GfxMatrixToSkiaMatrix(pat.mMatrix, mat);
218 shader->setLocalMatrix(mat);
219 SkSafeUnref(aPaint.setShader(shader));
220 if (pat.mFilter == Filter::POINT) {
221 aPaint.setFilterLevel(SkPaint::kNone_FilterLevel);
222 }
223 break;
224 }
225 }
226 }
227
228 static inline Rect
229 GetClipBounds(SkCanvas *aCanvas)
230 {
231 SkRect clipBounds;
232 aCanvas->getClipBounds(&clipBounds);
233 return SkRectToRect(clipBounds);
234 }
235
236 struct AutoPaintSetup {
237 AutoPaintSetup(SkCanvas *aCanvas, const DrawOptions& aOptions, const Pattern& aPattern, const Rect* aMaskBounds = nullptr)
238 : mNeedsRestore(false), mAlpha(1.0)
239 {
240 Init(aCanvas, aOptions, aMaskBounds);
241 SetPaintPattern(mPaint, aPattern, mTmpBitmap, mAlpha);
242 }
243
244 AutoPaintSetup(SkCanvas *aCanvas, const DrawOptions& aOptions, const Rect* aMaskBounds = nullptr)
245 : mNeedsRestore(false), mAlpha(1.0)
246 {
247 Init(aCanvas, aOptions, aMaskBounds);
248 }
249
250 ~AutoPaintSetup()
251 {
252 if (mNeedsRestore) {
253 mCanvas->restore();
254 }
255 }
256
257 void Init(SkCanvas *aCanvas, const DrawOptions& aOptions, const Rect* aMaskBounds)
258 {
259 mPaint.setXfermodeMode(GfxOpToSkiaOp(aOptions.mCompositionOp));
260 mCanvas = aCanvas;
261
262 //TODO: Can we set greyscale somehow?
263 if (aOptions.mAntialiasMode != AntialiasMode::NONE) {
264 mPaint.setAntiAlias(true);
265 } else {
266 mPaint.setAntiAlias(false);
267 }
268
269 Rect clipBounds = GetClipBounds(aCanvas);
270 bool needsGroup = !IsOperatorBoundByMask(aOptions.mCompositionOp) &&
271 (!aMaskBounds || !aMaskBounds->Contains(clipBounds));
272
273 // TODO: We could skip the temporary for operator_source and just
274 // clear the clip rect. The other operators would be harder
275 // but could be worth it to skip pushing a group.
276 if (needsGroup) {
277 mPaint.setXfermodeMode(SkXfermode::kSrcOver_Mode);
278 SkPaint temp;
279 temp.setXfermodeMode(GfxOpToSkiaOp(aOptions.mCompositionOp));
280 temp.setAlpha(U8CPU(aOptions.mAlpha*255));
281 //TODO: Get a rect here
282 mCanvas->saveLayer(nullptr, &temp);
283 mNeedsRestore = true;
284 } else {
285 mPaint.setAlpha(U8CPU(aOptions.mAlpha*255.0));
286 mAlpha = aOptions.mAlpha;
287 }
288 mPaint.setFilterLevel(SkPaint::kLow_FilterLevel);
289 }
290
291 // TODO: Maybe add an operator overload to access this easier?
292 SkPaint mPaint;
293 TempBitmap mTmpBitmap;
294 bool mNeedsRestore;
295 SkCanvas* mCanvas;
296 Float mAlpha;
297 };
298
299 void
300 DrawTargetSkia::Flush()
301 {
302 mCanvas->flush();
303 }
304
305 void
306 DrawTargetSkia::DrawSurface(SourceSurface *aSurface,
307 const Rect &aDest,
308 const Rect &aSource,
309 const DrawSurfaceOptions &aSurfOptions,
310 const DrawOptions &aOptions)
311 {
312 RefPtr<SourceSurface> dataSurface;
313
314 if (!(aSurface->GetType() == SurfaceType::SKIA || aSurface->GetType() == SurfaceType::DATA)) {
315 dataSurface = aSurface->GetDataSurface();
316 if (!dataSurface) {
317 gfxDebug() << *this << ": DrawSurface() can't draw surface";
318 return;
319 }
320 aSurface = dataSurface.get();
321 }
322
323 if (aSource.IsEmpty()) {
324 return;
325 }
326
327 MarkChanged();
328
329 SkRect destRect = RectToSkRect(aDest);
330 SkRect sourceRect = RectToSkRect(aSource);
331
332 TempBitmap bitmap = GetBitmapForSurface(aSurface);
333
334 AutoPaintSetup paint(mCanvas.get(), aOptions, &aDest);
335 if (aSurfOptions.mFilter == Filter::POINT) {
336 paint.mPaint.setFilterLevel(SkPaint::kNone_FilterLevel);
337 }
338
339 mCanvas->drawBitmapRectToRect(bitmap.mBitmap, &sourceRect, destRect, &paint.mPaint);
340 }
341
342 void
343 DrawTargetSkia::DrawFilter(FilterNode *aNode,
344 const Rect &aSourceRect,
345 const Point &aDestPoint,
346 const DrawOptions &aOptions)
347 {
348 FilterNodeSoftware* filter = static_cast<FilterNodeSoftware*>(aNode);
349 filter->Draw(this, aSourceRect, aDestPoint, aOptions);
350 }
351
352 void
353 DrawTargetSkia::DrawSurfaceWithShadow(SourceSurface *aSurface,
354 const Point &aDest,
355 const Color &aColor,
356 const Point &aOffset,
357 Float aSigma,
358 CompositionOp aOperator)
359 {
360 if (!(aSurface->GetType() == SurfaceType::SKIA || aSurface->GetType() == SurfaceType::DATA)) {
361 return;
362 }
363
364 MarkChanged();
365
366 mCanvas->save(SkCanvas::kMatrix_SaveFlag);
367 mCanvas->resetMatrix();
368
369 TempBitmap bitmap = GetBitmapForSurface(aSurface);
370
371 SkPaint paint;
372
373 SkImageFilter* filter = SkDropShadowImageFilter::Create(aOffset.x, aOffset.y,
374 aSigma, ColorToSkColor(aColor, 1.0));
375
376 paint.setImageFilter(filter);
377 paint.setXfermodeMode(GfxOpToSkiaOp(aOperator));
378
379 mCanvas->drawBitmap(bitmap.mBitmap, aDest.x, aDest.y, &paint);
380 mCanvas->restore();
381 }
382
383 void
384 DrawTargetSkia::FillRect(const Rect &aRect,
385 const Pattern &aPattern,
386 const DrawOptions &aOptions)
387 {
388 MarkChanged();
389 SkRect rect = RectToSkRect(aRect);
390 AutoPaintSetup paint(mCanvas.get(), aOptions, aPattern, &aRect);
391
392 mCanvas->drawRect(rect, paint.mPaint);
393 }
394
395 void
396 DrawTargetSkia::Stroke(const Path *aPath,
397 const Pattern &aPattern,
398 const StrokeOptions &aStrokeOptions,
399 const DrawOptions &aOptions)
400 {
401 MarkChanged();
402 MOZ_ASSERT(aPath, "Null path");
403 if (aPath->GetBackendType() != BackendType::SKIA) {
404 return;
405 }
406
407 const PathSkia *skiaPath = static_cast<const PathSkia*>(aPath);
408
409
410 AutoPaintSetup paint(mCanvas.get(), aOptions, aPattern);
411 if (!StrokeOptionsToPaint(paint.mPaint, aStrokeOptions)) {
412 return;
413 }
414
415 mCanvas->drawPath(skiaPath->GetPath(), paint.mPaint);
416 }
417
418 void
419 DrawTargetSkia::StrokeRect(const Rect &aRect,
420 const Pattern &aPattern,
421 const StrokeOptions &aStrokeOptions,
422 const DrawOptions &aOptions)
423 {
424 MarkChanged();
425 AutoPaintSetup paint(mCanvas.get(), aOptions, aPattern);
426 if (!StrokeOptionsToPaint(paint.mPaint, aStrokeOptions)) {
427 return;
428 }
429
430 mCanvas->drawRect(RectToSkRect(aRect), paint.mPaint);
431 }
432
433 void
434 DrawTargetSkia::StrokeLine(const Point &aStart,
435 const Point &aEnd,
436 const Pattern &aPattern,
437 const StrokeOptions &aStrokeOptions,
438 const DrawOptions &aOptions)
439 {
440 MarkChanged();
441 AutoPaintSetup paint(mCanvas.get(), aOptions, aPattern);
442 if (!StrokeOptionsToPaint(paint.mPaint, aStrokeOptions)) {
443 return;
444 }
445
446 mCanvas->drawLine(SkFloatToScalar(aStart.x), SkFloatToScalar(aStart.y),
447 SkFloatToScalar(aEnd.x), SkFloatToScalar(aEnd.y),
448 paint.mPaint);
449 }
450
451 void
452 DrawTargetSkia::Fill(const Path *aPath,
453 const Pattern &aPattern,
454 const DrawOptions &aOptions)
455 {
456 MarkChanged();
457 if (aPath->GetBackendType() != BackendType::SKIA) {
458 return;
459 }
460
461 const PathSkia *skiaPath = static_cast<const PathSkia*>(aPath);
462
463 AutoPaintSetup paint(mCanvas.get(), aOptions, aPattern);
464
465 mCanvas->drawPath(skiaPath->GetPath(), paint.mPaint);
466 }
467
468 void
469 DrawTargetSkia::FillGlyphs(ScaledFont *aFont,
470 const GlyphBuffer &aBuffer,
471 const Pattern &aPattern,
472 const DrawOptions &aOptions,
473 const GlyphRenderingOptions *aRenderingOptions)
474 {
475 if (aFont->GetType() != FontType::MAC &&
476 aFont->GetType() != FontType::SKIA &&
477 aFont->GetType() != FontType::GDI) {
478 return;
479 }
480
481 MarkChanged();
482
483 ScaledFontBase* skiaFont = static_cast<ScaledFontBase*>(aFont);
484
485 AutoPaintSetup paint(mCanvas.get(), aOptions, aPattern);
486 paint.mPaint.setTypeface(skiaFont->GetSkTypeface());
487 paint.mPaint.setTextSize(SkFloatToScalar(skiaFont->mSize));
488 paint.mPaint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
489
490 if (aRenderingOptions && aRenderingOptions->GetType() == FontType::CAIRO) {
491 switch (static_cast<const GlyphRenderingOptionsCairo*>(aRenderingOptions)->GetHinting()) {
492 case FontHinting::NONE:
493 paint.mPaint.setHinting(SkPaint::kNo_Hinting);
494 break;
495 case FontHinting::LIGHT:
496 paint.mPaint.setHinting(SkPaint::kSlight_Hinting);
497 break;
498 case FontHinting::NORMAL:
499 paint.mPaint.setHinting(SkPaint::kNormal_Hinting);
500 break;
501 case FontHinting::FULL:
502 paint.mPaint.setHinting(SkPaint::kFull_Hinting);
503 break;
504 }
505
506 if (static_cast<const GlyphRenderingOptionsCairo*>(aRenderingOptions)->GetAutoHinting()) {
507 paint.mPaint.setAutohinted(true);
508 }
509 } else {
510 paint.mPaint.setHinting(SkPaint::kNormal_Hinting);
511 }
512
513 std::vector<uint16_t> indices;
514 std::vector<SkPoint> offsets;
515 indices.resize(aBuffer.mNumGlyphs);
516 offsets.resize(aBuffer.mNumGlyphs);
517
518 for (unsigned int i = 0; i < aBuffer.mNumGlyphs; i++) {
519 indices[i] = aBuffer.mGlyphs[i].mIndex;
520 offsets[i].fX = SkFloatToScalar(aBuffer.mGlyphs[i].mPosition.x);
521 offsets[i].fY = SkFloatToScalar(aBuffer.mGlyphs[i].mPosition.y);
522 }
523
524 mCanvas->drawPosText(&indices.front(), aBuffer.mNumGlyphs*2, &offsets.front(), paint.mPaint);
525 }
526
527 void
528 DrawTargetSkia::Mask(const Pattern &aSource,
529 const Pattern &aMask,
530 const DrawOptions &aOptions)
531 {
532 MarkChanged();
533 AutoPaintSetup paint(mCanvas.get(), aOptions, aSource);
534
535 SkPaint maskPaint;
536 TempBitmap tmpBitmap;
537 SetPaintPattern(maskPaint, aMask, tmpBitmap);
538
539 SkLayerRasterizer *raster = new SkLayerRasterizer();
540 raster->addLayer(maskPaint);
541 SkSafeUnref(paint.mPaint.setRasterizer(raster));
542
543 mCanvas->drawRect(SkRectCoveringWholeSurface(), paint.mPaint);
544 }
545
546 void
547 DrawTargetSkia::MaskSurface(const Pattern &aSource,
548 SourceSurface *aMask,
549 Point aOffset,
550 const DrawOptions &aOptions)
551 {
552 MarkChanged();
553 AutoPaintSetup paint(mCanvas.get(), aOptions, aSource);
554
555 SkPaint maskPaint;
556 TempBitmap tmpBitmap;
557 SetPaintPattern(maskPaint, SurfacePattern(aMask, ExtendMode::CLAMP), tmpBitmap);
558
559 SkMatrix transform = maskPaint.getShader()->getLocalMatrix();
560 transform.postTranslate(SkFloatToScalar(aOffset.x), SkFloatToScalar(aOffset.y));
561 maskPaint.getShader()->setLocalMatrix(transform);
562
563 SkLayerRasterizer *raster = new SkLayerRasterizer();
564 raster->addLayer(maskPaint);
565 SkSafeUnref(paint.mPaint.setRasterizer(raster));
566
567 IntSize size = aMask->GetSize();
568 Rect rect = Rect(aOffset.x, aOffset.y, size.width, size.height);
569 mCanvas->drawRect(RectToSkRect(rect), paint.mPaint);
570 }
571
572 TemporaryRef<SourceSurface>
573 DrawTargetSkia::CreateSourceSurfaceFromData(unsigned char *aData,
574 const IntSize &aSize,
575 int32_t aStride,
576 SurfaceFormat aFormat) const
577 {
578 RefPtr<SourceSurfaceSkia> newSurf = new SourceSurfaceSkia();
579
580 if (!newSurf->InitFromData(aData, aSize, aStride, aFormat)) {
581 gfxDebug() << *this << ": Failure to create source surface from data. Size: " << aSize;
582 return nullptr;
583 }
584
585 return newSurf;
586 }
587
588 TemporaryRef<DrawTarget>
589 DrawTargetSkia::CreateSimilarDrawTarget(const IntSize &aSize, SurfaceFormat aFormat) const
590 {
591 RefPtr<DrawTargetSkia> target = new DrawTargetSkia();
592 if (!target->Init(aSize, aFormat)) {
593 return nullptr;
594 }
595 return target;
596 }
597
598 TemporaryRef<SourceSurface>
599 DrawTargetSkia::OptimizeSourceSurface(SourceSurface *aSurface) const
600 {
601 if (aSurface->GetType() == SurfaceType::SKIA) {
602 return aSurface;
603 }
604
605 return aSurface->GetDataSurface();
606 }
607
608 TemporaryRef<SourceSurface>
609 DrawTargetSkia::CreateSourceSurfaceFromNativeSurface(const NativeSurface &aSurface) const
610 {
611 return nullptr;
612 }
613
614 void
615 DrawTargetSkia::CopySurface(SourceSurface *aSurface,
616 const IntRect& aSourceRect,
617 const IntPoint &aDestination)
618 {
619 //TODO: We could just use writePixels() here if the sourceRect is the entire source
620
621 if (aSurface->GetType() != SurfaceType::SKIA) {
622 return;
623 }
624
625 MarkChanged();
626
627 TempBitmap bitmap = GetBitmapForSurface(aSurface);
628
629 mCanvas->save();
630 mCanvas->resetMatrix();
631 SkRect dest = IntRectToSkRect(IntRect(aDestination.x, aDestination.y, aSourceRect.width, aSourceRect.height));
632 SkIRect source = IntRectToSkIRect(aSourceRect);
633 mCanvas->clipRect(dest, SkRegion::kReplace_Op);
634 SkPaint paint;
635
636 if (mCanvas->getDevice()->config() == SkBitmap::kRGB_565_Config) {
637 // Set the xfermode to SOURCE_OVER to workaround
638 // http://code.google.com/p/skia/issues/detail?id=628
639 // RGB565 is opaque so they're equivalent anyway
640 paint.setXfermodeMode(SkXfermode::kSrcOver_Mode);
641 } else {
642 paint.setXfermodeMode(SkXfermode::kSrc_Mode);
643 }
644
645 mCanvas->drawBitmapRect(bitmap.mBitmap, &source, dest, &paint);
646 mCanvas->restore();
647 }
648
649 bool
650 DrawTargetSkia::Init(const IntSize &aSize, SurfaceFormat aFormat)
651 {
652 SkAutoTUnref<SkBaseDevice> device(new SkBitmapDevice(GfxFormatToSkiaConfig(aFormat),
653 aSize.width, aSize.height,
654 aFormat == SurfaceFormat::B8G8R8X8));
655
656 SkBitmap bitmap = device->accessBitmap(true);
657 if (!bitmap.allocPixels()) {
658 return false;
659 }
660
661 bitmap.eraseARGB(0, 0, 0, 0);
662
663 SkAutoTUnref<SkCanvas> canvas(new SkCanvas(device.get()));
664 mSize = aSize;
665
666 mCanvas = canvas.get();
667 mFormat = aFormat;
668 return true;
669 }
670
671 #ifdef USE_SKIA_GPU
672 bool
673 DrawTargetSkia::InitWithGrContext(GrContext* aGrContext,
674 const IntSize &aSize,
675 SurfaceFormat aFormat)
676 {
677 MOZ_ASSERT(aGrContext, "null GrContext");
678
679 mGrContext = aGrContext;
680
681 mSize = aSize;
682 mFormat = aFormat;
683
684 GrTextureDesc targetDescriptor;
685
686 targetDescriptor.fFlags = kRenderTarget_GrTextureFlagBit;
687 targetDescriptor.fWidth = mSize.width;
688 targetDescriptor.fHeight = mSize.height;
689 targetDescriptor.fConfig = GfxFormatToGrConfig(mFormat);
690 targetDescriptor.fOrigin = kBottomLeft_GrSurfaceOrigin;
691 targetDescriptor.fSampleCnt = 0;
692
693 SkAutoTUnref<GrTexture> skiaTexture(mGrContext->createUncachedTexture(targetDescriptor, NULL, 0));
694 if (!skiaTexture) {
695 return false;
696 }
697
698 mTexture = (uint32_t)skiaTexture->getTextureHandle();
699
700 SkAutoTUnref<SkBaseDevice> device(new SkGpuDevice(mGrContext.get(), skiaTexture->asRenderTarget()));
701 SkAutoTUnref<SkCanvas> canvas(new SkCanvas(device.get()));
702 mCanvas = canvas.get();
703
704 return true;
705 }
706
707 #endif
708
709 void
710 DrawTargetSkia::Init(unsigned char* aData, const IntSize &aSize, int32_t aStride, SurfaceFormat aFormat)
711 {
712 SkAlphaType alphaType = kPremul_SkAlphaType;
713 if (aFormat == SurfaceFormat::B8G8R8X8) {
714 // We have to manually set the A channel to be 255 as Skia doesn't understand BGRX
715 ConvertBGRXToBGRA(aData, aSize, aStride);
716 alphaType = kOpaque_SkAlphaType;
717 }
718
719 SkBitmap bitmap;
720 bitmap.setConfig(GfxFormatToSkiaConfig(aFormat), aSize.width, aSize.height, aStride, alphaType);
721 bitmap.setPixels(aData);
722 SkAutoTUnref<SkCanvas> canvas(new SkCanvas(new SkBitmapDevice(bitmap)));
723
724 mSize = aSize;
725 mCanvas = canvas.get();
726 mFormat = aFormat;
727 }
728
729 void
730 DrawTargetSkia::SetTransform(const Matrix& aTransform)
731 {
732 SkMatrix mat;
733 GfxMatrixToSkiaMatrix(aTransform, mat);
734 mCanvas->setMatrix(mat);
735 mTransform = aTransform;
736 }
737
738 void*
739 DrawTargetSkia::GetNativeSurface(NativeSurfaceType aType)
740 {
741 if (aType == NativeSurfaceType::OPENGL_TEXTURE) {
742 return (void*)((uintptr_t)mTexture);
743 }
744
745 return nullptr;
746 }
747
748
749 TemporaryRef<PathBuilder>
750 DrawTargetSkia::CreatePathBuilder(FillRule aFillRule) const
751 {
752 RefPtr<PathBuilderSkia> pb = new PathBuilderSkia(aFillRule);
753 return pb;
754 }
755
756 void
757 DrawTargetSkia::ClearRect(const Rect &aRect)
758 {
759 MarkChanged();
760 SkPaint paint;
761 mCanvas->save();
762 mCanvas->clipRect(RectToSkRect(aRect), SkRegion::kIntersect_Op, true);
763 paint.setColor(SkColorSetARGB(0, 0, 0, 0));
764 paint.setXfermodeMode(SkXfermode::kSrc_Mode);
765 mCanvas->drawPaint(paint);
766 mCanvas->restore();
767 }
768
769 void
770 DrawTargetSkia::PushClip(const Path *aPath)
771 {
772 if (aPath->GetBackendType() != BackendType::SKIA) {
773 return;
774 }
775
776 const PathSkia *skiaPath = static_cast<const PathSkia*>(aPath);
777 mCanvas->save(SkCanvas::kClip_SaveFlag);
778 mCanvas->clipPath(skiaPath->GetPath(), SkRegion::kIntersect_Op, true);
779 }
780
781 void
782 DrawTargetSkia::PushClipRect(const Rect& aRect)
783 {
784 SkRect rect = RectToSkRect(aRect);
785
786 mCanvas->save(SkCanvas::kClip_SaveFlag);
787 mCanvas->clipRect(rect, SkRegion::kIntersect_Op, true);
788 }
789
790 void
791 DrawTargetSkia::PopClip()
792 {
793 mCanvas->restore();
794 }
795
796 TemporaryRef<GradientStops>
797 DrawTargetSkia::CreateGradientStops(GradientStop *aStops, uint32_t aNumStops, ExtendMode aExtendMode) const
798 {
799 std::vector<GradientStop> stops;
800 stops.resize(aNumStops);
801 for (uint32_t i = 0; i < aNumStops; i++) {
802 stops[i] = aStops[i];
803 }
804 std::stable_sort(stops.begin(), stops.end());
805
806 return new GradientStopsSkia(stops, aNumStops, aExtendMode);
807 }
808
809 TemporaryRef<FilterNode>
810 DrawTargetSkia::CreateFilter(FilterType aType)
811 {
812 return FilterNodeSoftware::Create(aType);
813 }
814
815 void
816 DrawTargetSkia::MarkChanged()
817 {
818 if (mSnapshot) {
819 mSnapshot->DrawTargetWillChange();
820 mSnapshot = nullptr;
821 }
822 }
823
824 // Return a rect (in user space) that covers the entire surface by applying
825 // the inverse of GetTransform() to (0, 0, mSize.width, mSize.height).
826 SkRect
827 DrawTargetSkia::SkRectCoveringWholeSurface() const
828 {
829 return RectToSkRect(mTransform.TransformBounds(Rect(0, 0, mSize.width, mSize.height)));
830 }
831
832 void
833 DrawTargetSkia::SnapshotDestroyed()
834 {
835 mSnapshot = nullptr;
836 }
837
838 }
839 }

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial