Initial work to get ETC1 data up to the GPU

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 "SkColorFilter.h"
 #include "SkConfig8888.h"
+#include "SkData.h"
 #include "SkMessageBus.h"
 #include "SkPixelRef.h"
 #include "GrResourceCache.h"
+#include "GrGpu.h"
+#include "GrDrawTargetCaps.h"
+
+#include "etc1.h"
 
 /*  Fill out buffer with the compressed format Ganesh expects from a colortable
  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
@@ skipping 141 matching lines @@
                                     bitmap->height(), desc.fConfig,
                                     storage.get());
                 return result;
             }
         } else {
             origBitmap.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 (cache && ctx->getGpu()->caps()->compressedTextureSupport(kETC1_GrCompressedFormat)) {
+        SkData *data = bitmap->pixelRef()->refEncodedData();

[robertphillips, 2014/05/27 22:01:50]

hmmm

+        do {
+            // Is this even encoded data?

[robertphillips, 2014/05/27 22:01:50]

NULL == data ?

[krajcevski, 2014/05/27 22:19:29]

Done.

+            if (!data) {
+                break;
+            }
+
+            // Is this a valid PKM encoded data?
+            const uint8_t *bytes = data->bytes();
+            if (!etc1_pkm_is_valid(bytes)) {
+                break;
+            }
+
+            uint32_t encodedWidth = etc1_pkm_get_width(bytes);
+            uint32_t encodedHeight = etc1_pkm_get_height(bytes);
+
+            // Does the data match the dimensions of the bitmap? If not,
+            // then we don't know how to scale the image to match it...
+            if (encodedWidth != static_cast<uint32_t>(bitmap->width()) ||
+                encodedHeight != static_cast<uint32_t>(bitmap->height())) {
+                break;
+            }
+
+            // Everything seems good... skip ahead to the data.
+            bytes += ETC_PKM_HEADER_SIZE;
+
+            // This texture is likely to be used again so leave it in the cache
+            GrCacheID cacheID;
+            generate_bitmap_cache_id(origBitmap, &cacheID);
+
+            GrResourceKey key;
+            GrTexture* result =
+                ctx->createCompressedTexture(params, desc, cacheID,
+                                             bytes, kETC1_GrCompressedFormat, &key);
+            if (NULL != result) {
+                add_genID_listener(key, origBitmap.pixelRef());
+            }
+            return result;
+
+        } while(0);
     }
 
     SkAutoLockPixels alp(*bitmap);
     if (!bitmap->readyToDraw()) {
         return NULL;
     }
     if (cache) {
         // This texture is likely to be used again so leave it in the cache
         GrCacheID cacheID;
         generate_bitmap_cache_id(origBitmap, &cacheID);
@@ skipping 247 matching lines @@
             copy.setShader(NULL);
             // modulate the paint alpha by the shader's solid color alpha
             U8CPU newA = SkMulDiv255Round(SkColorGetA(color), copy.getAlpha());
             copy.setColor(SkColorSetA(color, newA));
             SkPaint2GrPaintNoShader(context, copy, false, constantColor, grPaint);
         } else {
             SkPaint2GrPaintNoShader(context, skPaint, false, constantColor, grPaint);
         }
     }
 }