Index8 GPU and CPU raster support.

src/gpu/SkGr.cpp

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 
 #include "SkGr.h"
 
 #include "GrCaps.h"
 #include "GrContext.h"
+#include "GrDrawContext.h"
 #include "GrTextureParamsAdjuster.h"
 #include "GrGpuResourcePriv.h"
 #include "GrImageIDTextureAdjuster.h"
 #include "GrXferProcessor.h"
 #include "GrYUVProvider.h"
 
 #include "SkColorFilter.h"
 #include "SkConfig8888.h"
 #include "SkCanvas.h"
 #include "SkData.h"
 #include "SkErrorInternals.h"
 #include "SkGrPixelRef.h"
 #include "SkMessageBus.h"
 #include "SkPixelRef.h"
 #include "SkResourceCache.h"
 #include "SkTextureCompressor.h"
 #include "SkYUVPlanesCache.h"
 #include "effects/GrBicubicEffect.h"
 #include "effects/GrConstColorProcessor.h"
 #include "effects/GrDitherEffect.h"
 #include "effects/GrPorterDuffXferProcessor.h"
 #include "effects/GrXfermodeFragmentProcessor.h"
 #include "effects/GrYUVtoRGBEffect.h"
+#include "effects/GrIndex8toRGBEffect.h"
 
 #ifndef SK_IGNORE_ETC1_SUPPORT
 #  include "ktx.h"
 #  include "etc1.h"
 #endif
 
 GrSurfaceDesc GrImageInfoToSurfaceDesc(const SkImageInfo& info) {
     GrSurfaceDesc desc;
     desc.fFlags = kNone_GrSurfaceFlags;
     desc.fWidth = info.width();
@@ skipping 162 matching lines @@
     const void* startOfTexData;
     desc.fConfig = GrIsCompressedTextureDataSupported(ctx, data, bm.width(), bm.height(),
                                                       &startOfTexData);
     if (kUnknown_GrPixelConfig == desc.fConfig) {
         return nullptr;
     }
 
     return ctx->textureProvider()->createTexture(desc, true, startOfTexData, 0);
 }
 
+static GrTexture* create_texture_from_index8(GrContext* ctx, const SkBitmap& bm,
+                                             const GrSurfaceDesc& desc) {
+    SkAutoLockPixels alp(bm);
+    if (!bm.readyToDraw()) {
+        return nullptr;
+    }
+
+    GrSurfaceDesc indicesDesc = desc;
+    indicesDesc.fConfig = kAlpha_8_GrPixelConfig;
+    SkAutoTUnref<GrTexture> tex(ctx->textureProvider()->
+                                createTexture(indicesDesc, true, bm.getPixels(), bm.rowBytes()));
+
+    SkAutoTUnref<GrTexture> colorTableTexture;
+    const SkImageInfo info = SkImageInfo::Make(256, 1, kRGBA_8888_SkColorType, kPremul_SkAlphaType);
+    GrSurfaceDesc colorTableDesc = GrImageInfoToSurfaceDesc(info);
+    SkColorTable* ctable = bm.getColorTable();
+    const int count = ctable->count();
+    if (count != 256 || kN32_SkColorType != kRGBA_8888_SkColorType) {

[aleksandar.stojiljkovic, 2015/12/03 13:30:49]

Not happy with this one - might make sense to use N32 always also for target
surface.

+        // Allocate 256 color array for palette and fill it with converted N32->RGBA colors.
+        SkPMColor fullTable[256] = { 0 };
+        SkDstPixelInfo dstPI;
+        dstPI.fColorType = kRGBA_8888_SkColorType;
+        dstPI.fAlphaType = kPremul_SkAlphaType;
+        dstPI.fPixels = fullTable;
+        dstPI.fRowBytes = count * sizeof(SkPMColor);
+
+        SkSrcPixelInfo srcPI;
+        srcPI.fColorType = kN32_SkColorType;
+        srcPI.fAlphaType = kPremul_SkAlphaType;
+        srcPI.fPixels = ctable->readColors();
+        srcPI.fRowBytes = count * sizeof(SkPMColor);
+
+        srcPI.convertPixelsTo(&dstPI, count, 1);
+
+        colorTableTexture.reset(ctx->textureProvider()->
+            createTexture(colorTableDesc, true, fullTable, sizeof(SkPMColor) * 256));
+    } else {
+        colorTableTexture.reset(ctx->textureProvider()->
+            createTexture(colorTableDesc, true, ctable->readColors(), sizeof(SkPMColor) * 256));
+    }
+
+
+    GrSurfaceDesc rDesc = desc;
+    rDesc.fFlags = rDesc.fFlags | kRenderTarget_GrSurfaceFlag;
+    rDesc.fConfig = kRGBA_8888_GrPixelConfig;
+
+    SkAutoTUnref<GrTexture> result(ctx->textureProvider()->createTexture(rDesc, true, nullptr, 0));
+    if (!result) {
+        return nullptr;
+    }
+
+    GrRenderTarget* renderTarget = result->asRenderTarget();
+    SkASSERT(renderTarget);
+
+    GrPaint paint;
+    SkMatrix textureMatrix;
+    textureMatrix.setTranslate(0, 0);
+    textureMatrix.postIDiv(bm.width(), bm.height());
+    SkAutoTUnref<GrFragmentProcessor> index8ToRgbProcessor(
+        GrIndex8toRGBEffect::Create(tex, colorTableTexture, textureMatrix));
+    paint.addColorFragmentProcessor(index8ToRgbProcessor);
+    const SkRect r = SkRect::MakeIWH(desc.fWidth, desc.fHeight);
+
+    SkAutoTUnref<GrDrawContext> drawContext(ctx->drawContext(renderTarget));
+    if (!drawContext) {
+        return nullptr;
+    }
+
+    drawContext->drawRect(GrClip::WideOpen(), paint, SkMatrix::I(), r);
+
+    return result.detach();
+}
+
 GrTexture* GrUploadBitmapToTexture(GrContext* ctx, const SkBitmap& bmp) {
     SkASSERT(!bmp.getTexture());
 
     SkBitmap tmpBitmap;
     const SkBitmap* bitmap = &bmp;
 
     GrSurfaceDesc desc = GrImageInfoToSurfaceDesc(bitmap->info());
     const GrCaps* caps = ctx->caps();
 
     if (kIndex_8_SkColorType == bitmap->colorType()) {
         if (caps->isConfigTexturable(kIndex_8_GrPixelConfig)) {

[aleksandar.stojiljkovic, 2015/12/03 13:30:49]

Based on my previous finding with Mali and Adrenos,
OES_compressed_paletted_texture is slower than uploading RGBA, indicating that
it is not implemented in silicon. After measurements, propose to remove this and
always use else branch.

             size_t imageSize = GrCompressedFormatDataSize(kIndex_8_GrPixelConfig,
                                                           bitmap->width(), bitmap->height());
             SkAutoMalloc storage(imageSize);
             build_index8_data(storage.get(), bmp);
 
             // our compressed data will be trimmed, so pass width() for its
             // "rowBytes", since they are the same now.
             return ctx->textureProvider()->createTexture(desc, true, storage.get(),
                                                          bitmap->width());
         } else {
+            if (GrTexture* tex = create_texture_from_index8(ctx, bmp, desc))
+                return tex;
             bmp.copyTo(&tmpBitmap, kN32_SkColorType);
             // now bitmap points to our temp, which has been promoted to 32bits
             bitmap = &tmpBitmap;
             desc.fConfig = SkImageInfo2GrPixelConfig(bitmap->info());
         }
     } else if (!bitmap->readyToDraw()) {
         // If the bitmap had compressed data and was then uncompressed, it'll still return
         // compressed data on 'refEncodedData' and upload it. Probably not good, since if
         // the bitmap has available pixels, then they might not be what the decompressed
         // data is.
@@ skipping 406 matching lines @@
             SkErrorInternals::SetError( kInvalidPaint_SkError,
                                         "Sorry, I don't understand the filtering "
                                         "mode you asked for.  Falling back to "
                                         "MIPMaps.");
             textureFilterMode = GrTextureParams::kMipMap_FilterMode;
             break;
 
     }
     return textureFilterMode;
 }