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

       1                 : /*
       2                 :  * Copyright 2006 The Android Open Source Project
       3                 :  *
       4                 :  * Use of this source code is governed by a BSD-style license that can be
       5                 :  * found in the LICENSE file.
       6                 :  */
       7                 : 
       8                 : #ifndef SkCoreBlitters_DEFINED
       9                 : #define SkCoreBlitters_DEFINED
      10                 : 
      11                 : #include "SkBlitter.h"
      12                 : #include "SkBlitRow.h"
      13                 : 
      14               0 : class SkRasterBlitter : public SkBlitter {
      15                 : public:
      16               0 :     SkRasterBlitter(const SkBitmap& device) : fDevice(device) {}
      17                 : 
      18                 : protected:
      19                 :     const SkBitmap& fDevice;
      20                 : 
      21                 : private:
      22                 :     typedef SkBlitter INHERITED;
      23                 : };
      24                 : 
      25                 : class SkShaderBlitter : public SkRasterBlitter {
      26                 : public:
      27                 :     SkShaderBlitter(const SkBitmap& device, const SkPaint& paint);
      28                 :     virtual ~SkShaderBlitter();
      29                 : 
      30                 : protected:
      31                 :     uint32_t    fShaderFlags;
      32                 :     SkShader*   fShader;
      33                 : 
      34                 : private:
      35                 :     // illegal
      36                 :     SkShaderBlitter& operator=(const SkShaderBlitter&);
      37                 : 
      38                 :     typedef SkRasterBlitter INHERITED;
      39                 : };
      40                 : 
      41                 : ///////////////////////////////////////////////////////////////////////////////
      42                 : 
      43               0 : class SkA8_Blitter : public SkRasterBlitter {
      44                 : public:
      45                 :     SkA8_Blitter(const SkBitmap& device, const SkPaint& paint);
      46                 :     virtual void blitH(int x, int y, int width);
      47                 :     virtual void blitAntiH(int x, int y, const SkAlpha antialias[], const int16_t runs[]);
      48                 :     virtual void blitV(int x, int y, int height, SkAlpha alpha);
      49                 :     virtual void blitRect(int x, int y, int width, int height);
      50                 :     virtual void blitMask(const SkMask&, const SkIRect&);
      51                 :     virtual const SkBitmap* justAnOpaqueColor(uint32_t*);
      52                 : 
      53                 : private:
      54                 :     unsigned fSrcA;
      55                 : 
      56                 :     // illegal
      57                 :     SkA8_Blitter& operator=(const SkA8_Blitter&);
      58                 : 
      59                 :     typedef SkRasterBlitter INHERITED;
      60                 : };
      61                 : 
      62                 : class SkA8_Shader_Blitter : public SkShaderBlitter {
      63                 : public:
      64                 :     SkA8_Shader_Blitter(const SkBitmap& device, const SkPaint& paint);
      65                 :     virtual ~SkA8_Shader_Blitter();
      66                 :     virtual void blitH(int x, int y, int width);
      67                 :     virtual void blitAntiH(int x, int y, const SkAlpha antialias[], const int16_t runs[]);
      68                 :     virtual void blitMask(const SkMask&, const SkIRect&);
      69                 : 
      70                 : private:
      71                 :     SkXfermode* fXfermode;
      72                 :     SkPMColor*  fBuffer;
      73                 :     uint8_t*    fAAExpand;
      74                 : 
      75                 :     // illegal
      76                 :     SkA8_Shader_Blitter& operator=(const SkA8_Shader_Blitter&);
      77                 : 
      78                 :     typedef SkShaderBlitter INHERITED;
      79                 : };
      80                 : 
      81                 : ////////////////////////////////////////////////////////////////
      82                 : 
      83               0 : class SkARGB32_Blitter : public SkRasterBlitter {
      84                 : public:
      85                 :     SkARGB32_Blitter(const SkBitmap& device, const SkPaint& paint);
      86                 :     virtual void blitH(int x, int y, int width);
      87                 :     virtual void blitAntiH(int x, int y, const SkAlpha antialias[], const int16_t runs[]);
      88                 :     virtual void blitV(int x, int y, int height, SkAlpha alpha);
      89                 :     virtual void blitRect(int x, int y, int width, int height);
      90                 :     virtual void blitMask(const SkMask&, const SkIRect&);
      91                 :     virtual const SkBitmap* justAnOpaqueColor(uint32_t*);
      92                 : 
      93                 : protected:
      94                 :     SkColor                fColor;
      95                 :     SkPMColor              fPMColor;
      96                 :     SkBlitRow::ColorProc   fColor32Proc;
      97                 : 
      98                 : private:
      99                 :     unsigned fSrcA, fSrcR, fSrcG, fSrcB;
     100                 : 
     101                 :     // illegal
     102                 :     SkARGB32_Blitter& operator=(const SkARGB32_Blitter&);
     103                 : 
     104                 :     typedef SkRasterBlitter INHERITED;
     105                 : };
     106                 : 
     107               0 : class SkARGB32_Opaque_Blitter : public SkARGB32_Blitter {
     108                 : public:
     109               0 :     SkARGB32_Opaque_Blitter(const SkBitmap& device, const SkPaint& paint)
     110               0 :         : INHERITED(device, paint) { SkASSERT(paint.getAlpha() == 0xFF); }
     111                 :     virtual void blitMask(const SkMask&, const SkIRect&);
     112                 : 
     113                 : private:
     114                 :     typedef SkARGB32_Blitter INHERITED;
     115                 : };
     116                 : 
     117               0 : class SkARGB32_Black_Blitter : public SkARGB32_Opaque_Blitter {
     118                 : public:
     119               0 :     SkARGB32_Black_Blitter(const SkBitmap& device, const SkPaint& paint)
     120               0 :         : INHERITED(device, paint) {}
     121                 :     virtual void blitAntiH(int x, int y, const SkAlpha antialias[], const int16_t runs[]);
     122                 : 
     123                 : private:
     124                 :     typedef SkARGB32_Opaque_Blitter INHERITED;
     125                 : };
     126                 : 
     127                 : class SkARGB32_Shader_Blitter : public SkShaderBlitter {
     128                 : public:
     129                 :     SkARGB32_Shader_Blitter(const SkBitmap& device, const SkPaint& paint);
     130                 :     virtual ~SkARGB32_Shader_Blitter();
     131                 :     virtual void blitH(int x, int y, int width);
     132                 :     virtual void blitAntiH(int x, int y, const SkAlpha antialias[], const int16_t runs[]);
     133                 :     virtual void blitMask(const SkMask&, const SkIRect&);
     134                 : 
     135                 : private:
     136                 :     SkXfermode*         fXfermode;
     137                 :     SkPMColor*          fBuffer;
     138                 :     SkBlitRow::Proc32   fProc32;
     139                 :     SkBlitRow::Proc32   fProc32Blend;
     140                 : 
     141                 :     // illegal
     142                 :     SkARGB32_Shader_Blitter& operator=(const SkARGB32_Shader_Blitter&);
     143                 : 
     144                 :     typedef SkShaderBlitter INHERITED;
     145                 : };
     146                 : 
     147                 : ///////////////////////////////////////////////////////////////////////////////
     148                 : 
     149               0 : class SkA1_Blitter : public SkRasterBlitter {
     150                 : public:
     151                 :     SkA1_Blitter(const SkBitmap& device, const SkPaint& paint);
     152                 :     virtual void blitH(int x, int y, int width);
     153                 : 
     154                 : private:
     155                 :     uint8_t fSrcA;
     156                 : 
     157                 :     // illegal
     158                 :     SkA1_Blitter& operator=(const SkA1_Blitter&);
     159                 : 
     160                 :     typedef SkRasterBlitter INHERITED;
     161                 : };
     162                 : 
     163                 : ///////////////////////////////////////////////////////////////////////////////
     164                 : 
     165                 : /*  These return the correct subclass of blitter for their device config.
     166                 : 
     167                 :     Currently, they make the following assumptions about the state of the
     168                 :     paint:
     169                 : 
     170                 :     1. If there is an xfermode, there will also be a shader
     171                 :     2. If there is a colorfilter, there will be a shader that itself handles
     172                 :        calling the filter, so the blitter can always ignore the colorfilter obj
     173                 : 
     174                 :     These pre-conditions must be handled by the caller, in our case
     175                 :     SkBlitter::Choose(...)
     176                 :  */
     177                 : 
     178                 : extern SkBlitter* SkBlitter_ChooseD4444(const SkBitmap& device,
     179                 :                                         const SkPaint& paint,
     180                 :                                         void* storage, size_t storageSize);
     181                 : 
     182                 : extern SkBlitter* SkBlitter_ChooseD565(const SkBitmap& device,
     183                 :                                        const SkPaint& paint,
     184                 :                                        void* storage, size_t storageSize);
     185                 : 
     186                 : #endif
     187                 : 

Generated by: LCOV version 1.7