TBR=robertphillips@google.com

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 "SkGrPriv.h"
 
 #include "GrCaps.h"
 #include "GrContext.h"
 #include "GrGpuResourcePriv.h"
 #include "GrImageIDTextureAdjuster.h"
 #include "GrTextureParamsAdjuster.h"
 #include "GrTypes.h"
 #include "GrXferProcessor.h"
 #include "GrYUVProvider.h"
 
@@ skipping 94 matching lines @@
  * based bitmap. [palette (colortable) + indices].
  *
  * At the moment Ganesh only supports 8bit version. If Ganesh allowed we others
  * we could detect that the colortable.count is <= 16, and then repack the
  * indices as nibbles to save RAM, but it would take more time (i.e. a lot
  * slower than memcpy), so skipping that for now.
  *
  * Ganesh wants a full 256 palette entry, even though Skia's ctable is only as big
  * as the colortable.count says it is.
  */
-static void build_index8_data(void* buffer, const SkPixmap& pixmap) {
-    SkASSERT(kIndex_8_SkColorType == pixmap.colorType());
+static void build_index8_data(void* buffer, const SkBitmap& bitmap) {
+    SkASSERT(kIndex_8_SkColorType == bitmap.colorType());
 
-    const SkColorTable* ctable = pixmap.ctable();
+    SkAutoLockPixels alp(bitmap);
+    if (!bitmap.readyToDraw()) {
+        SkDEBUGFAIL("bitmap not ready to draw!");
+        return;
+    }
+
+    SkColorTable* ctable = bitmap.getColorTable();
     char* dst = (char*)buffer;
 
     const int count = ctable->count();
 
     SkDstPixelInfo dstPI;
     dstPI.fColorType = kRGBA_8888_SkColorType;
     dstPI.fAlphaType = kPremul_SkAlphaType;
     dstPI.fPixels = buffer;
     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);
 
     // always skip a full 256 number of entries, even if we memcpy'd fewer
     dst += 256 * sizeof(GrColor);
 
-    if ((unsigned)pixmap.width() == pixmap.rowBytes()) {
-        memcpy(dst, pixmap.addr(), pixmap.getSafeSize());
+    if ((unsigned)bitmap.width() == bitmap.rowBytes()) {
+        memcpy(dst, bitmap.getPixels(), bitmap.getSize());
     } else {
         // need to trim off the extra bytes per row
-        size_t width = pixmap.width();
-        size_t rowBytes = pixmap.rowBytes();
-        const uint8_t* src = pixmap.addr8();
-        for (int y = 0; y < pixmap.height(); y++) {
+        size_t width = bitmap.width();
+        size_t rowBytes = bitmap.rowBytes();
+        const char* src = (const char*)bitmap.getPixels();
+        for (int y = 0; y < bitmap.height(); y++) {
             memcpy(dst, src, width);
             src += rowBytes;
             dst += width;
         }
     }
 }
 
 /**
  *  Once we have made SkImages handle all lazy/deferred/generated content, the YUV apis will
  *  be gone from SkPixelRef, and we can remove this subclass entirely.
@@ skipping 38 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, SkBudgeted::kYes, startOfTexData, 0);
 }
 
-GrTexture* GrUploadBitmapToTexture(GrContext* ctx, const SkBitmap& bitmap) {
-    GrSurfaceDesc desc = GrImageInfoToSurfaceDesc(bitmap.info());
-    if (GrTexture *texture = load_etc1_texture(ctx, bitmap, desc)) {
-        return texture;
-    }
+GrTexture* GrUploadBitmapToTexture(GrContext* ctx, const SkBitmap& bmp) {
+    SkASSERT(!bmp.getTexture());
 
-    if (GrTexture* texture = create_texture_from_yuv(ctx, bitmap, desc)) {
-        return texture;
-    }
+    SkBitmap tmpBitmap;
+    const SkBitmap* bitmap = &bmp;
 
-    SkAutoLockPixels alp(bitmap);
-    if (!bitmap.readyToDraw()) {
-        return nullptr;
-    }
-    SkPixmap pixmap;
-    if (!bitmap.peekPixels(&pixmap)) {
-        return nullptr;
-    }
-    return GrUploadPixmapToTexture(ctx, pixmap);
-}
-
-GrTexture* GrUploadPixmapToTexture(GrContext* ctx, const SkPixmap& pixmap) {
-    const SkPixmap* pmap = &pixmap;
-    SkPixmap tmpPixmap;
-    SkBitmap tmpBitmap;
-
-    GrSurfaceDesc desc = GrImageInfoToSurfaceDesc(pixmap.info());
+    GrSurfaceDesc desc = GrImageInfoToSurfaceDesc(bitmap->info());
     const GrCaps* caps = ctx->caps();
 
-    if (kIndex_8_SkColorType == pixmap.colorType()) {
+    if (kIndex_8_SkColorType == bitmap->colorType()) {
         if (caps->isConfigTexturable(kIndex_8_GrPixelConfig)) {
             size_t imageSize = GrCompressedFormatDataSize(kIndex_8_GrPixelConfig,
-                                                          pixmap.width(), pixmap.height());
+                                                          bitmap->width(), bitmap->height());
             SkAutoMalloc storage(imageSize);
-            build_index8_data(storage.get(), pixmap);
+            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, SkBudgeted::kYes, storage.get(),
-                                                         pixmap.width());
+                                                         bitmap->width());
         } else {
-            SkImageInfo info = SkImageInfo::MakeN32Premul(pixmap.width(), pixmap.height());
-            tmpBitmap.allocPixels(info);
-            if (!pixmap.readPixels(info, tmpBitmap.getPixels(), tmpBitmap.rowBytes())) {
-                return nullptr;
-            }
-            if (!tmpBitmap.peekPixels(&tmpPixmap)) {
-                return nullptr;
-            }
-            pmap = &tmpPixmap;
-            // must rebuild desc, since we've forced the info to be N32
-            desc = GrImageInfoToSurfaceDesc(pmap->info());
+            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.
+
+        // Really?? We aren't doing this with YUV.
+
+        GrTexture *texture = load_etc1_texture(ctx, *bitmap, desc);
+        if (texture) {
+            return texture;
         }
     }
 
-    return ctx->textureProvider()->createTexture(desc, SkBudgeted::kYes, pmap->addr(),
-                                                 pmap->rowBytes());
+    GrTexture *texture = create_texture_from_yuv(ctx, *bitmap, desc);
+    if (texture) {
+        return texture;
+    }
+
+    SkAutoLockPixels alp(*bitmap);
+    if (!bitmap->readyToDraw()) {
+        return nullptr;
+    }
+
+    return ctx->textureProvider()->createTexture(desc, SkBudgeted::kYes, bitmap->getPixels(),
+                                                 bitmap->rowBytes());
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 
 void GrInstallBitmapUniqueKeyInvalidator(const GrUniqueKey& key, SkPixelRef* pixelRef) {
     class Invalidator : public SkPixelRef::GenIDChangeListener {
     public:
         explicit Invalidator(const GrUniqueKey& key) : fMsg(key) {}
     private:
@@ skipping 413 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;
 }