Fix iOS surface creation for SampleApp

experimental/iOSSampleApp/SkSampleUIView.mm

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #import "SkSampleUIView.h"
 
 //#define SKGL_CONFIG         kEAGLColorFormatRGB565
@@ skipping 14 matching lines @@
 #include "GrContext.h"
 #include "SkGpuDevice.h"
 #endif
 
 class SkiOSDeviceManager : public SampleWindow::DeviceManager {
 public:
     SkiOSDeviceManager(GLint layerFBO) {
 #if SK_SUPPORT_GPU
         fCurContext = NULL;
         fCurIntf = NULL;
-        fCurRenderTarget = NULL;
         fMSAASampleCount = 0;
-        fLayerFBO = layerFBO;
+        fDeepColor = false;
+        fActualColorBits = 0;
 #endif
         fBackend = SkOSWindow::kNone_BackEndType;
     }
     
     virtual ~SkiOSDeviceManager() {
 #if SK_SUPPORT_GPU
         SkSafeUnref(fCurContext);
         SkSafeUnref(fCurIntf);
-        SkSafeUnref(fCurRenderTarget);
 #endif
     }
     
     void setUpBackend(SampleWindow* win, int msaaSampleCount, bool deepColor) override {
         SkASSERT(SkOSWindow::kNone_BackEndType == fBackend);
         
         fBackend = SkOSWindow::kNone_BackEndType;
         
 #if SK_SUPPORT_GPU
         switch (win->getDeviceType()) {
             case SampleWindow::kRaster_DeviceType:
                 break;
             // these guys use the native backend
             case SampleWindow::kGPU_DeviceType:
                 fBackend = SkOSWindow::kNativeGL_BackEndType;
                 break;
             default:
                 SkASSERT(false);
                 break;
         }
         SkOSWindow::AttachmentInfo info;
         bool result = win->attach(fBackend, msaaSampleCount, false, &info);
         if (!result) {
             SkDebugf("Failed to initialize GL");
             return;
         }
         fMSAASampleCount = msaaSampleCount;
+        fDeepColor = deepColor;
+        // Assume that we have at least 24-bit output, for backends that don't supply this data
+        fActualColorBits = SkTMax(info.fColorBits, 24);
         
         SkASSERT(NULL == fCurIntf);
         switch (win->getDeviceType()) {
             case SampleWindow::kRaster_DeviceType:
                 fCurIntf = NULL;
                 break;
             case SampleWindow::kGPU_DeviceType:
                 fCurIntf = GrGLCreateNativeInterface();
                 break;
             default:
@@ skipping 21 matching lines @@
     }
     
     void tearDownBackend(SampleWindow *win) override {
 #if SK_SUPPORT_GPU
         SkSafeUnref(fCurContext);
         fCurContext = NULL;
         
         SkSafeUnref(fCurIntf);
         fCurIntf = NULL;
         
-        SkSafeUnref(fCurRenderTarget);
-        fCurRenderTarget = NULL;
+        fGpuSurface = nullptr;
 #endif
         win->release();
         fBackend = SampleWindow::kNone_BackEndType;
     }
 
-    SkSurface* createSurface(SampleWindow::DeviceType dType, SampleWindow* win) override{
+    sk_sp<SkSurface> makeSurface(SampleWindow::DeviceType dType, SampleWindow* win) override {
 #if SK_SUPPORT_GPU
         if (SampleWindow::IsGpuDeviceType(dType) && fCurContext) {
             SkSurfaceProps props(win->getSurfaceProps());
-            return SkSurface::MakeRenderTargetDirect(fCurRenderTarget,
-                                                     sk_ref_sp(win->info().colorSpace()),
-                                                     &props).release();
+            if (kRGBA_F16_SkColorType == win->info().colorType() || fActualColorBits > 24) {
+                // If we're rendering to F16, we need an off-screen surface - the current render
+                // target is most likely the wrong format.
+                //
+                // If we're using a deep (10-bit or higher) surface, we probably need an off-screen
+                // surface. 10-bit, in particular, has strange gamma behavior.
+                return SkSurface::MakeRenderTarget(fCurContext, SkBudgeted::kNo, win->info(),
+                                                   fMSAASampleCount, &props);
+            } else {
+                return fGpuSurface;
+            }
         }
 #endif
         return nullptr;
     }
 
     virtual void publishCanvas(SampleWindow::DeviceType dType,
                                SkCanvas* canvas,
                                SampleWindow* win) override {
 #if SK_SUPPORT_GPU
         if (NULL != fCurContext) {
             fCurContext->flush();
         }
 #endif
         win->present();
     }
-    
+
     void windowSizeChanged(SampleWindow* win) override {
 #if SK_SUPPORT_GPU
-        if (NULL != fCurContext) {
-            SkOSWindow::AttachmentInfo info;
-
-            win->attach(fBackend, fMSAASampleCount, false, &info);
-            
-            glBindFramebuffer(GL_FRAMEBUFFER, fLayerFBO);
-            GrBackendRenderTargetDesc desc;
-            desc.fWidth = SkScalarRoundToInt(win->width());
-            desc.fHeight = SkScalarRoundToInt(win->height());
-            desc.fConfig = kSkia8888_GrPixelConfig;
-            desc.fRenderTargetHandle = fLayerFBO;
-            desc.fSampleCnt = info.fSampleCount;
-            desc.fStencilBits = info.fStencilBits;
-
-            SkSafeUnref(fCurRenderTarget);
-            fCurRenderTarget = fCurContext->textureProvider()->wrapBackendRenderTarget(desc);
+        if (fCurContext) {
+            SampleWindow::AttachmentInfo attachmentInfo;
+            win->attach(fBackend, fMSAASampleCount, fDeepColor, &attachmentInfo);
+            fActualColorBits = SkTMax(attachmentInfo.fColorBits, 24);
+            fGpuSurface = win->makeGpuBackedSurface(attachmentInfo, fCurIntf, fCurContext);
         }
 #endif
     }
-    
+
     GrContext* getGrContext() override {
 #if SK_SUPPORT_GPU
         return fCurContext;
 #else
         return NULL;
 #endif
     }
-    
-    GrRenderTarget* getGrRenderTarget() override {
-#if SK_SUPPORT_GPU
-        return fCurRenderTarget;
-#else
-        return NULL;
-#endif
-    }
 
+    int numColorSamples() const override {
+#if SK_SUPPORT_GPU
+        return fMSAASampleCount;
+#else
+        return 0;
+#endif
+    }
+
     int getColorBits() override {
+#if SK_SUPPORT_GPU
+        return fActualColorBits;
+#else
         return 24;
+#endif
     }
 
     bool isUsingGL() const { return SkOSWindow::kNone_BackEndType != fBackend; }
-    
+
 private:
-   
+
 #if SK_SUPPORT_GPU
     GrContext*              fCurContext;
     const GrGLInterface*    fCurIntf;
-    GrRenderTarget*         fCurRenderTarget;
+    sk_sp<SkSurface>        fGpuSurface;
     int                     fMSAASampleCount;
-    GLint                   fLayerFBO;
+    bool                    fDeepColor;
+    int                     fActualColorBits;
 #endif
     
     SkOSWindow::SkBackEndTypes fBackend;
     
     typedef SampleWindow::DeviceManager INHERITED;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 @implementation SkSampleUIView
 
@@ skipping 205 matching lines @@
     glGetIntegerv(GL_SCISSOR_TEST, &scissorEnable);
     glDisable(GL_SCISSOR_TEST);
     glClearColor(0,0,0,0);
     glClear(GL_COLOR_BUFFER_BIT);
     if (scissorEnable) {
         glEnable(GL_SCISSOR_TEST);
     }
     glViewport(0, 0, fGL.fWidth, fGL.fHeight);
     
    
-    SkAutoTUnref<SkSurface> surface(fWind->createSurface());
+    sk_sp<SkSurface> surface(fWind->makeSurface());
     SkCanvas* canvas = surface->getCanvas();
 
     // if we're not "retained", then we have to always redraw everything.
     // This call forces us to ignore the fDirtyRgn, and draw everywhere.
     // If we are "retained", we can skip this call (as the raster case does)
     fWind->forceInvalAll();
 
     [self drawWithCanvas:canvas];
 
     // This application only creates a single color renderbuffer which is already bound at this point.
     // This call is redundant, but needed if dealing with multiple renderbuffers.
     glBindRenderbuffer(GL_RENDERBUFFER, fGL.fRenderbuffer);
     [fGL.fContext presentRenderbuffer:GL_RENDERBUFFER];
 }
 
 - (void)drawInRaster {
-    SkAutoTUnref<SkSurface> surface(fWind->createSurface());
+    sk_sp<SkSurface> surface(fWind->makeSurface());
     SkCanvas* canvas = surface->getCanvas();
     [self drawWithCanvas:canvas];
     CGImageRef cgimage = SkCreateCGImageRef(fWind->getBitmap());
     fRasterLayer.contents = (id)cgimage;
     CGImageRelease(cgimage);
 }
 
 - (void)forceRedraw {
     if (fDevManager->isUsingGL())
         [self drawInGL];
@@ skipping 37 matching lines @@
     glBindRenderbuffer(GL_RENDERBUFFER, fGL.fRenderbuffer);
     glGetRenderbufferParameteriv(GL_RENDERBUFFER,
                                  GL_RENDERBUFFER_STENCIL_SIZE,
                                  &info->fStencilBits);
     glGetRenderbufferParameteriv(GL_RENDERBUFFER,
                                  GL_RENDERBUFFER_SAMPLES_APPLE,
                                  &info->fSampleCount);
 }
 
 @end