Home | History | Annotate | Download | only in gm 
      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 #include "GrBackendSurface.h"
     13 #include "GrContext.h"
     14 #include "GrContextPriv.h"
     15 #include "GrGpu.h"
     16 #include "SkBitmap.h"
     17 #include "SkGradientShader.h"
     18 #include "SkImage.h"
     19 #include "SkTo.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, 300);
     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, GrBackendTexture yuvTextures[3]) {
     97         if (context->abandoned()) {
     98             return;
     99         }
    100 
    101         GrGpu* gpu = context->contextPriv().getGpu();
    102         if (!gpu) {
    103             return;
    104         }
    105 
    106         for (int i = 0; i < 3; ++i) {
    107             SkASSERT(fYUVBmps[i].width() == SkToInt(fYUVBmps[i].rowBytes()));
    108             yuvTextures[i] = gpu->createTestingOnlyBackendTexture(fYUVBmps[i].getPixels(),
    109                                                                   fYUVBmps[i].width(),
    110                                                                   fYUVBmps[i].height(),
    111                                                                   GrColorType::kAlpha_8,
    112                                                                   false, GrMipMapped::kNo);
    113         }
    114         context->resetContext();
    115     }
    116 
    117     void createResultTexture(GrContext* context, int width, int height,
    118                              GrBackendTexture* resultTexture) {
    119         if (context->abandoned()) {
    120             return;
    121         }
    122 
    123         GrGpu* gpu = context->contextPriv().getGpu();
    124         if (!gpu) {
    125             return;
    126         }
    127 
    128         *resultTexture = gpu->createTestingOnlyBackendTexture(
    129                 nullptr, width, height, GrColorType::kRGBA_8888, true, GrMipMapped::kNo);
    130 
    131         context->resetContext();
    132     }
    133 
    134     void deleteBackendTextures(GrContext* context, GrBackendTexture textures[], int n) {
    135         if (context->abandoned()) {
    136             return;
    137         }
    138 
    139         GrGpu* gpu = context->contextPriv().getGpu();
    140         if (!gpu) {
    141             return;
    142         }
    143 
    144         context->flush();
    145         gpu->testingOnly_flushGpuAndSync();
    146         for (int i = 0; i < n; ++i) {
    147             if (textures[i].isValid()) {
    148                 gpu->deleteTestingOnlyBackendTexture(textures[i]);
    149             }
    150         }
    151 
    152         context->resetContext();
    153     }
    154 
    155     void onDraw(SkCanvas* canvas) override {
    156         GrContext* context = canvas->getGrContext();
    157         if (!context) {
    158             skiagm::GM::DrawGpuOnlyMessage(canvas);
    159             return;
    160         }
    161 
    162 
    163         constexpr SkScalar kPad = 10.f;
    164 
    165         SkTArray<sk_sp<SkImage>> images;
    166         images.push_back(fRGBImage);
    167         for (int space = kJPEG_SkYUVColorSpace; space <= kLastEnum_SkYUVColorSpace; ++space) {
    168             GrBackendTexture yuvTextures[3];
    169             this->createYUVTextures(context, yuvTextures);
    170             images.push_back(SkImage::MakeFromYUVTexturesCopy(context,
    171                                                               static_cast<SkYUVColorSpace>(space),
    172                                                               yuvTextures,
    173                                                               kTopLeft_GrSurfaceOrigin));
    174             this->deleteBackendTextures(context, yuvTextures, 3);
    175         }
    176         for (int i = 0; i < images.count(); ++ i) {
    177             SkScalar y = (i + 1) * kPad + i * fYUVBmps[0].height();
    178             SkScalar x = kPad;
    179 
    180             canvas->drawImage(images[i].get(), x, y);
    181         }
    182 
    183         sk_sp<SkImage> image;
    184         for (int space = kJPEG_SkYUVColorSpace, i = images.count();
    185              space <= kLastEnum_SkYUVColorSpace; ++space, ++i) {
    186             GrBackendTexture yuvTextures[3];
    187             GrBackendTexture resultTexture;
    188             this->createYUVTextures(context, yuvTextures);
    189             this->createResultTexture(
    190                     context, yuvTextures[0].width(), yuvTextures[0].height(), &resultTexture);
    191             image = SkImage::MakeFromYUVTexturesCopyWithExternalBackend(
    192                     context,
    193                     static_cast<SkYUVColorSpace>(space),
    194                     yuvTextures,
    195                     kTopLeft_GrSurfaceOrigin,
    196                     resultTexture);
    197 
    198             SkScalar y = (i + 1) * kPad + i * fYUVBmps[0].height();
    199             SkScalar x = kPad;
    200 
    201             canvas->drawImage(image.get(), x, y);
    202             GrBackendTexture texturesToDelete[4]{
    203                     yuvTextures[0],
    204                     yuvTextures[1],
    205                     yuvTextures[2],
    206                     resultTexture,
    207             };
    208             this->deleteBackendTextures(context, texturesToDelete, 4);
    209         }
    210      }
    211 
    212 private:
    213     sk_sp<SkImage>  fRGBImage;
    214     SkBitmap        fYUVBmps[3];
    215 
    216     static constexpr int kBmpSize = 32;
    217 
    218     typedef GM INHERITED;
    219 };
    220 
    221 DEF_GM(return new ImageFromYUVTextures;)
    222 }
    223