Creating functions for uploading a mipmapped texture.

src/gpu/GrGpu.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 "GrGpu.h"
 
@@ skipping 78 matching lines @@
     // By default, GrRenderTargets are GL's normal orientation so that they
     // can be drawn to by the outside world without the client having
     // to render upside down.
     if (kDefault_GrSurfaceOrigin == origin) {
         return renderTarget ? kBottomLeft_GrSurfaceOrigin : kTopLeft_GrSurfaceOrigin;
     } else {
         return origin;
     }
 }
 
-GrTexture* GrGpu::createTexture(const GrSurfaceDesc& origDesc, bool budgeted,
-                                const void* srcData, size_t rowBytes) {
-    GrSurfaceDesc desc = origDesc;
-
-    if (!this->caps()->isConfigTexturable(desc.fConfig)) {
-        return nullptr;
+/**
+ * Prior to creating a texture, make sure the type of texture being created is
+ * supported by calling check_texture_creation_params.
+ *
+ * @param caps The capabilities of the GL device.
+ * @param desc The descriptor of the texture to create.
+ * @param isRT Indicates if the texture can be a render target.
+ */
+static bool check_texture_creation_params(const GrCaps& caps, const GrSurfaceDesc& desc,
+                                          bool* isRT) {
+    if (!caps.isConfigTexturable(desc.fConfig)) {
+        return false;
     }
 
-    bool isRT = SkToBool(desc.fFlags & kRenderTarget_GrSurfaceFlag);
-    if (isRT && !this->caps()->isConfigRenderable(desc.fConfig, desc.fSampleCnt > 0)) {
-        return nullptr;
+    *isRT = SkToBool(desc.fFlags & kRenderTarget_GrSurfaceFlag);
+    if (*isRT && !caps.isConfigRenderable(desc.fConfig, desc.fSampleCnt > 0)) {
+        return false;
     }
 
     // We currently do not support multisampled textures
-    if (!isRT && desc.fSampleCnt > 0) {
-        return nullptr;
+    if (!*isRT && desc.fSampleCnt > 0) {
+        return false;
     }
 
-    GrTexture *tex = nullptr;
-
-    if (isRT) {
-        int maxRTSize = this->caps()->maxRenderTargetSize();
+    if (*isRT) {
+        int maxRTSize = caps.maxRenderTargetSize();
         if (desc.fWidth > maxRTSize || desc.fHeight > maxRTSize) {
-            return nullptr;
+            return false;
         }
     } else {
-        int maxSize = this->caps()->maxTextureSize();
+        int maxSize = caps.maxTextureSize();
         if (desc.fWidth > maxSize || desc.fHeight > maxSize) {
-            return nullptr;
+            return false;
         }
     }
+    return true;
+}
 
-    GrGpuResource::LifeCycle lifeCycle = budgeted ? GrGpuResource::kCached_LifeCycle :
-                                                    GrGpuResource::kUncached_LifeCycle;
+GrTexture* GrGpu::createTexture(const GrSurfaceDesc& origDesc, bool budgeted,
+                                const SkTArray<SkMipMapLevel>& texels) {
+    GrSurfaceDesc desc = origDesc;
 
-    desc.fSampleCnt = SkTMin(desc.fSampleCnt, this->caps()->maxSampleCount());
-    // Attempt to catch un- or wrongly initialized sample counts;
-    SkASSERT(desc.fSampleCnt >= 0 && desc.fSampleCnt <= 64);
-
-    desc.fOrigin = resolve_origin(desc.fOrigin, isRT);
-
-    if (GrPixelConfigIsCompressed(desc.fConfig)) {
-        // We shouldn't be rendering into this
-        SkASSERT(!isRT);
-        SkASSERT(0 == desc.fSampleCnt);
-
-        if (!this->caps()->npotTextureTileSupport() &&
-            (!SkIsPow2(desc.fWidth) || !SkIsPow2(desc.fHeight))) {
+    const GrCaps* caps = this->caps();
+    if (!caps) {
+        return nullptr;
+    } else {
+        bool isRT = false;
+        bool textureCreationParamsValid = check_texture_creation_params(*caps, desc, &isRT);
+        if (!textureCreationParamsValid) {
             return nullptr;
         }
 
-        this->handleDirtyContext();
-        tex = this->onCreateCompressedTexture(desc, lifeCycle, srcData);
-    } else {
-        this->handleDirtyContext();
-        tex = this->onCreateTexture(desc, lifeCycle, srcData, rowBytes);
+        desc.fSampleCnt = SkTMin(desc.fSampleCnt, caps->maxSampleCount());
+        // Attempt to catch un- or wrongly intialized sample counts;
+        SkASSERT(desc.fSampleCnt >= 0 && desc.fSampleCnt <= 64);
+
+        desc.fOrigin = resolve_origin(desc.fOrigin, isRT);
+
+        GrTexture* tex = nullptr;
+        GrGpuResource::LifeCycle lifeCycle = budgeted ? GrGpuResource::kCached_LifeCycle :
+                                                        GrGpuResource::kUncached_LifeCycle;
+
+        if (GrPixelConfigIsCompressed(desc.fConfig)) {
+            // We shouldn't be rendering into this
+            SkASSERT(!isRT);
+            SkASSERT(0 == desc.fSampleCnt);
+
+            if (!caps->npotTextureTileSupport() &&
+                (!SkIsPow2(desc.fWidth) || !SkIsPow2(desc.fHeight))) {
+                return nullptr;
+            }
+
+            this->handleDirtyContext();
+            tex = this->onCreateCompressedTexture(desc, lifeCycle, texels);
+        } else {
+            this->handleDirtyContext();
+            tex = this->onCreateTexture(desc, lifeCycle, texels);
+        }
+        if (tex) {
+            if (!caps->reuseScratchTextures() && !isRT) {
+                tex->resourcePriv().removeScratchKey();
+            }
+            fStats.incTextureCreates();
+            if (!texels.empty()) {
+                if (texels[0].fTexels) {
+                    fStats.incTextureUploads();
+                }
+            }
+        }
+        return tex;
     }
-    if (!this->caps()->reuseScratchTextures() && !isRT) {
-        tex->resourcePriv().removeScratchKey();
+}
+
+GrTexture* GrGpu::createTexture(const GrSurfaceDesc& desc, bool budgeted,
+                                const void* srcData, size_t rowBytes) {
+    const int width = desc.fWidth;
+    const int height = desc.fHeight;
+    if (width <= 0 || height <= 0) {
+        return nullptr;
     }
-    if (tex) {
-        fStats.incTextureCreates();
-        if (srcData) {
-            fStats.incTextureUploads();
-        }
-    }
-    return tex;
+    const uint32_t baseLevelWidth = width;
+    const uint32_t baseLevelHeight = height;
+
+    SkMipMapLevel level(srcData, rowBytes, baseLevelWidth, baseLevelHeight);
+    const int mipLevelCount = 1;
+    SkTArray<SkMipMapLevel> levels(mipLevelCount);
+    levels.push_back(level);
+
+    return this->createTexture(desc, budgeted, levels);
 }
 
 GrTexture* GrGpu::wrapBackendTexture(const GrBackendTextureDesc& desc, GrWrapOwnership ownership) {
     this->handleDirtyContext();
     GrTexture* tex = this->onWrapBackendTexture(desc, ownership);
     if (nullptr == tex) {
         return nullptr;
     }
     // TODO: defer this and attach dynamically
     GrRenderTarget* tgt = tex->asRenderTarget();
@@ skipping 77 matching lines @@
         !this->caps()->isConfigRenderable(tempDrawInfo->fTempSurfaceDesc.fConfig, false)) {
         // If we don't have a fallback to a straight read then fail.
         if (kRequireDraw_DrawPreference == *drawPreference) {
             return false;
         }
         *drawPreference = kNoDraw_DrawPreference;
     }
 
     return true;
 }
-bool GrGpu::getWritePixelsInfo(GrSurface* dstSurface, int width, int height, size_t rowBytes,
+bool GrGpu::getWritePixelsInfo(GrSurface* dstSurface, int width, int height,
                                GrPixelConfig srcConfig, DrawPreference* drawPreference,
                                WritePixelTempDrawInfo* tempDrawInfo) {
     SkASSERT(drawPreference);
     SkASSERT(tempDrawInfo);
     SkASSERT(kGpuPrefersDraw_DrawPreference != *drawPreference);
 
     if (GrPixelConfigIsCompressed(dstSurface->desc().fConfig) &&
         dstSurface->desc().fConfig != srcConfig) {
         return false;
     }
 
     if (this->caps()->useDrawInsteadOfPartialRenderTargetWrite() &&
         SkToBool(dstSurface->asRenderTarget()) &&
         (width < dstSurface->width() || height < dstSurface->height())) {
         ElevateDrawPreference(drawPreference, kRequireDraw_DrawPreference);
     }
 
-    if (!this->onGetWritePixelsInfo(dstSurface, width, height, rowBytes, srcConfig, drawPreference,
+    if (!this->onGetWritePixelsInfo(dstSurface, width, height, srcConfig, drawPreference,
                                     tempDrawInfo)) {
         return false;
     }
 
     // Check to see if we're going to request that the caller draw when drawing is not possible.
     if (!dstSurface->asRenderTarget() ||
         !this->caps()->isConfigTexturable(tempDrawInfo->fTempSurfaceDesc.fConfig)) {
         // If we don't have a fallback to a straight upload then fail.
         if (kRequireDraw_DrawPreference == *drawPreference ||
             !this->caps()->isConfigTexturable(srcConfig)) {
@@ skipping 24 matching lines @@
     }
 
     return this->onReadPixels(surface,
                               left, top, width, height,
                               config, buffer,
                               rowBytes);
 }
 
 bool GrGpu::writePixels(GrSurface* surface,
                         int left, int top, int width, int height,
-                        GrPixelConfig config, const void* buffer,
-                        size_t rowBytes) {
-    if (!buffer) {
-        return false;
-    }
-
+                        GrPixelConfig config, const SkTArray<SkMipMapLevel>& texels) {
     this->handleDirtyContext();
-    if (this->onWritePixels(surface, left, top, width, height, config, buffer, rowBytes)) {
+    if (this->onWritePixels(surface, left, top, width, height, config, texels)) {
         fStats.incTextureUploads();
         return true;
     }
     return false;
 }
 
+bool GrGpu::writePixels(GrSurface* surface,
+                        int left, int top, int width, int height,
+                        GrPixelConfig config, const void* buffer,
+                        size_t rowBytes) {
+    if (width <= 0 || height <= 0) {
+        return false;
+    }
+    const uint32_t baseLevelWidth = width;
+    const uint32_t baseLevelHeight = height;
+
+    SkMipMapLevel mipLevel(buffer, rowBytes, baseLevelWidth, baseLevelHeight);
+    const int mipLevelCount = 1;
+    SkTArray<SkMipMapLevel> texels(mipLevelCount);
+    texels.push_back(mipLevel);
+
+    return this->writePixels(surface, left, top, width, height, config, texels);
+}
+
 void GrGpu::resolveRenderTarget(GrRenderTarget* target) {
     SkASSERT(target);
     this->handleDirtyContext();
     this->onResolveRenderTarget(target);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 void GrGpu::draw(const DrawArgs& args, const GrVertices& vertices) {
     this->handleDirtyContext();
     if (GrXferBarrierType barrierType = args.fPipeline->xferBarrierType(*this->caps())) {
         this->xferBarrier(args.fPipeline->getRenderTarget(), barrierType);
     }
 
     GrVertices::Iterator iter;
     const GrNonInstancedVertices* verts = iter.init(vertices);
     do {
         this->onDraw(args, *verts);
         fStats.incNumDraws();
     } while ((verts = iter.next()));
 }