205 lines
7.7 KiB
C++
205 lines
7.7 KiB
C++
|
|
/*
|
|
* 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.h"
|
|
|
|
#if SK_SUPPORT_GPU
|
|
|
|
#include "GrContext.h"
|
|
#include "gl/GrGLInterface.h"
|
|
#include "gl/GrGLUtil.h"
|
|
#include "GrTest.h"
|
|
#include "SkBitmap.h"
|
|
#include "SkGradientShader.h"
|
|
#include "SkImage.h"
|
|
|
|
namespace skiagm {
|
|
class ImageFromYUVTextures : public GM {
|
|
public:
|
|
ImageFromYUVTextures() {
|
|
this->setBGColor(0xFFFFFFFF);
|
|
}
|
|
|
|
protected:
|
|
SkString onShortName() override {
|
|
return SkString("image_from_yuv_textures");
|
|
}
|
|
|
|
SkISize onISize() override {
|
|
return SkISize::Make(50, 135);
|
|
}
|
|
|
|
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;
|
|
static const SkColor kColors[] =
|
|
{ SK_ColorBLUE, SK_ColorYELLOW, SK_ColorGREEN, SK_ColorWHITE };
|
|
paint.setShader(SkGradientShader::CreateRadial(SkPoint::Make(0,0), kBmpSize / 2.f, kColors,
|
|
NULL, SK_ARRAY_COUNT(kColors),
|
|
SkShader::kMirror_TileMode))->unref();
|
|
SkBitmap rgbBmp;
|
|
rgbBmp.allocN32Pixels(kBmpSize, kBmpSize, true);
|
|
SkCanvas canvas(rgbBmp);
|
|
canvas.drawPaint(paint);
|
|
SkPMColor* rgbColors = static_cast<SkPMColor*>(rgbBmp.getPixels());
|
|
|
|
SkImageInfo yinfo = SkImageInfo::MakeA8(kBmpSize, kBmpSize);
|
|
fYUVBmps[0].allocPixels(yinfo);
|
|
SkImageInfo uinfo = SkImageInfo::MakeA8(kBmpSize / 2, kBmpSize / 2);
|
|
fYUVBmps[1].allocPixels(uinfo);
|
|
SkImageInfo vinfo = SkImageInfo::MakeA8(kBmpSize / 2, kBmpSize / 2);
|
|
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 NTC encoding (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.reset(SkImage::NewRasterCopy(rgbBmp.info(), rgbColors, rgbBmp.rowBytes()));
|
|
}
|
|
|
|
void createYUVTextures(GrContext* context, GrGLuint yuvIDs[3]) {
|
|
GrTestTarget tt;
|
|
context->getTestTarget(&tt);
|
|
if (!tt.target()) {
|
|
SkDEBUGFAIL("Couldn't get Gr test target.");
|
|
return;
|
|
}
|
|
|
|
// We currently hav only implemented the texture uploads for GL.
|
|
const GrGLInterface* gl = tt.glInterface();
|
|
if (!gl) {
|
|
return;
|
|
}
|
|
|
|
GR_GL_CALL(gl, GenTextures(3, yuvIDs));
|
|
GR_GL_CALL(gl, ActiveTexture(GR_GL_TEXTURE0));
|
|
GR_GL_CALL(gl, PixelStorei(GR_GL_UNPACK_ALIGNMENT, 1));
|
|
for (int i = 0; i < 3; ++i) {
|
|
GR_GL_CALL(gl, BindTexture(GR_GL_TEXTURE_2D, yuvIDs[i]));
|
|
GR_GL_CALL(gl, TexParameteri(GR_GL_TEXTURE_2D, GR_GL_TEXTURE_MAG_FILTER,
|
|
GR_GL_NEAREST));
|
|
GR_GL_CALL(gl, TexParameteri(GR_GL_TEXTURE_2D, GR_GL_TEXTURE_MIN_FILTER,
|
|
GR_GL_NEAREST));
|
|
GR_GL_CALL(gl, TexParameteri(GR_GL_TEXTURE_2D, GR_GL_TEXTURE_WRAP_S,
|
|
GR_GL_CLAMP_TO_EDGE));
|
|
GR_GL_CALL(gl, TexParameteri(GR_GL_TEXTURE_2D, GR_GL_TEXTURE_WRAP_T,
|
|
GR_GL_CLAMP_TO_EDGE));
|
|
SkASSERT(fYUVBmps[i].width() == SkToInt(fYUVBmps[i].rowBytes()));
|
|
GR_GL_CALL(gl, TexImage2D(GR_GL_TEXTURE_2D, 0, GR_GL_RED, fYUVBmps[i].width(),
|
|
fYUVBmps[i].height(), 0, GR_GL_RED, GR_GL_UNSIGNED_BYTE,
|
|
fYUVBmps[i].getPixels()));
|
|
}
|
|
context->resetContext();
|
|
}
|
|
|
|
void deleteYUVTextures(GrContext* context, const GrGLuint yuvIDs[3]) {
|
|
GrTestTarget tt;
|
|
context->getTestTarget(&tt);
|
|
if (!tt.target()) {
|
|
SkDEBUGFAIL("Couldn't get Gr test target.");
|
|
return;
|
|
}
|
|
|
|
const GrGLInterface* gl = tt.glInterface();
|
|
if (!gl) {
|
|
return;
|
|
}
|
|
GR_GL_CALL(gl, DeleteTextures(3, yuvIDs));
|
|
context->resetContext();
|
|
}
|
|
|
|
void onDraw(SkCanvas* canvas) override {
|
|
GrRenderTarget* rt = canvas->internal_private_accessTopLayerRenderTarget();
|
|
GrContext* context;
|
|
if (!rt || !(context = rt->getContext())) {
|
|
this->drawGpuOnlyMessage(canvas);
|
|
return;
|
|
}
|
|
|
|
GrGLuint yuvIDs[3];
|
|
this->createYUVTextures(context, yuvIDs);
|
|
|
|
static const SkScalar kPad = 10.f;
|
|
|
|
GrBackendObject backendTextureObjects[] = {
|
|
static_cast<GrBackendObject>(yuvIDs[0]),
|
|
static_cast<GrBackendObject>(yuvIDs[1]),
|
|
static_cast<GrBackendObject>(yuvIDs[2])
|
|
};
|
|
SkISize sizes[] = {
|
|
{ fYUVBmps[0].width(), fYUVBmps[0].height()},
|
|
{ fYUVBmps[1].width(), fYUVBmps[1].height()},
|
|
{ fYUVBmps[2].width(), fYUVBmps[2].height()},
|
|
};
|
|
SkTArray<SkImage*> images;
|
|
images.push_back(SkRef(fRGBImage.get()));
|
|
for (int space = kJPEG_SkYUVColorSpace; space <= kLastEnum_SkYUVColorSpace; ++space) {
|
|
images.push_back(SkImage::NewFromYUVTexturesCopy(context,
|
|
static_cast<SkYUVColorSpace>(space),
|
|
backendTextureObjects, sizes,
|
|
kTopLeft_GrSurfaceOrigin));
|
|
}
|
|
this->deleteYUVTextures(context, yuvIDs);
|
|
for (int i = 0; i < images.count(); ++ i) {
|
|
SkScalar y = (i + 1) * kPad + i * fYUVBmps[0].height();
|
|
SkScalar x = kPad;
|
|
|
|
canvas->drawImage(images[i], x, y);
|
|
images[i]->unref();
|
|
images[i] = NULL;
|
|
}
|
|
}
|
|
|
|
private:
|
|
SkAutoTUnref<SkImage> fRGBImage;
|
|
SkBitmap fYUVBmps[3];
|
|
|
|
static const int kBmpSize = 32;
|
|
|
|
typedef GM INHERITED;
|
|
};
|
|
|
|
DEF_GM( return SkNEW(ImageFromYUVTextures); )
|
|
}
|
|
|
|
#endif
|