Creating functions for uploading a mipmapped texture.

src/gpu/GrTextureProvider.cpp

-
 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrTextureProvider.h"
 #include "GrTexturePriv.h"
 #include "GrResourceCache.h"
 #include "GrGpu.h"
 
 enum ScratchTextureFlags {
     kExact_ScratchTextureFlag           = 0x1,
     kNoPendingIO_ScratchTextureFlag     = 0x2,
     kNoCreate_ScratchTextureFlag        = 0x4,
 };
 
 GrTexture* GrTextureProvider::createTexture(const GrSurfaceDesc& desc, bool budgeted,
-                                            const void* srcData, size_t rowBytes) {
+                                            const SkTArray<SkMipMapLevel>& texels) {
     if (this->isAbandoned()) {
         return nullptr;
     }
     if ((desc.fFlags & kRenderTarget_GrSurfaceFlag) &&
         !fGpu->caps()->isConfigRenderable(desc.fConfig, desc.fSampleCnt > 0)) {
         return nullptr;
     }
     if (!GrPixelConfigIsCompressed(desc.fConfig)) {
         static const uint32_t kFlags = kExact_ScratchTextureFlag |
                                        kNoCreate_ScratchTextureFlag;
         if (GrTexture* texture = this->refScratchTexture(desc, kFlags)) {
-            if (!srcData || texture->writePixels(0, 0, desc.fWidth, desc.fHeight, desc.fConfig,
-                                                 srcData, rowBytes)) {
+            if (texture->writePixels(0, 0, desc.fWidth, desc.fHeight, desc.fConfig,
+                                     texels)) {
                 if (!budgeted) {
                     texture->resourcePriv().makeUnbudgeted();
                 }
                 return texture;
             }
             texture->unref();
         }
     }
-    return fGpu->createTexture(desc, budgeted, srcData, rowBytes);
+    return fGpu->createTexture(desc, budgeted, texels);
+}
+
+GrTexture* GrTextureProvider::createTexture(const GrSurfaceDesc& desc, bool budgeted,
+                                            const void* srcData, size_t rowBytes) {
+    const int height = desc.fHeight;
+    const int width = desc.fWidth;
+    if (height < 0 || width < 0) {
+        return nullptr;
+    }
+    const uint32_t baseLevelHeight = height;
+    const uint32_t baseLevelWidth = width;
+
+    SkMipMapLevel level(srcData, rowBytes, baseLevelWidth, baseLevelHeight);
+    const int mipLevelCount = 1;
+    SkTArray<SkMipMapLevel> texels(mipLevelCount);
+    texels.push_back(level);
+
+    return this->createTexture(desc, budgeted, texels);
 }
 
 GrTexture* GrTextureProvider::createApproxTexture(const GrSurfaceDesc& desc) {
     return this->internalCreateApproxTexture(desc, 0);
 }
 
 GrTexture* GrTextureProvider::internalCreateApproxTexture(const GrSurfaceDesc& desc,
                                                           uint32_t scratchFlags) {
     if (this->isAbandoned()) {
         return nullptr;
@@ skipping 72 matching lines @@
     resource->resourcePriv().setUniqueKey(key);
 }
 
 bool GrTextureProvider::existsResourceWithUniqueKey(const GrUniqueKey& key) const {
     return this->isAbandoned() ? false : fCache->hasUniqueKey(key);
 }
 
 GrGpuResource* GrTextureProvider::findAndRefResourceByUniqueKey(const GrUniqueKey& key) {
     return this->isAbandoned() ? nullptr : fCache->findAndRefUniqueResource(key);
 }