LCOV - code coverage report
Current view: directory - gfx/skia/include/core - SkBlitter.h (source / functions) Found Hit Coverage
Test: app.info Lines: 15 0 0.0 %
Date: 2012-06-02 Functions: 14 0 0.0 %

       1                 : 
       2                 : /*
       3                 :  * Copyright 2006 The Android Open Source Project
       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                 : 
       9                 : 
      10                 : #ifndef SkBlitter_DEFINED
      11                 : #define SkBlitter_DEFINED
      12                 : 
      13                 : #include "SkBitmap.h"
      14                 : #include "SkMatrix.h"
      15                 : #include "SkPaint.h"
      16                 : #include "SkRefCnt.h"
      17                 : #include "SkRegion.h"
      18                 : #include "SkMask.h"
      19                 : 
      20                 : /** SkBlitter and its subclasses are responsible for actually writing pixels
      21                 :     into memory. Besides efficiency, they handle clipping and antialiasing.
      22                 : */
      23               0 : class SkBlitter {
      24                 : public:
      25                 :     virtual ~SkBlitter();
      26                 : 
      27                 :     /// Blit a horizontal run of one or more pixels.
      28                 :     virtual void blitH(int x, int y, int width);
      29                 :     /// Blit a horizontal run of antialiased pixels; runs[] is a *sparse*
      30                 :     /// zero-terminated run-length encoding of spans of constant alpha values.
      31                 :     virtual void blitAntiH(int x, int y, const SkAlpha antialias[],
      32                 :                            const int16_t runs[]);
      33                 :     /// Blit a vertical run of pixels with a constant alpha value.
      34                 :     virtual void blitV(int x, int y, int height, SkAlpha alpha);
      35                 :     /// Blit a solid rectangle one or more pixels wide.
      36                 :     virtual void blitRect(int x, int y, int width, int height);
      37                 :     /** Blit a rectangle with one alpha-blended column on the left,
      38                 :         width (zero or more) opaque pixels, and one alpha-blended column
      39                 :         on the right.
      40                 :         The result will always be at least two pixels wide.
      41                 :     */
      42                 :     virtual void blitAntiRect(int x, int y, int width, int height,
      43                 :                               SkAlpha leftAlpha, SkAlpha rightAlpha);
      44                 :     /// Blit a pattern of pixels defined by a rectangle-clipped mask;
      45                 :     /// typically used for text.
      46                 :     virtual void blitMask(const SkMask&, const SkIRect& clip);
      47                 : 
      48                 :     /** If the blitter just sets a single value for each pixel, return the
      49                 :         bitmap it draws into, and assign value. If not, return NULL and ignore
      50                 :         the value parameter.
      51                 :     */
      52                 :     virtual const SkBitmap* justAnOpaqueColor(uint32_t* value);
      53                 : 
      54                 :     ///@name non-virtual helpers
      55                 :     void blitMaskRegion(const SkMask& mask, const SkRegion& clip);
      56                 :     void blitRectRegion(const SkIRect& rect, const SkRegion& clip);
      57                 :     void blitRegion(const SkRegion& clip);
      58                 :     ///@}
      59                 : 
      60                 :     /** @name Factories
      61                 :         Return the correct blitter to use given the specified context.
      62                 :      */
      63                 :     static SkBlitter* Choose(const SkBitmap& device,
      64                 :                              const SkMatrix& matrix,
      65                 :                              const SkPaint& paint) {
      66                 :         return Choose(device, matrix, paint, NULL, 0);
      67                 :     }
      68                 : 
      69                 :     static SkBlitter* Choose(const SkBitmap& device,
      70                 :                              const SkMatrix& matrix,
      71                 :                              const SkPaint& paint,
      72                 :                              void* storage, size_t storageSize);
      73                 : 
      74                 :     static SkBlitter* ChooseSprite(const SkBitmap& device,
      75                 :                                    const SkPaint&,
      76                 :                                    const SkBitmap& src,
      77                 :                                    int left, int top,
      78                 :                                    void* storage, size_t storageSize);
      79                 :     ///@}
      80                 : 
      81                 : private:
      82                 : };
      83                 : 
      84                 : /** This blitter silently never draws anything.
      85                 : */
      86               0 : class SkNullBlitter : public SkBlitter {
      87                 : public:
      88                 :     virtual void blitH(int x, int y, int width) SK_OVERRIDE;
      89                 :     virtual void blitAntiH(int x, int y, const SkAlpha[],
      90                 :                            const int16_t runs[]) SK_OVERRIDE;
      91                 :     virtual void blitV(int x, int y, int height, SkAlpha alpha) SK_OVERRIDE;
      92                 :     virtual void blitRect(int x, int y, int width, int height) SK_OVERRIDE;
      93                 :     virtual void blitMask(const SkMask&, const SkIRect& clip) SK_OVERRIDE;
      94                 :     virtual const SkBitmap* justAnOpaqueColor(uint32_t* value) SK_OVERRIDE;
      95                 : };
      96                 : 
      97                 : /** Wraps another (real) blitter, and ensures that the real blitter is only
      98                 :     called with coordinates that have been clipped by the specified clipRect.
      99                 :     This means the caller need not perform the clipping ahead of time.
     100                 : */
     101               0 : class SkRectClipBlitter : public SkBlitter {
     102                 : public:
     103               0 :     void init(SkBlitter* blitter, const SkIRect& clipRect) {
     104               0 :         SkASSERT(!clipRect.isEmpty());
     105               0 :         fBlitter = blitter;
     106               0 :         fClipRect = clipRect;
     107               0 :     }
     108                 : 
     109                 :     virtual void blitH(int x, int y, int width) SK_OVERRIDE;
     110                 :     virtual void blitAntiH(int x, int y, const SkAlpha[],
     111                 :                            const int16_t runs[]) SK_OVERRIDE;
     112                 :     virtual void blitV(int x, int y, int height, SkAlpha alpha) SK_OVERRIDE;
     113                 :     virtual void blitRect(int x, int y, int width, int height) SK_OVERRIDE;
     114                 :     virtual void blitAntiRect(int x, int y, int width, int height,
     115                 :                      SkAlpha leftAlpha, SkAlpha rightAlpha) SK_OVERRIDE;
     116                 :     virtual void blitMask(const SkMask&, const SkIRect& clip) SK_OVERRIDE;
     117                 :     virtual const SkBitmap* justAnOpaqueColor(uint32_t* value) SK_OVERRIDE;
     118                 : 
     119                 : private:
     120                 :     SkBlitter*  fBlitter;
     121                 :     SkIRect     fClipRect;
     122                 : };
     123                 : 
     124                 : /** Wraps another (real) blitter, and ensures that the real blitter is only
     125                 :     called with coordinates that have been clipped by the specified clipRgn.
     126                 :     This means the caller need not perform the clipping ahead of time.
     127                 : */
     128               0 : class SkRgnClipBlitter : public SkBlitter {
     129                 : public:
     130               0 :     void init(SkBlitter* blitter, const SkRegion* clipRgn) {
     131               0 :         SkASSERT(clipRgn && !clipRgn->isEmpty());
     132               0 :         fBlitter = blitter;
     133               0 :         fRgn = clipRgn;
     134               0 :     }
     135                 : 
     136                 :     virtual void blitH(int x, int y, int width) SK_OVERRIDE;
     137                 :     virtual void blitAntiH(int x, int y, const SkAlpha[],
     138                 :                            const int16_t runs[]) SK_OVERRIDE;
     139                 :     virtual void blitV(int x, int y, int height, SkAlpha alpha) SK_OVERRIDE;
     140                 :     virtual void blitRect(int x, int y, int width, int height) SK_OVERRIDE;
     141                 :     virtual void blitAntiRect(int x, int y, int width, int height,
     142                 :                      SkAlpha leftAlpha, SkAlpha rightAlpha) SK_OVERRIDE;
     143                 :     virtual void blitMask(const SkMask&, const SkIRect& clip) SK_OVERRIDE;
     144                 :     virtual const SkBitmap* justAnOpaqueColor(uint32_t* value) SK_OVERRIDE;
     145                 : 
     146                 : private:
     147                 :     SkBlitter*      fBlitter;
     148                 :     const SkRegion* fRgn;
     149                 : };
     150                 : 
     151                 : /** Factory to set up the appropriate most-efficient wrapper blitter
     152                 :     to apply a clip. Returns a pointer to a member, so lifetime must
     153                 :     be managed carefully.
     154                 : */
     155               0 : class SkBlitterClipper {
     156                 : public:
     157                 :     SkBlitter*  apply(SkBlitter* blitter, const SkRegion* clip,
     158                 :                       const SkIRect* bounds = NULL);
     159                 : 
     160                 : private:
     161                 :     SkNullBlitter       fNullBlitter;
     162                 :     SkRectClipBlitter   fRectBlitter;
     163                 :     SkRgnClipBlitter    fRgnBlitter;
     164                 : };
     165                 : 
     166                 : #endif

Generated by: LCOV version 1.7