1 /* 2 * Copyright 2014 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 "GrContext.h" 13 #include "GrContextPriv.h" 14 #include "GrProxyProvider.h" 15 #include "GrRenderTargetContextPriv.h" 16 #include "GrTextureProxy.h" 17 #include "SkBitmap.h" 18 #include "SkGr.h" 19 #include "SkGradientShader.h" 20 #include "effects/GrYUVtoRGBEffect.h" 21 #include "ops/GrDrawOp.h" 22 #include "ops/GrFillRectOp.h" 23 24 #define YSIZE 8 25 #define USIZE 4 26 #define VSIZE 4 27 28 namespace skiagm { 29 /** 30 * This GM directly exercises GrYUVtoRGBEffect. 31 */ 32 class YUVtoRGBEffect : public GM { 33 public: YUVtoRGBEffect()34 YUVtoRGBEffect() { 35 this->setBGColor(0xFFFFFFFF); 36 } 37 38 protected: onShortName()39 SkString onShortName() override { 40 return SkString("yuv_to_rgb_effect"); 41 } 42 onISize()43 SkISize onISize() override { 44 return SkISize::Make(238, 120); 45 } 46 onOnceBeforeDraw()47 void onOnceBeforeDraw() override { 48 SkBitmap bmp[3]; 49 SkImageInfo yinfo = SkImageInfo::MakeA8(YSIZE, YSIZE); 50 bmp[0].allocPixels(yinfo); 51 SkImageInfo uinfo = SkImageInfo::MakeA8(USIZE, USIZE); 52 bmp[1].allocPixels(uinfo); 53 SkImageInfo vinfo = SkImageInfo::MakeA8(VSIZE, VSIZE); 54 bmp[2].allocPixels(vinfo); 55 unsigned char* pixels[3]; 56 for (int i = 0; i < 3; ++i) { 57 pixels[i] = (unsigned char*)bmp[i].getPixels(); 58 } 59 int color[] = {0, 85, 170}; 60 const int limit[] = {255, 0, 255}; 61 const int invl[] = {0, 255, 0}; 62 const int inc[] = {1, -1, 1}; 63 for (int i = 0; i < 3; ++i) { 64 const size_t nbBytes = bmp[i].rowBytes() * bmp[i].height(); 65 for (size_t j = 0; j < nbBytes; ++j) { 66 pixels[i][j] = (unsigned char)color[i]; 67 color[i] = (color[i] == limit[i]) ? invl[i] : color[i] + inc[i]; 68 } 69 } 70 for (int i = 0; i < 3; ++i) { 71 fImage[i] = SkImage::MakeFromBitmap(bmp[i]); 72 } 73 } 74 onDraw(SkCanvas * canvas)75 void onDraw(SkCanvas* canvas) override { 76 GrRenderTargetContext* renderTargetContext = 77 canvas->internal_private_accessTopLayerRenderTargetContext(); 78 if (!renderTargetContext) { 79 skiagm::GM::DrawGpuOnlyMessage(canvas); 80 return; 81 } 82 83 GrContext* context = canvas->getGrContext(); 84 if (!context) { 85 return; 86 } 87 88 GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider(); 89 sk_sp<GrTextureProxy> proxies[3]; 90 91 for (int i = 0; i < 3; ++i) { 92 proxies[i] = proxyProvider->createTextureProxy(fImage[i], kNone_GrSurfaceFlags, 1, 93 SkBudgeted::kYes, SkBackingFit::kExact); 94 if (!proxies[i]) { 95 return; 96 } 97 } 98 99 constexpr SkScalar kDrawPad = 10.f; 100 constexpr SkScalar kTestPad = 10.f; 101 constexpr SkScalar kColorSpaceOffset = 36.f; 102 103 for (int space = kJPEG_SkYUVColorSpace; space <= kLastEnum_SkYUVColorSpace; ++space) { 104 SkRect renderRect = SkRect::MakeWH(SkIntToScalar(fImage[0]->width()), 105 SkIntToScalar(fImage[0]->height())); 106 renderRect.outset(kDrawPad, kDrawPad); 107 108 SkScalar y = kDrawPad + kTestPad + space * kColorSpaceOffset; 109 SkScalar x = kDrawPad + kTestPad; 110 111 const int indices[6][3] = {{0, 1, 2}, {0, 2, 1}, {1, 0, 2}, 112 {1, 2, 0}, {2, 0, 1}, {2, 1, 0}}; 113 114 for (int i = 0; i < 6; ++i) { 115 SkYUVAIndex yuvaIndices[4] = { 116 { indices[i][0], SkColorChannel::kR }, 117 { indices[i][1], SkColorChannel::kR }, 118 { indices[i][2], SkColorChannel::kR }, 119 { -1, SkColorChannel::kA } 120 }; 121 122 std::unique_ptr<GrFragmentProcessor> fp( 123 GrYUVtoRGBEffect::Make(proxies, yuvaIndices, 124 static_cast<SkYUVColorSpace>(space), 125 GrSamplerState::Filter::kNearest)); 126 if (fp) { 127 GrPaint grPaint; 128 grPaint.setXPFactory(GrPorterDuffXPFactory::Get(SkBlendMode::kSrc)); 129 grPaint.addColorFragmentProcessor(std::move(fp)); 130 SkMatrix viewMatrix; 131 viewMatrix.setTranslate(x, y); 132 renderTargetContext->priv().testingOnly_addDrawOp( 133 GrFillRectOp::Make(context, std::move(grPaint), GrAAType::kNone, 134 viewMatrix, renderRect)); 135 } 136 x += renderRect.width() + kTestPad; 137 } 138 } 139 } 140 141 private: 142 sk_sp<SkImage> fImage[3]; 143 144 typedef GM INHERITED; 145 }; 146 147 DEF_GM(return new YUVtoRGBEffect;) 148 149 ////////////////////////////////////////////////////////////////////////////// 150 151 class YUVNV12toRGBEffect : public GM { 152 public: YUVNV12toRGBEffect()153 YUVNV12toRGBEffect() { 154 this->setBGColor(0xFFFFFFFF); 155 } 156 157 protected: onShortName()158 SkString onShortName() override { 159 return SkString("yuv_nv12_to_rgb_effect"); 160 } 161 onISize()162 SkISize onISize() override { 163 return SkISize::Make(48, 120); 164 } 165 onOnceBeforeDraw()166 void onOnceBeforeDraw() override { 167 SkBitmap bmp[2]; 168 SkImageInfo yinfo = SkImageInfo::MakeA8(YSIZE, YSIZE); 169 bmp[0].allocPixels(yinfo); 170 SkImageInfo uvinfo = SkImageInfo::MakeN32Premul(USIZE, USIZE); 171 bmp[1].allocPixels(uvinfo); 172 int color[] = {0, 85, 170}; 173 const int limit[] = {255, 0, 255}; 174 const int invl[] = {0, 255, 0}; 175 const int inc[] = {1, -1, 1}; 176 177 { 178 unsigned char* pixels = (unsigned char*)bmp[0].getPixels(); 179 const size_t nbBytes = bmp[0].rowBytes() * bmp[0].height(); 180 for (size_t j = 0; j < nbBytes; ++j) { 181 pixels[j] = (unsigned char)color[0]; 182 color[0] = (color[0] == limit[0]) ? invl[0] : color[0] + inc[0]; 183 } 184 } 185 186 { 187 for (int y = 0; y < bmp[1].height(); ++y) { 188 uint32_t* pixels = bmp[1].getAddr32(0, y); 189 for (int j = 0; j < bmp[1].width(); ++j) { 190 pixels[j] = SkColorSetARGB(0, color[1], color[2], 0); 191 color[1] = (color[1] == limit[1]) ? invl[1] : color[1] + inc[1]; 192 color[2] = (color[2] == limit[2]) ? invl[2] : color[2] + inc[2]; 193 } 194 } 195 } 196 197 for (int i = 0; i < 2; ++i) { 198 fImage[i] = SkImage::MakeFromBitmap(bmp[i]); 199 } 200 } 201 onDraw(SkCanvas * canvas)202 void onDraw(SkCanvas* canvas) override { 203 GrRenderTargetContext* renderTargetContext = 204 canvas->internal_private_accessTopLayerRenderTargetContext(); 205 if (!renderTargetContext) { 206 skiagm::GM::DrawGpuOnlyMessage(canvas); 207 return; 208 } 209 210 GrContext* context = canvas->getGrContext(); 211 if (!context) { 212 return; 213 } 214 215 GrProxyProvider* proxyProvider = context->contextPriv().proxyProvider(); 216 sk_sp<GrTextureProxy> proxies[2]; 217 218 for (int i = 0; i < 2; ++i) { 219 proxies[i] = proxyProvider->createTextureProxy(fImage[i], kNone_GrSurfaceFlags, 1, 220 SkBudgeted::kYes, SkBackingFit::kExact); 221 if (!proxies[i]) { 222 return; 223 } 224 } 225 226 SkYUVAIndex yuvaIndices[4] = { 227 { 0, SkColorChannel::kR }, 228 { 1, SkColorChannel::kR }, 229 { 1, SkColorChannel::kG }, 230 { -1, SkColorChannel::kA } 231 }; 232 233 constexpr SkScalar kDrawPad = 10.f; 234 constexpr SkScalar kTestPad = 10.f; 235 constexpr SkScalar kColorSpaceOffset = 36.f; 236 237 for (int space = kJPEG_SkYUVColorSpace; space <= kLastEnum_SkYUVColorSpace; ++space) { 238 SkRect renderRect = SkRect::MakeWH(SkIntToScalar(fImage[0]->width()), 239 SkIntToScalar(fImage[0]->height())); 240 renderRect.outset(kDrawPad, kDrawPad); 241 242 SkScalar y = kDrawPad + kTestPad + space * kColorSpaceOffset; 243 SkScalar x = kDrawPad + kTestPad; 244 245 GrPaint grPaint; 246 grPaint.setXPFactory(GrPorterDuffXPFactory::Get(SkBlendMode::kSrc)); 247 auto fp = GrYUVtoRGBEffect::Make(proxies, yuvaIndices, 248 static_cast<SkYUVColorSpace>(space), 249 GrSamplerState::Filter::kNearest); 250 if (fp) { 251 SkMatrix viewMatrix; 252 viewMatrix.setTranslate(x, y); 253 grPaint.addColorFragmentProcessor(std::move(fp)); 254 std::unique_ptr<GrDrawOp> op(GrFillRectOp::Make(context, std::move(grPaint), 255 GrAAType::kNone, viewMatrix, renderRect)); 256 renderTargetContext->priv().testingOnly_addDrawOp(std::move(op)); 257 } 258 } 259 } 260 261 private: 262 sk_sp<SkImage> fImage[2]; 263 264 typedef GM INHERITED; 265 }; 266 267 DEF_GM(return new YUVNV12toRGBEffect;) 268 } 269