Creating functions for uploading a mipmapped texture.

include/gpu/GrContext.h

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrContext_DEFINED
 #define GrContext_DEFINED
 
 #include "GrClip.h"
 #include "GrColor.h"
 #include "GrPaint.h"
 #include "GrPathRendererChain.h"
 #include "GrRenderTarget.h"
 #include "GrTextureProvider.h"
 #include "SkMatrix.h"
-#include "SkMutex.h"
+#include "../private/SkMutex.h"
+#include "SkMipMapLevel.h"
 #include "SkPathEffect.h"
+#include "SkTArray.h"
 #include "SkTypes.h"
 
 struct GrBatchAtlasConfig;
 class GrBatchFontCache;
 class GrCaps;
 struct GrContextOptions;
 class GrDrawContext;
 class GrDrawTarget;
 class GrFragmentProcessor;
 class GrGpu;
@@ skipping 138 matching lines @@
      *         rendering quality for the display. Alternatively returns 0 if
      *         MSAA is not supported or recommended to be used by default.
      */
     int getRecommendedSampleCount(GrPixelConfig config, SkScalar dpi) const;
 
     /**
      * Returns a helper object to orchestrate draws.
      * Callers should take a ref if they rely on the GrDrawContext sticking around.
      * NULL will be returned if the context has been abandoned.
      *
+     * @param  rt           the render target receiving the draws
      * @param  surfaceProps the surface properties (mainly defines text drawing)
      *
      * @return a draw context
      */
-    GrDrawContext* drawContext(const SkSurfaceProps* surfaceProps = NULL) {
-        return fDrawingMgr.drawContext(surfaceProps);
+    GrDrawContext* drawContext(GrRenderTarget* rt, const SkSurfaceProps* surfaceProps = NULL) {

[bsalomon, 2015/10/19 14:56:18]

Is this supposed to be showing up in the diff? Looks like this is from a
different change that already landed.

+        return fDrawingMgr.drawContext(rt, surfaceProps);
+    }
+
+    GrTextContext* textContext(const SkSurfaceProps& surfaceProps, GrRenderTarget* rt) {
+        return fDrawingMgr.textContext(surfaceProps, rt);
     }
 
     ///////////////////////////////////////////////////////////////////////////
     // Misc.
 
     /**
      * Flags that affect flush() behavior.
      */
     enum FlushBits {
         /**
@@ skipping 57 matching lines @@
                            uint32_t pixelOpsFlags = 0);
 
     /**
      * Writes a rectangle of pixels to a surface.
      * @param surface       the surface to write to.
      * @param left          left edge of the rectangle to write (inclusive)
      * @param top           top edge of the rectangle to write (inclusive)
      * @param width         width of rectangle to write in pixels.
      * @param height        height of rectangle to write in pixels.
      * @param config        the pixel config of the source buffer
-     * @param buffer        memory to read pixels from
-     * @param rowBytes      number of bytes between consecutive rows. Zero
-     *                      means rows are tightly packed.
+     * @param texels        array of mipmap levels containing texel data to load.
+     *                      Begins with full-sized palette data for paletted textures.
+     *                      For compressed formats it contains the compressed pixel data.
+     *                      Otherwise, it contains width*height texels. If the array is empty,
+     *                      texture data is uninitialized.
      * @param pixelOpsFlags see PixelOpsFlags enum above.
+     *
      * @return true if the write succeeded, false if not. The write can fail because of an
      *         unsupported combination of surface and src configs.
      */
     bool writeSurfacePixels(GrSurface* surface,
                             int left, int top, int width, int height,
+                            GrPixelConfig config, const SkTArray<SkMipMapLevel>& texels,
+                            uint32_t pixelOpsFlags = 0);
+
+    /**
+     * This function is a shim which creates a SkTArray<SkMipMapLevel> of size 1.
+     * It then calls writeSurfacePixels with that SkTArray.
+     *
+     * @param buffer    Pointer to the pixel values (optional).
+     * @param rowBytes  The number of bytes between rows of the texture. Zero
+     *                  implies tightly packed rows. For compressed pixel configs, this
+     *                  field is ignored.
+     */
+    bool writeSurfacePixels(GrSurface* surface,
+                            int left, int top, int width, int height,
                             GrPixelConfig config, const void* buffer,
                             size_t rowBytes,
                             uint32_t pixelOpsFlags = 0);
 
     /**
      * Copies a rectangle of texels from src to dst.
      * bounds.
      * @param dst           the surface to copy to.
      * @param src           the surface to copy from.
      * @param srcRect       the rectangle of the src that should be copied.
@@ skipping 123 matching lines @@
         void*         fInfo;
     };
 
     SkTDArray<CleanUpData>          fCleanUpData;
 
     const uint32_t                  fUniqueID;
 
     GrContext(); // init must be called after the constructor.
     bool init(GrBackend, GrBackendContext, const GrContextOptions& options);
 
-    // Currently the DrawingMgr stores a separate GrDrawContext for each
+    // Currently the DrawingMgr creates a separate GrTextContext for each
     // combination of text drawing options (pixel geometry x DFT use)
-    // and hands the appropriate one back given the user's request.
-    // All of the GrDrawContexts still land in the same GrDrawTarget!
+    // and hands the appropriate one back given the DrawContext's request.
+    //
+    // It allocates a new GrDrawContext for each GrRenderTarget
+    // but all of them still land in the same GrDrawTarget!
     //
     // In the future this class will allocate a new GrDrawContext for
     // each GrRenderTarget/GrDrawTarget and manage the DAG.
     class DrawingMgr {
     public:
-        DrawingMgr() : fDrawTarget(NULL) {
-            sk_bzero(fDrawContext, sizeof(fDrawContext));
+        DrawingMgr() : fDrawTarget(nullptr), fNVPRTextContext(nullptr) {
+            sk_bzero(fTextContexts, sizeof(fTextContexts));
         }
 
         ~DrawingMgr();
 
         void init(GrContext* context);
 
         void abandon();
         bool abandoned() const { return NULL == fDrawTarget; }
 
-        void purgeResources();
         void reset();
         void flush();
 
-        // Callers should take a ref if they rely on the GrDrawContext sticking around.
+        // Callers assume the creation ref of the drawContext!
         // NULL will be returned if the context has been abandoned.
-        GrDrawContext* drawContext(const SkSurfaceProps* surfaceProps);
+        GrDrawContext* drawContext(GrRenderTarget* rt, const SkSurfaceProps* surfaceProps);
+
+        GrTextContext* textContext(const SkSurfaceProps& props, GrRenderTarget* rt);
 
     private:
         void cleanup();
 
         friend class GrContext;  // for access to fDrawTarget for testing
 
         static const int kNumPixelGeometries = 5; // The different pixel geometries
         static const int kNumDFTOptions = 2;      // DFT or no DFT
 
         GrContext*        fContext;
         GrDrawTarget*     fDrawTarget;
 
-        GrDrawContext*    fDrawContext[kNumPixelGeometries][kNumDFTOptions];
+        GrTextContext*    fNVPRTextContext;
+        GrTextContext*    fTextContexts[kNumPixelGeometries][kNumDFTOptions];
     };
 
     DrawingMgr                      fDrawingMgr;
 
     void initMockContext();
     void initCommon();
 
     /**
      * These functions create premul <-> unpremul effects if it is possible to generate a pair
      * of effects that make a readToUPM->writeToPM->readToUPM cycle invariant. Otherwise, they
      * return NULL.
      */
-    const GrFragmentProcessor* createPMToUPMEffect(GrProcessorDataManager*, GrTexture*,
-                                                   bool swapRAndB, const SkMatrix&) const;
-    const GrFragmentProcessor* createUPMToPMEffect(GrProcessorDataManager*, GrTexture*,
-                                                   bool swapRAndB, const SkMatrix&) const;
+    const GrFragmentProcessor* createPMToUPMEffect(GrTexture*, bool swapRAndB,
+                                                   const SkMatrix&) const;
+    const GrFragmentProcessor* createUPMToPMEffect(GrTexture*, bool swapRAndB,
+                                                   const SkMatrix&) const;
     /** Called before either of the above two functions to determine the appropriate fragment
-        processors for conversions. This must be called by readSurfacePixels befor a mutex is taken,
-        since testingvPM conversions itself will call readSurfacePixels */
+        processors for conversions. This must be called by readSurfacePixels before a mutex is
+        taken, since testingvPM conversions itself will call readSurfacePixels */
     void testPMConversionsIfNecessary(uint32_t flags);
     /** Returns true if we've already determined that createPMtoUPMEffect and createUPMToPMEffect
         will fail. In such cases fall back to SW conversion. */
     bool didFailPMUPMConversionTest() const;
 
     /**
      *  This callback allows the resource cache to callback into the GrContext
      *  when the cache is still over budget after a purge.
      */
     static void OverBudgetCB(void* data);
 
     /**
      * A callback similar to the above for use by the TextBlobCache
      * TODO move textblob draw calls below context so we can use the call above.
      */
     static void TextBlobCacheOverBudgetCB(void* data);
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif