Add SkColorSpace to GrDrawContext

src/gpu/GrTextureToYUVPlanes.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrTextureToYUVPlanes.h"
 #include "effects/GrSimpleTextureEffect.h"
 #include "effects/GrYUVEffect.h"
@@ skipping 49 matching lines @@
 
         GrPixelConfig singleChannelPixelConfig;
         if (context->caps()->isConfigRenderable(kAlpha_8_GrPixelConfig, false)) {
             singleChannelPixelConfig = kAlpha_8_GrPixelConfig;
         } else {
             singleChannelPixelConfig = kRGBA_8888_GrPixelConfig;
         }
 
         // We issue draw(s) to convert from RGBA to Y, U, and V. All three planes may have different
         // sizes however we optimize for two other cases - all planes are the same (1 draw to YUV),
         // and U and V are the same but Y differs (2 draws, one for Y, one for UV).

[robertphillips, 2016/07/21 19:22:41]

What's up with the 'colorSpace' parameter ?

[Brian Osman, 2016/07/21 19:51:44]

That defines the transform between RGB (in any color space)
and YUV. (There are multiple such YUV transforms defined).
It's basically orthogonal to the RGB color-space. JPEG uses
one YUV conversion matrix, but video has a couple different
standard ones, and we support those, too. In this case, the
YUV data is actually "linear" from the SkColorSpace
perspective, so I think nullptr is fully correct here.

         if (sizes[0] == sizes[1] && sizes[1] == sizes[2]) {
             yuvDrawContext = context->newDrawContext(SkBackingFit::kApprox,
                                                      sizes[0].fWidth, sizes[0].fHeight,
-                                                     kRGBA_8888_GrPixelConfig);
+                                                     kRGBA_8888_GrPixelConfig, nullptr);
             if (!yuvDrawContext) {
                 return false;
             }
         } else {
             yDrawContext = context->newDrawContext(SkBackingFit::kApprox,
                                                    sizes[0].fWidth, sizes[0].fHeight,
-                                                   singleChannelPixelConfig);
+                                                   singleChannelPixelConfig, nullptr);
             if (!yDrawContext) {
                 return false;
             }
             if (sizes[1] == sizes[2]) {
                 // TODO: Add support for GL_RG when available.
                 uvDrawContext = context->newDrawContext(SkBackingFit::kApprox,
                                                         sizes[1].fWidth, sizes[1].fHeight,
-                                                        kRGBA_8888_GrPixelConfig);
+                                                        kRGBA_8888_GrPixelConfig, nullptr);
                 if (!uvDrawContext) {
                     return false;
                 }
             } else {
                 uDrawContext = context->newDrawContext(SkBackingFit::kApprox,
                                                        sizes[1].fWidth, sizes[1].fHeight,
-                                                       singleChannelPixelConfig);
+                                                       singleChannelPixelConfig, nullptr);
                 vDrawContext = context->newDrawContext(SkBackingFit::kApprox,
                                                        sizes[2].fWidth, sizes[2].fHeight,
-                                                       singleChannelPixelConfig);
+                                                       singleChannelPixelConfig, nullptr);
                 if (!uDrawContext || !vDrawContext) {
                     return false;
                 }
             }
         }
 
         // Do all the draws before any readback.
         if (yuvDrawContext) {
             if (!convert_texture(texture, yuvDrawContext.get(),
                                  sizes[0].fWidth, sizes[0].fHeight,
@@ skipping 111 matching lines @@
                 if (!tex->readPixels(0, 0, sizes[2].fWidth, sizes[2].fHeight,
                                      kAlpha_8_GrPixelConfig, planes[2], rowBytes[2])) {
                     return false;
                 }
                 return true;
             }
         }
     }
     return false;
 }