LCOV - app.info - gfx/skia/src/core/SkConfig8888.h

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

           1                 :
           2                 : /*
           3                 :  * Copyright 2011 Google Inc.
           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                 : #include "SkCanvas.h"
          11                 : #include "SkColorPriv.h"
          12                 :
          13                 : namespace {
          14                 :
          15                 : /**
          16                 :   Copies all pixels from a bitmap to a dst ptr with a given rowBytes and
          17                 :   Config8888. The bitmap must have kARGB_8888_Config.
          18                 :  */
          19                 : inline void SkCopyBitmapToConfig8888(uint32_t* dstPixels,
          20                 :                                      size_t dstRowBytes,
          21                 :                                      SkCanvas::Config8888 dstConfig8888,
          22                 :                                      const SkBitmap& srcBmp);
          23                 :
          24                 : /**
          25                 :  * Copies all pixels in a bitmap to a dst ptr with row bytes. The src bitmap
          26                 :  * is assumed to have pixels and be kARGB_8888_Config. No conversion is applied
          27                 :  */
          28                 : inline void SkCopyARGB8888BitmapTo(uint32_t* dstPixels,
          29                 :                                    size_t dstRowBytes,
          30                 :                                    const SkBitmap& srcBmp);
          31                 :
          32                 : /**
          33                 :   Copies over all pixels in a bitmap from a src ptr with a given rowBytes and
          34                 :   Config8888. The bitmap must have pixels and be kARGB_8888_Config.
          35                 :  */
          36                 : inline void SkCopyConfig8888ToBitmap(const SkBitmap& dstBmp,
          37                 :                                      const uint32_t* srcPixels,
          38                 :                                      size_t srcRowBytes,
          39                 :                                      SkCanvas::Config8888 srcConfig8888);
          40                 :
          41                 : }
          42                 :
          43                 : ///////////////////////////////////////////////////////////////////////////////
          44                 : // Implementation
          45                 :
          46                 : namespace {
          47                 :
          48                 : template <int A_IDX, int R_IDX, int G_IDX, int B_IDX>
          49               0 : inline uint32_t pack_config8888(uint32_t a, uint32_t r,
          50                 :                                 uint32_t g, uint32_t b) {
          51                 : #ifdef SK_CPU_LENDIAN
          52                 :     return (a << (A_IDX * 8)) | (r << (R_IDX * 8)) |
          53               0 :            (g << (G_IDX * 8)) | (b << (B_IDX * 8));
          54                 : #else
          55                 :     return (a << ((3-A_IDX) * 8)) | (r << ((3-R_IDX) * 8)) |
          56                 :            (g << ((3-G_IDX) * 8)) | (b << ((3-B_IDX) * 8));
          57                 : #endif
          58                 : }
          59                 :
          60                 : template <int A_IDX, int R_IDX, int G_IDX, int B_IDX>
          61               0 : inline void unpack_config8888(uint32_t color,
          62                 :                               uint32_t* a, uint32_t* r,
          63                 :                               uint32_t* g, uint32_t* b) {
          64                 : #ifdef SK_CPU_LENDIAN
          65               0 :     *a = (color >> (A_IDX * 8)) & 0xff;
          66               0 :     *r = (color >> (R_IDX * 8)) & 0xff;
          67               0 :     *g = (color >> (G_IDX * 8)) & 0xff;
          68               0 :     *b = (color >> (B_IDX * 8)) & 0xff;
          69                 : #else
          70                 :     *a = (color >> ((3 - A_IDX) * 8)) & 0xff;
          71                 :     *r = (color >> ((3 - R_IDX) * 8)) & 0xff;
          72                 :     *g = (color >> ((3 - G_IDX) * 8)) & 0xff;
          73                 :     *b = (color >> ((3 - B_IDX) * 8)) & 0xff;
          74                 : #endif
          75               0 : }
          76                 :
          77                 : template <bool UNPM, int A_IDX, int R_IDX, int G_IDX, int B_IDX>
          78               0 : inline void bitmap_copy_to_config8888(uint32_t* dstPixels,
          79                 :                                       size_t dstRowBytes,
          80                 :                                       const SkBitmap& srcBmp) {
          81               0 :     SkASSERT(SkBitmap::kARGB_8888_Config == srcBmp.config());
          82               0 :     SkAutoLockPixels alp(srcBmp);
          83               0 :     int w = srcBmp.width();
          84               0 :     int h = srcBmp.height();
          85               0 :     size_t srcRowBytes = srcBmp.rowBytes();
          86                 :
          87               0 :     intptr_t src = reinterpret_cast<intptr_t>(srcBmp.getPixels());
          88               0 :     intptr_t dst = reinterpret_cast<intptr_t>(dstPixels);
          89                 :
          90               0 :     for (int y = 0; y < h; ++y) {
          91               0 :         const SkPMColor* srcRow = reinterpret_cast<SkPMColor*>(src);
          92               0 :         uint32_t* dstRow  = reinterpret_cast<uint32_t*>(dst);
          93               0 :         for (int x = 0; x < w; ++x) {
          94               0 :             SkPMColor pmcolor = srcRow[x];
          95                 :             if (UNPM) {
          96                 :                 U8CPU a, r, g, b;
          97               0 :                 a = SkGetPackedA32(pmcolor);
          98               0 :                 if (a) {
          99                 :                     // We're doing the explicit divide to match WebKit layout
         100                 :                     // test expectations. We can modify and rebaseline if there
         101                 :                     // it can be shown that there is a more performant way to
         102                 :                     // unpremul.
         103               0 :                     r = SkGetPackedR32(pmcolor) * 0xff / a;
         104               0 :                     g = SkGetPackedG32(pmcolor) * 0xff / a;
         105               0 :                     b = SkGetPackedB32(pmcolor) * 0xff / a;
         106               0 :                     dstRow[x] = pack_config8888<A_IDX, R_IDX,
         107                 :                                                 G_IDX, B_IDX>(a, r, g, b);
         108                 :                 } else {
         109               0 :                     dstRow[x] = 0;
         110                 :                 }
         111                 :             } else {
         112               0 :                 dstRow[x] = pack_config8888<A_IDX, R_IDX,
         113                 :                                             G_IDX, B_IDX>(
         114                 :                                                    SkGetPackedA32(pmcolor),
         115                 :                                                    SkGetPackedR32(pmcolor),
         116                 :                                                    SkGetPackedG32(pmcolor),
         117                 :                                                    SkGetPackedB32(pmcolor));
         118                 :             }
         119                 :         }
         120               0 :         dst += dstRowBytes;
         121               0 :         src += srcRowBytes;
         122                 :     }
         123               0 : }
         124                 :
         125                 : template <bool PM, int A_IDX, int R_IDX, int G_IDX, int B_IDX>
         126               0 : inline void config8888_copy_to_bitmap(const SkBitmap& dstBmp,
         127                 :                                       const uint32_t* srcPixels,
         128                 :                                       size_t srcRowBytes) {
         129               0 :     SkASSERT(SkBitmap::kARGB_8888_Config == dstBmp.config());
         130               0 :     SkAutoLockPixels alp(dstBmp);
         131               0 :     int w = dstBmp.width();
         132               0 :     int h = dstBmp.height();
         133               0 :     size_t dstRowBytes = dstBmp.rowBytes();
         134                 :
         135               0 :     intptr_t src = reinterpret_cast<intptr_t>(srcPixels);
         136               0 :     intptr_t dst = reinterpret_cast<intptr_t>(dstBmp.getPixels());
         137                 :
         138               0 :     for (int y = 0; y < h; ++y) {
         139               0 :         const uint32_t* srcRow  = reinterpret_cast<uint32_t*>(src);
         140               0 :         SkPMColor* dstRow = reinterpret_cast<SkPMColor*>(dst);
         141               0 :         for (int x = 0; x < w; ++x) {
         142               0 :             uint32_t c8888 = srcRow[x];
         143                 :             uint32_t a, r, g, b;
         144               0 :             unpack_config8888<A_IDX, R_IDX, G_IDX, B_IDX>(c8888, &a, &r,
         145                 :                                                                  &g, &b);
         146                 :             if (PM) {
         147                 :                 // This matches WebKit's conversion which we are replacing.
         148                 :                 // We can consider alternative rounding rules for performance.
         149               0 :                 r = SkMulDiv255Ceiling(r, a);
         150               0 :                 g = SkMulDiv255Ceiling(g, a);
         151               0 :                 b = SkMulDiv255Ceiling(b, a);
         152                 :             }
         153                 :             // NoCheck: https://bugs.webkit.org/show_bug.cgi?id=74025
         154               0 :             dstRow[x] = SkPackARGB32NoCheck(a, r, g, b);
         155                 :         }
         156               0 :         src += srcRowBytes;
         157               0 :         dst += dstRowBytes;
         158                 :     }
         159               0 : }
         160                 :
         161                 : #ifdef SK_CPU_LENDIAN
         162                 :     static const int SK_NATIVE_A_IDX = SK_A32_SHIFT / 8;
         163                 :     static const int SK_NATIVE_R_IDX = SK_R32_SHIFT / 8;
         164                 :     static const int SK_NATIVE_G_IDX = SK_G32_SHIFT / 8;
         165                 :     static const int SK_NATIVE_B_IDX = SK_B32_SHIFT / 8;
         166                 : #else
         167                 :     static const int SK_NATIVE_A_IDX = 3 - (SK_A32_SHIFT / 8);
         168                 :     static const int SK_NATIVE_R_IDX = 3 - (SK_R32_SHIFT / 8);
         169                 :     static const int SK_NATIVE_G_IDX = 3 - (SK_G32_SHIFT / 8);
         170                 :     static const int SK_NATIVE_B_IDX = 3 - (SK_B32_SHIFT / 8);
         171                 : #endif
         172                 :
         173               0 : inline void SkCopyBitmapToConfig8888(uint32_t* dstPixels,
         174                 :                                      size_t dstRowBytes,
         175                 :                                      SkCanvas::Config8888 dstConfig8888,
         176                 :                                      const SkBitmap& srcBmp) {
         177               0 :     switch (dstConfig8888) {
         178                 :         case SkCanvas::kNative_Premul_Config8888:
         179                 :             bitmap_copy_to_config8888<false,
         180                 :                                       SK_NATIVE_A_IDX, SK_NATIVE_R_IDX,
         181                 :                                       SK_NATIVE_G_IDX, SK_NATIVE_B_IDX>(
         182                 :                                             dstPixels,
         183                 :                                             dstRowBytes,
         184               0 :                                             srcBmp);
         185               0 :             break;
         186                 :         case SkCanvas::kNative_Unpremul_Config8888:
         187                 :             bitmap_copy_to_config8888<true,
         188                 :                                       SK_NATIVE_A_IDX, SK_NATIVE_R_IDX,
         189                 :                                       SK_NATIVE_G_IDX, SK_NATIVE_B_IDX>(
         190                 :                                             dstPixels,
         191                 :                                             dstRowBytes,
         192               0 :                                             srcBmp);
         193               0 :             break;
         194                 :         case SkCanvas::kBGRA_Premul_Config8888:
         195                 :             bitmap_copy_to_config8888<false, 3, 2, 1, 0> (
         196               0 :                                     dstPixels, dstRowBytes, srcBmp);
         197               0 :             break;
         198                 :         case SkCanvas::kBGRA_Unpremul_Config8888:
         199                 :             bitmap_copy_to_config8888<true, 3, 2, 1, 0> (
         200               0 :                                     dstPixels, dstRowBytes, srcBmp);
         201               0 :             break;
         202                 :         case SkCanvas::kRGBA_Premul_Config8888:
         203                 :             bitmap_copy_to_config8888<false, 3, 0, 1, 2> (
         204               0 :                                     dstPixels, dstRowBytes, srcBmp);
         205               0 :             break;
         206                 :         case SkCanvas::kRGBA_Unpremul_Config8888:
         207                 :             bitmap_copy_to_config8888<true, 3, 0, 1, 2> (
         208               0 :                                     dstPixels, dstRowBytes, srcBmp);
         209               0 :             break;
         210                 :         default:
         211               0 :             SkDEBUGFAIL("unexpected Config8888");
         212               0 :             break;
         213                 :     }
         214               0 : }
         215                 :
         216               0 : inline void SkCopyConfig8888ToBitmap(const SkBitmap& dstBmp,
         217                 :                                      const uint32_t* srcPixels,
         218                 :                                      size_t srcRowBytes,
         219                 :                                      SkCanvas::Config8888 srcConfig8888) {
         220               0 :     switch (srcConfig8888) {
         221                 :         case SkCanvas::kNative_Premul_Config8888:
         222                 :             config8888_copy_to_bitmap<false,
         223                 :                                       SK_NATIVE_A_IDX, SK_NATIVE_R_IDX,
         224                 :                                       SK_NATIVE_G_IDX, SK_NATIVE_B_IDX>(
         225                 :                                             dstBmp,
         226                 :                                             srcPixels,
         227               0 :                                             srcRowBytes);
         228               0 :             break;
         229                 :         case SkCanvas::kNative_Unpremul_Config8888:
         230                 :             config8888_copy_to_bitmap<true,
         231                 :                                       SK_NATIVE_A_IDX, SK_NATIVE_R_IDX,
         232                 :                                       SK_NATIVE_G_IDX, SK_NATIVE_B_IDX>(
         233                 :                                             dstBmp,
         234                 :                                             srcPixels,
         235               0 :                                             srcRowBytes);
         236               0 :             break;
         237                 :         case SkCanvas::kBGRA_Premul_Config8888:
         238                 :             config8888_copy_to_bitmap<false, 3, 2, 1, 0> (
         239               0 :                                     dstBmp, srcPixels, srcRowBytes);
         240               0 :             break;
         241                 :         case SkCanvas::kBGRA_Unpremul_Config8888:
         242                 :             config8888_copy_to_bitmap<true, 3, 2, 1, 0> (
         243               0 :                                     dstBmp, srcPixels, srcRowBytes);
         244               0 :             break;
         245                 :         case SkCanvas::kRGBA_Premul_Config8888:
         246                 :             config8888_copy_to_bitmap<false, 3, 0, 1, 2> (
         247               0 :                                     dstBmp, srcPixels, srcRowBytes);
         248               0 :             break;
         249                 :         case SkCanvas::kRGBA_Unpremul_Config8888:
         250                 :             config8888_copy_to_bitmap<true, 3, 0, 1, 2> (
         251               0 :                                     dstBmp, srcPixels, srcRowBytes);
         252               0 :             break;
         253                 :         default:
         254               0 :             SkDEBUGFAIL("unexpected Config8888");
         255               0 :             break;
         256                 :     }
         257               0 : }
         258                 :
         259               0 : inline void SkCopyARGB8888BitmapTo(uint32_t* dstPixels,
         260                 :                                    size_t dstRowBytes,
         261                 :                                    const SkBitmap& srcBmp) {
         262               0 :     SkASSERT(SkBitmap::kARGB_8888_Config == srcBmp.config());
         263                 :
         264               0 :     SkAutoLockPixels alp(srcBmp);
         265                 :
         266               0 :     int w = srcBmp.width();
         267               0 :     int h = srcBmp.height();
         268               0 :     size_t srcRowBytes = srcBmp.rowBytes();
         269                 :
         270               0 :     size_t tightRowBytes = w * 4;
         271                 :
         272               0 :     char* src = reinterpret_cast<char*>(srcBmp.getPixels());
         273               0 :     char* dst = reinterpret_cast<char*>(dstPixels);
         274                 :
         275               0 :     if (tightRowBytes == srcRowBytes &&
         276                 :         tightRowBytes == dstRowBytes) {
         277               0 :         memcpy(dst, src, tightRowBytes * h);
         278                 :     } else {
         279               0 :         for (int y = 0; y < h; ++y) {
         280               0 :             memcpy(dst, src, tightRowBytes);
         281               0 :             dst += dstRowBytes;
         282               0 :             src += srcRowBytes;
         283                 :         }
         284                 :     }
         285               0 : }
         286                 :
         287                 : }

Generated by: LCOV version 1.7