gm/imagefromyuvtextures.cpp

   1 /*
   2  * Copyright 2015 Google Inc.
   3  *
   4  * Use of this source code is governed by a BSD-style license that can be
   5  * found in the LICENSE file.
   6  */
   7
   8 // This test only works with the GPU backend.
   9
  10 #include "gm.h"
  11
  12 #if SK_SUPPORT_GPU
  13
  14 #include "GrContext.h"
  15 #include "GrGpu.h"
  16 #include "GrTest.h"
  17 #include "SkBitmap.h"
  18 #include "SkGradientShader.h"
  19 #include "SkImage.h"
  20
  21 namespace skiagm {
  22 class ImageFromYUVTextures : public GM {
  23 public:
  24     ImageFromYUVTextures() {
  25         this->setBGColor(0xFFFFFFFF);
  26     }
  27
  28 protected:
  29     SkString onShortName() override {
  30         return SkString("image_from_yuv_textures");
  31     }
  32
  33     SkISize onISize() override {
  34         return SkISize::Make(50, 175);
  35     }
  36
  37     void onOnceBeforeDraw() override {
  38         // We create an RGB bitmap and then extract YUV bmps where the U and V bitmaps are
  39         // subsampled by 2 in both dimensions.
  40         SkPaint paint;
  41         constexpr SkColor kColors[] =
  42             { SK_ColorBLUE, SK_ColorYELLOW, SK_ColorGREEN, SK_ColorWHITE };
  43         paint.setShader(SkGradientShader::MakeRadial(SkPoint::Make(0,0), kBmpSize / 2.f, kColors,
  44                                                      nullptr, SK_ARRAY_COUNT(kColors),
  45                                                      SkShader::kMirror_TileMode));
  46         SkBitmap rgbBmp;
  47         rgbBmp.allocN32Pixels(kBmpSize, kBmpSize, true);
  48         SkCanvas canvas(rgbBmp);
  49         canvas.drawPaint(paint);
  50         SkPMColor* rgbColors = static_cast<SkPMColor*>(rgbBmp.getPixels());
  51
  52         SkImageInfo yinfo = SkImageInfo::MakeA8(kBmpSize, kBmpSize);
  53         fYUVBmps[0].allocPixels(yinfo);
  54         SkImageInfo uinfo = SkImageInfo::MakeA8(kBmpSize / 2, kBmpSize / 2);
  55         fYUVBmps[1].allocPixels(uinfo);
  56         SkImageInfo vinfo = SkImageInfo::MakeA8(kBmpSize / 2, kBmpSize / 2);
  57         fYUVBmps[2].allocPixels(vinfo);
  58         unsigned char* yPixels;
  59         signed char* uvPixels[2];
  60         yPixels = static_cast<unsigned char*>(fYUVBmps[0].getPixels());
  61         uvPixels[0] = static_cast<signed char*>(fYUVBmps[1].getPixels());
  62         uvPixels[1] = static_cast<signed char*>(fYUVBmps[2].getPixels());
  63
  64         // Here we encode using the NTC encoding (even though we will draw it with all the supported
  65         // yuv color spaces when converted back to RGB)
  66         for (int i = 0; i < kBmpSize * kBmpSize; ++i) {
  67             yPixels[i] = static_cast<unsigned char>(0.299f * SkGetPackedR32(rgbColors[i]) +
  68                                                     0.587f * SkGetPackedG32(rgbColors[i]) +
  69                                                     0.114f * SkGetPackedB32(rgbColors[i]));
  70         }
  71         for (int j = 0; j < kBmpSize / 2; ++j) {
  72             for (int i = 0; i < kBmpSize / 2; ++i) {
  73                 // Average together 4 pixels of RGB.
  74                 int rgb[] = { 0, 0, 0 };
  75                 for (int y = 0; y < 2; ++y) {
  76                     for (int x = 0; x < 2; ++x) {
  77                         int rgbIndex = (2 * j + y) * kBmpSize + 2 * i + x;
  78                         rgb[0] += SkGetPackedR32(rgbColors[rgbIndex]);
  79                         rgb[1] += SkGetPackedG32(rgbColors[rgbIndex]);
  80                         rgb[2] += SkGetPackedB32(rgbColors[rgbIndex]);
  81                     }
  82                 }
  83                 for (int c = 0; c < 3; ++c) {
  84                     rgb[c] /= 4;
  85                 }
  86                 int uvIndex = j * kBmpSize / 2 + i;
  87                 uvPixels[0][uvIndex] = static_cast<signed char>(
  88                     ((-38 * rgb[0] -  74 * rgb[1] + 112 * rgb[2] + 128) >> 8) + 128);
  89                 uvPixels[1][uvIndex] = static_cast<signed char>(
  90                     ((112 * rgb[0] -  94 * rgb[1] -  18 * rgb[2] + 128) >> 8) + 128);
  91             }
  92         }
  93         fRGBImage = SkImage::MakeRasterCopy(SkPixmap(rgbBmp.info(), rgbColors, rgbBmp.rowBytes()));
  94     }
  95
  96     void createYUVTextures(GrContext* context, GrBackendObject yuvHandles[3]) {
  97         GrGpu* gpu = context->getGpu();
  98         if (!gpu) {
  99             return;
 100         }
 101
 102         for (int i = 0; i < 3; ++i) {
 103             SkASSERT(fYUVBmps[i].width() == SkToInt(fYUVBmps[i].rowBytes()));
 104             yuvHandles[i] = gpu->createTestingOnlyBackendTexture(fYUVBmps[i].getPixels(),
 105                                                                  fYUVBmps[i].width(),
 106                                                                  fYUVBmps[i].height(),
 107                                                                  kAlpha_8_GrPixelConfig);
 108         }
 109         context->resetContext();
 110     }
 111
 112     void deleteYUVTextures(GrContext* context, const GrBackendObject yuvHandles[3]) {
 113
 114         GrGpu* gpu = context->getGpu();
 115         if (!gpu) {
 116             return;
 117         }
 118
 119         for (int i = 0; i < 3; ++i) {
 120             gpu->deleteTestingOnlyBackendTexture(yuvHandles[i]);
 121         }
 122
 123         context->resetContext();
 124     }
 125
 126     void onDraw(SkCanvas* canvas) override {
 127         GrContext* context = canvas->getGrContext();
 128         if (!context) {
 129             skiagm::GM::DrawGpuOnlyMessage(canvas);
 130             return;
 131         }
 132
 133
 134         constexpr SkScalar kPad = 10.f;
 135
 136         SkISize sizes[] = {
 137             { fYUVBmps[0].width(), fYUVBmps[0].height()},
 138             { fYUVBmps[1].width(), fYUVBmps[1].height()},
 139             { fYUVBmps[2].width(), fYUVBmps[2].height()},
 140         };
 141         SkTArray<sk_sp<SkImage>> images;
 142         images.push_back(fRGBImage);
 143         for (int space = kJPEG_SkYUVColorSpace; space <= kLastEnum_SkYUVColorSpace; ++space) {
 144             GrBackendObject yuvHandles[3];
 145             this->createYUVTextures(context, yuvHandles);
 146             images.push_back(SkImage::MakeFromYUVTexturesCopy(context,
 147                                                               static_cast<SkYUVColorSpace>(space),
 148                                                               yuvHandles, sizes,
 149                                                               kTopLeft_GrSurfaceOrigin));
 150             this->deleteYUVTextures(context, yuvHandles);
 151         }
 152         for (int i = 0; i < images.count(); ++ i) {
 153             SkScalar y = (i + 1) * kPad + i * fYUVBmps[0].height();
 154             SkScalar x = kPad;
 155
 156             canvas->drawImage(images[i].get(), x, y);
 157         }
 158      }
 159
 160 private:
 161     sk_sp<SkImage>  fRGBImage;
 162     SkBitmap        fYUVBmps[3];
 163
 164     static constexpr int kBmpSize = 32;
 165
 166     typedef GM INHERITED;
 167 };
 168
 169 DEF_GM(return new ImageFromYUVTextures;)
 170 }
 171
 172 #endif