text: /*
   * Copyright 2015 Google Inc.
   *
   * Use of this source code is governed by a BSD-style license that can be
   * found in the LICENSE file.
   */
  
  // This test only works with the GPU backend.
  
  #include "gm/gm.h"
  #include "include/core/SkBitmap.h"
  #include "include/core/SkCanvas.h"
  #include "include/core/SkColor.h"
  #include "include/core/SkColorFilter.h"
  #include "include/core/SkColorPriv.h"
  #include "include/core/SkImage.h"
  #include "include/core/SkImageInfo.h"
  #include "include/core/SkPaint.h"
  #include "include/core/SkPixmap.h"
  #include "include/core/SkPoint.h"
  #include "include/core/SkRefCnt.h"
  #include "include/core/SkScalar.h"
  #include "include/core/SkShader.h"
  #include "include/core/SkSize.h"
  #include "include/core/SkString.h"
  #include "include/core/SkTileMode.h"
  #include "include/core/SkTypes.h"
  #include "include/effects/SkGradientShader.h"
  #include "include/gpu/GrBackendSurface.h"
  #include "include/gpu/GrContext.h"
  #include "include/gpu/GrTypes.h"
  #include "include/private/GrTypesPriv.h"
  #include "include/private/SkTo.h"
  
  class GrRenderTargetContext;
  
  static sk_sp<SkColorFilter> yuv_to_rgb_colorfilter() {
      static const float kJPEGConversionMatrix[20] = {
          1.0f,  0.0f,       1.402f,    0.0f, -180.0f/255,
          1.0f, -0.344136f, -0.714136f, 0.0f,  136.0f/255,
          1.0f,  1.772f,     0.0f,      0.0f, -227.6f/255,
          0.0f,  0.0f,       0.0f,      1.0f,    0.0f
      };
  
      return SkColorFilters::Matrix(kJPEGConversionMatrix);
  }
  
  namespace skiagm {
  class ImageFromYUVTextures : public GpuGM {
  public:
      ImageFromYUVTextures() {
          this->setBGColor(0xFFFFFFFF);
      }
  
  protected:
      SkString onShortName() override {
          return SkString("image_from_yuv_textures");
      }
  
      SkISize onISize() override {
          // Original image, plus each color space drawn twice
          int numBitmaps = 2 * (kLastEnum_SkYUVColorSpace + 1) + 1;
          return SkISize::Make(kBmpSize + 2 * kPad, numBitmaps * (kBmpSize + kPad) + kPad);
      }
  
      void onOnceBeforeDraw() override {
          // We create an RGB bitmap and then extract YUV bmps where the U and V bitmaps are
          // subsampled by 2 in both dimensions.
          SkPaint paint;
          constexpr SkColor kColors[] =
              { SK_ColorBLUE, SK_ColorYELLOW, SK_ColorGREEN, SK_ColorWHITE };
          paint.setShader(SkGradientShader::MakeRadial(SkPoint::Make(0,0), kBmpSize / 2.f, kColors,
                                                       nullptr, SK_ARRAY_COUNT(kColors),
                                                       SkTileMode::kMirror));
          SkBitmap rgbBmp;
          rgbBmp.allocN32Pixels(kBmpSize, kBmpSize, true);
          SkCanvas canvas(rgbBmp);
          canvas.drawPaint(paint);
          SkPMColor* rgbColors = static_cast<SkPMColor*>(rgbBmp.getPixels());
  
          SkImageInfo yinfo = SkImageInfo::Make(kBmpSize, kBmpSize, kGray_8_SkColorType,
                                                kUnpremul_SkAlphaType);
          fYUVBmps[0].allocPixels(yinfo);
          SkImageInfo uinfo = SkImageInfo::Make(kBmpSize / 2, kBmpSize / 2, kGray_8_SkColorType,
                                                kUnpremul_SkAlphaType);
          fYUVBmps[1].allocPixels(uinfo);
          SkImageInfo vinfo = SkImageInfo::Make(kBmpSize / 2, kBmpSize / 2, kGray_8_SkColorType,
                                                kUnpremul_SkAlphaType);
          fYUVBmps[2].allocPixels(vinfo);
          unsigned char* yPixels;
          signed char* uvPixels[2];
          yPixels = static_cast<unsigned char*>(fYUVBmps[0].getPixels());
          uvPixels[0] = static_cast<signed char*>(fYUVBmps[1].getPixels());
          uvPixels[1] = static_cast<signed char*>(fYUVBmps[2].getPixels());
  
          // Here we encode using the kJPEG_SkYUVColorSpace (i.e., full-swing Rec 601) even though
          // we will draw it with all the supported yuv color spaces when converted back to RGB
          for (int i = 0; i < kBmpSize * kBmpSize; ++i) {
              yPixels[i] = static_cast<unsigned char>(0.299f * SkGetPackedR32(rgbColors[i]) +
                                                      0.587f * SkGetPackedG32(rgbColors[i]) +
                                                      0.114f * SkGetPackedB32(rgbColors[i]));
          }
          for (int j = 0; j < kBmpSize / 2; ++j) {
              for (int i = 0; i < kBmpSize / 2; ++i) {
                  // Average together 4 pixels of RGB.
                  int rgb[] = { 0, 0, 0 };
                  for (int y = 0; y < 2; ++y) {
                      for (int x = 0; x < 2; ++x) {
                          int rgbIndex = (2 * j + y) * kBmpSize + 2 * i + x;
                          rgb[0] += SkGetPackedR32(rgbColors[rgbIndex]);
                          rgb[1] += SkGetPackedG32(rgbColors[rgbIndex]);
                          rgb[2] += SkGetPackedB32(rgbColors[rgbIndex]);
                      }
                  }
                  for (int c = 0; c < 3; ++c) {
                      rgb[c] /= 4;
                  }
                  int uvIndex = j * kBmpSize / 2 + i;
                  uvPixels[0][uvIndex] = static_cast<signed char>(
                      ((-38 * rgb[0] -  74 * rgb[1] + 112 * rgb[2] + 128) >> 8) + 128);
                  uvPixels[1][uvIndex] = static_cast<signed char>(
                      ((112 * rgb[0] -  94 * rgb[1] -  18 * rgb[2] + 128) >> 8) + 128);
              }
          }
          fRGBImage = SkImage::MakeRasterCopy(SkPixmap(rgbBmp.info(), rgbColors, rgbBmp.rowBytes()));
      }
  
      void createYUVTextures(GrContext* context, GrBackendTexture yuvTextures[3]) {
          for (int i = 0; i < 3; ++i) {
              SkASSERT(fYUVBmps[i].width() == SkToInt(fYUVBmps[i].rowBytes()));
              yuvTextures[i] = context->createBackendTexture(&fYUVBmps[i].pixmap(), 1,
                                                             GrRenderable::kNo, GrProtected::kNo);
          }
      }
  
      void createResultTexture(GrContext* context, int width, int height,
                               GrBackendTexture* resultTexture) {
          *resultTexture = context->createBackendTexture(
                  width, height, kRGBA_8888_SkColorType, SkColors::kTransparent,
                  GrMipMapped::kNo, GrRenderable::kYes, GrProtected::kNo);
      }
  
      void deleteBackendTextures(GrContext* context, GrBackendTexture textures[], int n) {
          if (context->abandoned()) {
              return;
          }
  
          GrFlushInfo flushInfo;
          flushInfo.fFlags = kSyncCpu_GrFlushFlag;
          context->flush(flushInfo);
  
          for (int i = 0; i < n; ++i) {
              context->deleteBackendTexture(textures[i]);
          }
      }
  
      void onDraw(GrContext* context, GrRenderTargetContext*, SkCanvas* canvas) override {
          // draw the original
          SkScalar yOffset = kPad;
          canvas->drawImage(fRGBImage.get(), kPad, yOffset);
          yOffset += kBmpSize + kPad;
  
          for (int space = kJPEG_SkYUVColorSpace; space <= kLastEnum_SkYUVColorSpace; ++space) {
              GrBackendTexture yuvTextures[3];
              this->createYUVTextures(context, yuvTextures);
              auto image = SkImage::MakeFromYUVTexturesCopy(context,
                                                            static_cast<SkYUVColorSpace>(space),
                                                            yuvTextures,
                                                            kTopLeft_GrSurfaceOrigin);
              this->deleteBackendTextures(context, yuvTextures, 3);
  
              SkPaint paint;
              if (kIdentity_SkYUVColorSpace == space) {
                  // The identity color space needs post-processing to appear correct
                  paint.setColorFilter(yuv_to_rgb_colorfilter());
              }
  
              canvas->drawImage(image.get(), kPad, yOffset, &paint);
              yOffset += kBmpSize + kPad;
          }
  
          for (int space = kJPEG_SkYUVColorSpace; space <= kLastEnum_SkYUVColorSpace; ++space) {
              GrBackendTexture yuvTextures[3];
              GrBackendTexture resultTexture;
              this->createYUVTextures(context, yuvTextures);
              this->createResultTexture(
                      context, yuvTextures[0].width(), yuvTextures[0].height(), &resultTexture);
              auto image = SkImage::MakeFromYUVTexturesCopyWithExternalBackend(
                                                            context,
                                                            static_cast<SkYUVColorSpace>(space),
                                                            yuvTextures,
                                                            kTopLeft_GrSurfaceOrigin,
                                                            resultTexture);
  
              SkPaint paint;
              if (kIdentity_SkYUVColorSpace == space) {
                  // The identity color space needs post-processing to appear correct
                  paint.setColorFilter(yuv_to_rgb_colorfilter());
              }
              canvas->drawImage(image.get(), kPad, yOffset, &paint);
              yOffset += kBmpSize + kPad;
  
              GrBackendTexture texturesToDelete[4]{
                      yuvTextures[0],
                      yuvTextures[1],
                      yuvTextures[2],
                      resultTexture,
              };
              this->deleteBackendTextures(context, texturesToDelete, 4);
          }
       }
  
  private:
      sk_sp<SkImage>  fRGBImage;
      SkBitmap        fYUVBmps[3];
  
      static constexpr SkScalar kPad = 10.0f;
      static constexpr int kBmpSize  = 32;
  
      typedef GM INHERITED;
  };
  
  DEF_GM(return new ImageFromYUVTextures;)
  }
  