/*
|
* Copyright 2018 Google Inc.
|
*
|
* Use of this source code is governed by a BSD-style license that can be
|
* found in the LICENSE file.
|
*/
|
|
#include "gm.h"
|
#include "sk_tool_utils.h"
|
|
#include "SkColorPriv.h"
|
#include "SkImageGenerator.h"
|
#include "SkPath.h"
|
#include "SkTextUtils.h"
|
#include "SkYUVAIndex.h"
|
|
#if SK_SUPPORT_GPU
|
#include "GrBackendSurface.h"
|
#include "GrContextPriv.h"
|
#include "GrGpu.h"
|
#include "SkImage_GpuYUVA.h"
|
#endif
|
|
static const int kTileWidthHeight = 128;
|
static const int kLabelWidth = 64;
|
static const int kLabelHeight = 32;
|
static const int kPad = 1;
|
|
enum YUVFormat {
|
// 4:4:4 formats, 32 bpp
|
kAYUV_YUVFormat, // 8-bit YUVA values all interleaved
|
|
// 4:2:0 formats, 12 bpp
|
kNV12_YUVFormat, // 8-bit Y plane + 2x2 down sampled interleaved U/V planes
|
kNV21_YUVFormat, // same as kNV12 but w/ U/V reversed in the interleaved plane
|
|
kI420_YUVFormat, // 8-bit Y plane + 2x2 down sampled U and V planes
|
kYV12_YUVFormat, // 8-bit Y plane + 2x2 down sampled V and U planes
|
|
kLast_YUVFormat = kYV12_YUVFormat
|
};
|
|
// All the planes we need to construct the various YUV formats
|
struct PlaneData {
|
SkBitmap fYFull;
|
SkBitmap fUFull;
|
SkBitmap fVFull;
|
SkBitmap fAFull;
|
SkBitmap fUQuarter; // 2x2 downsampled U channel
|
SkBitmap fVQuarter; // 2x2 downsampled V channel
|
};
|
|
// Add a portion of a circle to 'path'. The points 'o1' and 'o2' are on the border of the circle
|
// and have tangents 'v1' and 'v2'.
|
static void add_arc(SkPath* path,
|
const SkPoint& o1, const SkVector& v1,
|
const SkPoint& o2, const SkVector& v2,
|
SkTDArray<SkRect>* circles, bool takeLongWayRound) {
|
|
SkVector v3 = { -v1.fY, v1.fX };
|
SkVector v4 = { v2.fY, -v2.fX };
|
|
SkScalar t = ((o2.fX - o1.fX) * v4.fY - (o2.fY - o1.fY) * v4.fX) / v3.cross(v4);
|
SkPoint center = { o1.fX + t * v3.fX, o1.fY + t * v3.fY };
|
|
SkRect r = { center.fX - t, center.fY - t, center.fX + t, center.fY + t };
|
|
if (circles) {
|
circles->push_back(r);
|
}
|
|
SkVector startV = o1 - center, endV = o2 - center;
|
startV.normalize();
|
endV.normalize();
|
|
SkScalar startDeg = SkRadiansToDegrees(SkScalarATan2(startV.fY, startV.fX));
|
SkScalar endDeg = SkRadiansToDegrees(SkScalarATan2(endV.fY, endV.fX));
|
|
startDeg += 360.0f;
|
startDeg = fmodf(startDeg, 360.0f);
|
|
endDeg += 360.0f;
|
endDeg = fmodf(endDeg, 360.0f);
|
|
if (endDeg < startDeg) {
|
endDeg += 360.0f;
|
}
|
|
SkScalar sweepDeg = SkTAbs(endDeg - startDeg);
|
if (!takeLongWayRound) {
|
sweepDeg = sweepDeg - 360;
|
}
|
|
path->arcTo(r, startDeg, sweepDeg, false);
|
}
|
|
static SkPath create_splat(const SkPoint& o, SkScalar innerRadius, SkScalar outerRadius,
|
SkScalar ratio, int numLobes, SkTDArray<SkRect>* circles) {
|
if (numLobes <= 1) {
|
return SkPath();
|
}
|
|
SkPath p;
|
|
int numDivisions = 2 * numLobes;
|
SkScalar fullLobeDegrees = 360.0f / numLobes;
|
SkScalar outDegrees = ratio * fullLobeDegrees / (ratio + 1.0f);
|
SkScalar innerDegrees = fullLobeDegrees / (ratio + 1.0f);
|
SkMatrix outerStep, innerStep;
|
outerStep.setRotate(outDegrees);
|
innerStep.setRotate(innerDegrees);
|
SkVector curV = SkVector::Make(0.0f, 1.0f);
|
|
if (circles) {
|
circles->push_back(SkRect::MakeLTRB(o.fX - innerRadius, o.fY - innerRadius,
|
o.fX + innerRadius, o.fY + innerRadius));
|
}
|
|
p.moveTo(o.fX + innerRadius * curV.fX, o.fY + innerRadius * curV.fY);
|
|
for (int i = 0; i < numDivisions; ++i) {
|
|
SkVector nextV;
|
if (0 == (i % 2)) {
|
nextV = outerStep.mapVector(curV.fX, curV.fY);
|
|
SkPoint top = SkPoint::Make(o.fX + outerRadius * curV.fX,
|
o.fY + outerRadius * curV.fY);
|
SkPoint nextTop = SkPoint::Make(o.fX + outerRadius * nextV.fX,
|
o.fY + outerRadius * nextV.fY);
|
|
p.lineTo(top);
|
add_arc(&p, top, curV, nextTop, nextV, circles, true);
|
} else {
|
nextV = innerStep.mapVector(curV.fX, curV.fY);
|
|
SkPoint bot = SkPoint::Make(o.fX + innerRadius * curV.fX,
|
o.fY + innerRadius * curV.fY);
|
SkPoint nextBot = SkPoint::Make(o.fX + innerRadius * nextV.fX,
|
o.fY + innerRadius * nextV.fY);
|
|
p.lineTo(bot);
|
add_arc(&p, bot, curV, nextBot, nextV, nullptr, false);
|
}
|
|
curV = nextV;
|
}
|
|
p.close();
|
|
return p;
|
}
|
|
static SkBitmap make_bitmap(const SkPath& path, const SkTDArray<SkRect>& circles, bool opaque) {
|
const SkColor kGreen = sk_tool_utils::color_to_565(SkColorSetARGB(0xFF, 178, 240, 104));
|
const SkColor kBlue = sk_tool_utils::color_to_565(SkColorSetARGB(0xFF, 173, 167, 252));
|
const SkColor kYellow = sk_tool_utils::color_to_565(SkColorSetARGB(0xFF, 255, 221, 117));
|
|
SkImageInfo ii = SkImageInfo::MakeN32(kTileWidthHeight, kTileWidthHeight, kPremul_SkAlphaType);
|
|
SkBitmap bm;
|
bm.allocPixels(ii);
|
|
std::unique_ptr<SkCanvas> canvas = SkCanvas::MakeRasterDirectN32(ii.width(), ii.height(),
|
(SkPMColor*)bm.getPixels(),
|
bm.rowBytes());
|
|
canvas->clear(opaque ? kGreen : SK_ColorTRANSPARENT);
|
|
SkPaint paint;
|
paint.setAntiAlias(false); // serialize-8888 doesn't seem to work well w/ partial transparency
|
paint.setColor(kBlue);
|
|
canvas->drawPath(path, paint);
|
|
paint.setColor(opaque ? kYellow : SK_ColorTRANSPARENT);
|
paint.setBlendMode(SkBlendMode::kSrc);
|
for (int i = 0; i < circles.count(); ++i) {
|
SkRect r = circles[i];
|
r.inset(r.width()/4, r.height()/4);
|
canvas->drawOval(r, paint);
|
}
|
|
return bm;
|
}
|
|
static void convert_rgba_to_yuva_601_shared(SkColor col, uint8_t yuv[4],
|
uint8_t off, uint8_t range) {
|
static const float Kr = 0.299f;
|
static const float Kb = 0.114f;
|
static const float Kg = 1.0f - Kr - Kb;
|
|
float r = SkColorGetR(col) / 255.0f;
|
float g = SkColorGetG(col) / 255.0f;
|
float b = SkColorGetB(col) / 255.0f;
|
|
float Ey = Kr * r + Kg * g + Kb * b;
|
float Ecb = (b - Ey) / 1.402f;
|
float Ecr = (r - Ey) / 1.772;
|
|
yuv[0] = SkScalarRoundToInt( range * Ey + off );
|
yuv[1] = SkScalarRoundToInt( 224 * Ecb + 128 );
|
yuv[2] = SkScalarRoundToInt( 224 * Ecr + 128 );
|
yuv[3] = SkColorGetA(col);
|
}
|
|
static void convert_rgba_to_yuva_jpeg(SkColor col, uint8_t yuv[4]) {
|
// full swing from 0..255
|
convert_rgba_to_yuva_601_shared(col, yuv, 0, 255);
|
}
|
|
static void convert_rgba_to_yuva_601(SkColor col, uint8_t yuv[4]) {
|
// partial swing from 16..235
|
convert_rgba_to_yuva_601_shared(col, yuv, 16, 219);
|
|
}
|
|
static void convert_rgba_to_yuva_709(SkColor col, uint8_t yuv[4]) {
|
static const float Kr = 0.2126f;
|
static const float Kb = 0.0722f;
|
static const float Kg = 1.0f - Kr - Kb;
|
|
float r = SkColorGetR(col) / 255.0f;
|
float g = SkColorGetG(col) / 255.0f;
|
float b = SkColorGetB(col) / 255.0f;
|
|
float Ey = Kr * r + Kg * g + Kb * b;
|
float Ecb = (b - Ey) / 1.8556f;
|
float Ecr = (r - Ey) / 1.5748;
|
|
yuv[0] = SkScalarRoundToInt( 219 * Ey + 16 );
|
yuv[1] = SkScalarRoundToInt( 224 * Ecb + 128 );
|
yuv[2] = SkScalarRoundToInt( 224 * Ecr + 128 );
|
|
yuv[3] = SkColorGetA(col);
|
}
|
|
|
static SkPMColor convert_yuva_to_rgba_jpeg(uint8_t y, uint8_t u, uint8_t v, uint8_t a) {
|
int c = y;
|
int d = u - 128;
|
int e = v - 128;
|
|
uint8_t r = SkScalarPin(SkScalarRoundToInt( 1.0f * c + 1.402f * e ),
|
0, 255);
|
uint8_t g = SkScalarPin(SkScalarRoundToInt( 1.0f * c - (0.344136f * d) - (0.714136f * e)),
|
0, 255);
|
uint8_t b = SkScalarPin(SkScalarRoundToInt( 1.0f * c + 1.773f * d ),
|
0, 255);
|
|
return SkPremultiplyARGBInline(a, r, g, b);
|
}
|
|
static SkPMColor convert_yuva_to_rgba_601(uint8_t y, uint8_t u, uint8_t v, uint8_t a) {
|
int c = y - 16;
|
int d = u - 128;
|
int e = v - 128;
|
|
uint8_t r = SkScalarPin(SkScalarRoundToInt( 1.164f * c + 1.596f * e ), 0, 255);
|
uint8_t g = SkScalarPin(SkScalarRoundToInt( 1.164f * c - (0.391f * d) - (0.813f * e)), 0, 255);
|
uint8_t b = SkScalarPin(SkScalarRoundToInt( 1.164f * c + 2.018f * d ), 0, 255);
|
|
return SkPremultiplyARGBInline(a, r, g, b);
|
}
|
|
static SkPMColor convert_yuva_to_rgba_709(uint8_t y, uint8_t u, uint8_t v, uint8_t a) {
|
int c = y - 16;
|
int d = u - 128;
|
int e = v - 128;
|
|
uint8_t r = SkScalarPin(SkScalarRoundToInt( 1.164f * c + 1.793f * e ), 0, 255);
|
uint8_t g = SkScalarPin(SkScalarRoundToInt( 1.164f * c - (0.213f * d) - (0.533f * e)), 0, 255);
|
uint8_t b = SkScalarPin(SkScalarRoundToInt( 1.164f * c + 2.112f * d ), 0, 255);
|
|
return SkPremultiplyARGBInline(a, r, g, b);
|
}
|
|
static void extract_planes(const SkBitmap& bm, SkYUVColorSpace yuvColorSpace, PlaneData* planes) {
|
SkASSERT(!(bm.width() % 2));
|
SkASSERT(!(bm.height() % 2));
|
|
planes->fYFull.allocPixels(SkImageInfo::MakeA8(bm.width(), bm.height()));
|
planes->fUFull.allocPixels(SkImageInfo::MakeA8(bm.width(), bm.height()));
|
planes->fVFull.allocPixels(SkImageInfo::MakeA8(bm.width(), bm.height()));
|
planes->fAFull.allocPixels(SkImageInfo::MakeA8(bm.width(), bm.height()));
|
planes->fUQuarter.allocPixels(SkImageInfo::MakeA8(bm.width()/2, bm.height()/2));
|
planes->fVQuarter.allocPixels(SkImageInfo::MakeA8(bm.width()/2, bm.height()/2));
|
|
for (int y = 0; y < bm.height(); ++y) {
|
for (int x = 0; x < bm.width(); ++x) {
|
SkColor col = bm.getColor(x, y);
|
|
uint8_t yuva[4];
|
|
if (kJPEG_SkYUVColorSpace == yuvColorSpace) {
|
convert_rgba_to_yuva_jpeg(col, yuva);
|
} else if (kRec601_SkYUVColorSpace == yuvColorSpace) {
|
convert_rgba_to_yuva_601(col, yuva);
|
} else {
|
SkASSERT(kRec709_SkYUVColorSpace == yuvColorSpace);
|
convert_rgba_to_yuva_709(col, yuva);
|
}
|
|
*planes->fYFull.getAddr8(x, y) = yuva[0];
|
*planes->fUFull.getAddr8(x, y) = yuva[1];
|
*planes->fVFull.getAddr8(x, y) = yuva[2];
|
*planes->fAFull.getAddr8(x, y) = yuva[3];
|
}
|
}
|
|
for (int y = 0; y < bm.height()/2; ++y) {
|
for (int x = 0; x < bm.width()/2; ++x) {
|
uint32_t uAccum = 0, vAccum = 0;
|
|
uAccum += *planes->fUFull.getAddr8(2*x, 2*y);
|
uAccum += *planes->fUFull.getAddr8(2*x+1, 2*y);
|
uAccum += *planes->fUFull.getAddr8(2*x, 2*y+1);
|
uAccum += *planes->fUFull.getAddr8(2*x+1, 2*y+1);
|
|
*planes->fUQuarter.getAddr8(x, y) = uAccum / 4.0f;
|
|
vAccum += *planes->fVFull.getAddr8(2*x, 2*y);
|
vAccum += *planes->fVFull.getAddr8(2*x+1, 2*y);
|
vAccum += *planes->fVFull.getAddr8(2*x, 2*y+1);
|
vAccum += *planes->fVFull.getAddr8(2*x+1, 2*y+1);
|
|
*planes->fVQuarter.getAddr8(x, y) = vAccum / 4.0f;
|
}
|
}
|
}
|
|
// Recombine the separate planes into some YUV format
|
static void create_YUV(const PlaneData& planes, YUVFormat yuvFormat,
|
SkBitmap resultBMs[], SkYUVAIndex yuvaIndices[4], bool opaque) {
|
int nextLayer = 0;
|
|
switch (yuvFormat) {
|
case kAYUV_YUVFormat: {
|
SkBitmap yuvaFull;
|
|
yuvaFull.allocPixels(SkImageInfo::Make(planes.fYFull.width(), planes.fYFull.height(),
|
kRGBA_8888_SkColorType, kUnpremul_SkAlphaType));
|
|
for (int y = 0; y < planes.fYFull.height(); ++y) {
|
for (int x = 0; x < planes.fYFull.width(); ++x) {
|
|
uint8_t Y = *planes.fYFull.getAddr8(x, y);
|
uint8_t U = *planes.fUFull.getAddr8(x, y);
|
uint8_t V = *planes.fVFull.getAddr8(x, y);
|
uint8_t A = *planes.fAFull.getAddr8(x, y);
|
|
// NOT premul!
|
// V and Y swapped to match RGBA layout
|
*yuvaFull.getAddr32(x, y) = SkColorSetARGB(A, V, U, Y);
|
}
|
}
|
|
resultBMs[nextLayer++] = yuvaFull;
|
|
yuvaIndices[0].fIndex = 0;
|
yuvaIndices[0].fChannel = SkColorChannel::kR;
|
yuvaIndices[1].fIndex = 0;
|
yuvaIndices[1].fChannel = SkColorChannel::kG;
|
yuvaIndices[2].fIndex = 0;
|
yuvaIndices[2].fChannel = SkColorChannel::kB;
|
yuvaIndices[3].fIndex = 0;
|
yuvaIndices[3].fChannel = SkColorChannel::kA;
|
break;
|
}
|
case kNV12_YUVFormat: {
|
SkBitmap uvQuarter;
|
|
// There isn't a RG color type. Approx w/ RGBA.
|
uvQuarter.allocPixels(SkImageInfo::Make(planes.fYFull.width()/2,
|
planes.fYFull.height()/2,
|
kRGBA_8888_SkColorType,
|
kUnpremul_SkAlphaType));
|
|
for (int y = 0; y < planes.fYFull.height()/2; ++y) {
|
for (int x = 0; x < planes.fYFull.width()/2; ++x) {
|
uint8_t U = *planes.fUQuarter.getAddr8(x, y);
|
uint8_t V = *planes.fVQuarter.getAddr8(x, y);
|
|
// NOT premul!
|
// U and 0 swapped to match RGBA layout
|
*uvQuarter.getAddr32(x, y) = SkColorSetARGB(0, 0, V, U);
|
}
|
}
|
|
resultBMs[nextLayer++] = planes.fYFull;
|
resultBMs[nextLayer++] = uvQuarter;
|
|
yuvaIndices[0].fIndex = 0;
|
yuvaIndices[0].fChannel = SkColorChannel::kA;
|
yuvaIndices[1].fIndex = 1;
|
yuvaIndices[1].fChannel = SkColorChannel::kR;
|
yuvaIndices[2].fIndex = 1;
|
yuvaIndices[2].fChannel = SkColorChannel::kG;
|
break;
|
}
|
case kNV21_YUVFormat: {
|
SkBitmap vuQuarter;
|
|
// There isn't a RG color type. Approx w/ RGBA.
|
vuQuarter.allocPixels(SkImageInfo::Make(planes.fYFull.width()/2,
|
planes.fYFull.height()/2,
|
kRGBA_8888_SkColorType,
|
kUnpremul_SkAlphaType));
|
|
for (int y = 0; y < planes.fYFull.height()/2; ++y) {
|
for (int x = 0; x < planes.fYFull.width()/2; ++x) {
|
uint8_t U = *planes.fUQuarter.getAddr8(x, y);
|
uint8_t V = *planes.fVQuarter.getAddr8(x, y);
|
|
// NOT premul!
|
// V and 0 swapped to match RGBA layout
|
*vuQuarter.getAddr32(x, y) = SkColorSetARGB(0, 0, U, V);
|
}
|
}
|
|
resultBMs[nextLayer++] = planes.fYFull;
|
resultBMs[nextLayer++] = vuQuarter;
|
|
yuvaIndices[0].fIndex = 0;
|
yuvaIndices[0].fChannel = SkColorChannel::kA;
|
yuvaIndices[1].fIndex = 1;
|
yuvaIndices[1].fChannel = SkColorChannel::kG;
|
yuvaIndices[2].fIndex = 1;
|
yuvaIndices[2].fChannel = SkColorChannel::kR;
|
break;
|
}
|
case kI420_YUVFormat:
|
resultBMs[nextLayer++] = planes.fYFull;
|
resultBMs[nextLayer++] = planes.fUQuarter;
|
resultBMs[nextLayer++] = planes.fVQuarter;
|
|
yuvaIndices[0].fIndex = 0;
|
yuvaIndices[0].fChannel = SkColorChannel::kA;
|
yuvaIndices[1].fIndex = 1;
|
yuvaIndices[1].fChannel = SkColorChannel::kA;
|
yuvaIndices[2].fIndex = 2;
|
yuvaIndices[2].fChannel = SkColorChannel::kA;
|
break;
|
case kYV12_YUVFormat:
|
resultBMs[nextLayer++] = planes.fYFull;
|
resultBMs[nextLayer++] = planes.fVQuarter;
|
resultBMs[nextLayer++] = planes.fUQuarter;
|
|
yuvaIndices[0].fIndex = 0;
|
yuvaIndices[0].fChannel = SkColorChannel::kA;
|
yuvaIndices[1].fIndex = 2;
|
yuvaIndices[1].fChannel = SkColorChannel::kA;
|
yuvaIndices[2].fIndex = 1;
|
yuvaIndices[2].fChannel = SkColorChannel::kA;
|
break;
|
}
|
|
if (kAYUV_YUVFormat != yuvFormat) {
|
if (opaque) {
|
yuvaIndices[3].fIndex = -1;
|
} else {
|
resultBMs[nextLayer] = planes.fAFull;
|
|
yuvaIndices[3].fIndex = nextLayer;
|
yuvaIndices[3].fChannel = SkColorChannel::kA;
|
}
|
}
|
|
}
|
|
static uint8_t look_up(float x1, float y1, const SkBitmap& bm, SkColorChannel channel) {
|
uint8_t result;
|
|
int x = SkScalarFloorToInt(x1 * bm.width());
|
int y = SkScalarFloorToInt(y1 * bm.height());
|
|
if (kAlpha_8_SkColorType == bm.colorType()) {
|
SkASSERT(SkColorChannel::kA == channel);
|
result = *bm.getAddr8(x, y);
|
} else {
|
SkASSERT(kRGBA_8888_SkColorType == bm.colorType());
|
|
switch (channel) {
|
case SkColorChannel::kR:
|
result = SkColorGetR(bm.getColor(x, y));
|
break;
|
case SkColorChannel::kG:
|
result = SkColorGetG(bm.getColor(x, y));
|
break;
|
case SkColorChannel::kB:
|
result = SkColorGetB(bm.getColor(x, y));
|
break;
|
case SkColorChannel::kA:
|
result = SkColorGetA(bm.getColor(x, y));
|
break;
|
}
|
}
|
|
return result;
|
}
|
|
class YUVGenerator : public SkImageGenerator {
|
public:
|
YUVGenerator(const SkImageInfo& ii,
|
SkYUVColorSpace yuvColorSpace,
|
SkYUVAIndex yuvaIndices[SkYUVAIndex::kIndexCount],
|
SkBitmap bitmaps[SkYUVASizeInfo::kMaxCount])
|
: SkImageGenerator(ii)
|
, fYUVColorSpace(yuvColorSpace) {
|
memcpy(fYUVAIndices, yuvaIndices, sizeof(fYUVAIndices));
|
|
SkAssertResult(SkYUVAIndex::AreValidIndices(fYUVAIndices, &fNumBitmaps));
|
SkASSERT(fNumBitmaps > 0 && fNumBitmaps <= SkYUVASizeInfo::kMaxCount);
|
|
for (int i = 0; i < fNumBitmaps; ++i) {
|
fYUVBitmaps[i] = bitmaps[i];
|
}
|
}
|
|
protected:
|
bool onGetPixels(const SkImageInfo& info, void* pixels, size_t rowBytes,
|
const Options&) override {
|
|
if (kUnknown_SkColorType == fFlattened.colorType()) {
|
fFlattened.allocPixels(this->getInfo());
|
|
for (int y = 0; y < info.height(); ++y) {
|
for (int x = 0; x < info.width(); ++x) {
|
|
float x1 = (x + 0.5f) / info.width();
|
float y1 = (y + 0.5f) / info.height();
|
|
uint8_t Y = look_up(x1, y1,
|
fYUVBitmaps[fYUVAIndices[0].fIndex],
|
fYUVAIndices[0].fChannel);
|
|
uint8_t U = look_up(x1, y1,
|
fYUVBitmaps[fYUVAIndices[1].fIndex],
|
fYUVAIndices[1].fChannel);
|
|
|
uint8_t V = look_up(x1, y1,
|
fYUVBitmaps[fYUVAIndices[2].fIndex],
|
fYUVAIndices[2].fChannel);
|
|
uint8_t A = 255;
|
if (fYUVAIndices[3].fIndex >= 0) {
|
A = look_up(x1, y1,
|
fYUVBitmaps[fYUVAIndices[3].fIndex],
|
fYUVAIndices[3].fChannel);
|
}
|
|
// Making premul here.
|
switch (fYUVColorSpace) {
|
case kJPEG_SkYUVColorSpace:
|
*fFlattened.getAddr32(x, y) = convert_yuva_to_rgba_jpeg(Y, U, V, A);
|
break;
|
case kRec601_SkYUVColorSpace:
|
*fFlattened.getAddr32(x, y) = convert_yuva_to_rgba_601(Y, U, V, A);
|
break;
|
case kRec709_SkYUVColorSpace:
|
*fFlattened.getAddr32(x, y) = convert_yuva_to_rgba_709(Y, U, V, A);
|
break;
|
}
|
}
|
}
|
}
|
|
return fFlattened.readPixels(info, pixels, rowBytes, 0, 0);
|
}
|
|
bool onQueryYUVA8(SkYUVASizeInfo* size,
|
SkYUVAIndex yuvaIndices[SkYUVAIndex::kIndexCount],
|
SkYUVColorSpace* yuvColorSpace) const override {
|
|
memcpy(yuvaIndices, fYUVAIndices, sizeof(fYUVAIndices));
|
*yuvColorSpace = fYUVColorSpace;
|
|
int i = 0;
|
for ( ; i < fNumBitmaps; ++i) {
|
size->fSizes[i].fWidth = fYUVBitmaps[i].width();
|
size->fSizes[i].fHeight = fYUVBitmaps[i].height();
|
size->fWidthBytes[i] = fYUVBitmaps[i].rowBytes();
|
}
|
for ( ; i < SkYUVASizeInfo::kMaxCount; ++i) {
|
size->fSizes[i].fWidth = 0;
|
size->fSizes[i].fHeight = 0;
|
size->fWidthBytes[i] = 0;
|
}
|
|
return true;
|
}
|
|
bool onGetYUVA8Planes(const SkYUVASizeInfo&, const SkYUVAIndex[SkYUVAIndex::kIndexCount],
|
void* planes[SkYUVASizeInfo::kMaxCount]) override {
|
for (int i = 0; i < fNumBitmaps; ++i) {
|
planes[i] = fYUVBitmaps[i].getPixels();
|
}
|
return true;
|
}
|
|
private:
|
SkYUVColorSpace fYUVColorSpace;
|
SkYUVAIndex fYUVAIndices[SkYUVAIndex::kIndexCount];
|
int fNumBitmaps;
|
SkBitmap fYUVBitmaps[SkYUVASizeInfo::kMaxCount];
|
SkBitmap fFlattened;
|
|
};
|
|
static sk_sp<SkImage> make_yuv_gen_image(const SkImageInfo& ii,
|
SkYUVColorSpace yuvColorSpace,
|
SkYUVAIndex yuvaIndices[SkYUVAIndex::kIndexCount],
|
SkBitmap bitmaps[]) {
|
std::unique_ptr<SkImageGenerator> gen(new YUVGenerator(ii, yuvColorSpace,
|
yuvaIndices, bitmaps));
|
|
return SkImage::MakeFromGenerator(std::move(gen));
|
}
|
|
static void draw_col_label(SkCanvas* canvas, int x, int yuvColorSpace, bool opaque) {
|
static const char* kYUVColorSpaceNames[] = { "JPEG", "601", "709" };
|
GR_STATIC_ASSERT(SK_ARRAY_COUNT(kYUVColorSpaceNames) == kLastEnum_SkYUVColorSpace+1);
|
|
SkPaint paint;
|
SkFont font(sk_tool_utils::create_portable_typeface(nullptr, SkFontStyle::Bold()), 16);
|
font.setEdging(SkFont::Edging::kAlias);
|
|
SkRect textRect;
|
SkString colLabel;
|
|
colLabel.printf("%s", kYUVColorSpaceNames[yuvColorSpace]);
|
font.measureText(colLabel.c_str(), colLabel.size(), kUTF8_SkTextEncoding, &textRect);
|
int y = textRect.height();
|
|
SkTextUtils::DrawString(canvas, colLabel.c_str(), x, y, font, paint, SkTextUtils::kCenter_Align);
|
|
colLabel.printf("%s", opaque ? "Opaque" : "Transparent");
|
|
font.measureText(colLabel.c_str(), colLabel.size(), kUTF8_SkTextEncoding, &textRect);
|
y += textRect.height();
|
|
SkTextUtils::DrawString(canvas, colLabel.c_str(), x, y, font, paint, SkTextUtils::kCenter_Align);
|
}
|
|
static void draw_row_label(SkCanvas* canvas, int y, int yuvFormat) {
|
static const char* kYUVFormatNames[] = { "AYUV", "NV12", "NV21", "I420", "YV12" };
|
GR_STATIC_ASSERT(SK_ARRAY_COUNT(kYUVFormatNames) == kLast_YUVFormat+1);
|
|
SkPaint paint;
|
SkFont font(sk_tool_utils::create_portable_typeface(nullptr, SkFontStyle::Bold()), 16);
|
font.setEdging(SkFont::Edging::kAlias);
|
|
SkRect textRect;
|
SkString rowLabel;
|
|
rowLabel.printf("%s", kYUVFormatNames[yuvFormat]);
|
font.measureText(rowLabel.c_str(), rowLabel.size(), kUTF8_SkTextEncoding, &textRect);
|
y += kTileWidthHeight/2 + textRect.height()/2;
|
|
canvas->drawString(rowLabel, 0, y, font, paint);
|
}
|
|
static GrBackendTexture create_yuva_texture(GrGpu* gpu, const SkBitmap& bm,
|
SkYUVAIndex yuvaIndices[4], int texIndex) {
|
SkASSERT(texIndex >= 0 && texIndex <= 3);
|
int channelCount = 0;
|
for (int i = 0; i < SkYUVAIndex::kIndexCount; ++i) {
|
if (yuvaIndices[i].fIndex == texIndex) {
|
++channelCount;
|
}
|
}
|
// Need to create an RG texture for two-channel planes
|
GrBackendTexture tex;
|
if (2 == channelCount) {
|
SkASSERT(kRGBA_8888_SkColorType == bm.colorType());
|
SkAutoTMalloc<char> pixels(2 * bm.width()*bm.height());
|
char* currPixel = pixels;
|
for (int y = 0; y < bm.height(); ++y) {
|
for (int x = 0; x < bm.width(); ++x) {
|
SkColor color = bm.getColor(x, y);
|
currPixel[0] = SkColorGetR(color);
|
currPixel[1] = SkColorGetG(color);
|
currPixel += 2;
|
}
|
}
|
tex = gpu->createTestingOnlyBackendTexture(
|
pixels,
|
bm.width(),
|
bm.height(),
|
GrColorType::kRG_88,
|
false,
|
GrMipMapped::kNo,
|
2*bm.width());
|
}
|
if (!tex.isValid()) {
|
tex = gpu->createTestingOnlyBackendTexture(
|
bm.getPixels(),
|
bm.width(),
|
bm.height(),
|
bm.colorType(),
|
false,
|
GrMipMapped::kNo,
|
bm.rowBytes());
|
}
|
return tex;
|
}
|
|
namespace skiagm {
|
|
// This GM creates an opaque and transparent bitmap, extracts the planes and then recombines
|
// them into various YUV formats. It then renders the results in the grid:
|
//
|
// JPEG 601 709
|
// Transparent Opaque Transparent Opaque Transparent Opaque
|
// AYUV
|
// NV12
|
// NV21
|
// I420
|
// YV12
|
class WackyYUVFormatsGM : public GM {
|
public:
|
WackyYUVFormatsGM(bool useTargetColorSpace) : fUseTargetColorSpace(useTargetColorSpace) {
|
this->setBGColor(0xFFCCCCCC);
|
}
|
|
protected:
|
|
SkString onShortName() override {
|
SkString name("wacky_yuv_formats");
|
if (fUseTargetColorSpace) {
|
name += "_cs";
|
}
|
return name;
|
}
|
|
SkISize onISize() override {
|
int numCols = 2 * (kLastEnum_SkYUVColorSpace + 1); // opacity x color-space
|
int numRows = 1 + (kLast_YUVFormat + 1); // origin + # yuv formats
|
return SkISize::Make(kLabelWidth + numCols * (kTileWidthHeight + kPad),
|
kLabelHeight + numRows * (kTileWidthHeight + kPad));
|
}
|
|
void onOnceBeforeDraw() override {
|
SkPoint origin = { kTileWidthHeight/2.0f, kTileWidthHeight/2.0f };
|
float outerRadius = kTileWidthHeight/2.0f - 20.0f;
|
float innerRadius = 20.0f;
|
|
{
|
// transparent
|
SkTDArray<SkRect> circles;
|
SkPath path = create_splat(origin, innerRadius, outerRadius, 1.0f, 5, &circles);
|
fOriginalBMs[0] = make_bitmap(path, circles, false);
|
}
|
|
{
|
// opaque
|
SkTDArray<SkRect> circles;
|
SkPath path = create_splat(origin, innerRadius, outerRadius, 1.0f, 7, &circles);
|
fOriginalBMs[1] = make_bitmap(path, circles, true);
|
}
|
|
if (fUseTargetColorSpace) {
|
fTargetColorSpace = SkColorSpace::MakeSRGB()->makeColorSpin();
|
}
|
}
|
|
void createImages(GrContext* context) {
|
int counter = 0;
|
for (bool opaque : { false, true }) {
|
for (int cs = kJPEG_SkYUVColorSpace; cs <= kLastEnum_SkYUVColorSpace; ++cs) {
|
PlaneData planes;
|
extract_planes(fOriginalBMs[opaque], (SkYUVColorSpace) cs, &planes);
|
|
for (int format = kAYUV_YUVFormat; format <= kLast_YUVFormat; ++format) {
|
SkBitmap resultBMs[4];
|
SkYUVAIndex yuvaIndices[4];
|
create_YUV(planes, (YUVFormat) format, resultBMs, yuvaIndices, opaque);
|
int numTextures;
|
if (!SkYUVAIndex::AreValidIndices(yuvaIndices, &numTextures)) {
|
continue;
|
}
|
|
if (context) {
|
if (context->abandoned()) {
|
return;
|
}
|
|
GrGpu* gpu = context->contextPriv().getGpu();
|
if (!gpu) {
|
return;
|
}
|
|
GrBackendTexture yuvaTextures[4];
|
SkPixmap yuvaPixmaps[4];
|
|
for (int i = 0; i < numTextures; ++i) {
|
yuvaTextures[i] = create_yuva_texture(gpu, resultBMs[i],
|
yuvaIndices, i);
|
if (yuvaTextures[i].isValid()) {
|
fBackendTextures.push_back(yuvaTextures[i]);
|
}
|
yuvaPixmaps[i] = resultBMs[i].pixmap();
|
}
|
|
int counterMod = counter % 3;
|
switch (counterMod) {
|
case 0:
|
fImages[opaque][cs][format] = SkImage::MakeFromYUVATexturesCopy(
|
context,
|
(SkYUVColorSpace)cs,
|
yuvaTextures,
|
yuvaIndices,
|
{ fOriginalBMs[opaque].width(), fOriginalBMs[opaque].height() },
|
kTopLeft_GrSurfaceOrigin);
|
break;
|
case 1:
|
fImages[opaque][cs][format] = SkImage::MakeFromYUVATextures(
|
context,
|
(SkYUVColorSpace)cs,
|
yuvaTextures,
|
yuvaIndices,
|
{ fOriginalBMs[opaque].width(), fOriginalBMs[opaque].height() },
|
kTopLeft_GrSurfaceOrigin);
|
break;
|
case 2:
|
default:
|
fImages[opaque][cs][format] = SkImage::MakeFromYUVAPixmaps(
|
context,
|
(SkYUVColorSpace)cs,
|
yuvaPixmaps,
|
yuvaIndices,
|
{ fOriginalBMs[opaque].width(), fOriginalBMs[opaque].height() },
|
kTopLeft_GrSurfaceOrigin, true);
|
break;
|
}
|
++counter;
|
} else {
|
fImages[opaque][cs][format] = make_yuv_gen_image(
|
fOriginalBMs[opaque].info(),
|
(SkYUVColorSpace) cs,
|
yuvaIndices,
|
resultBMs);
|
}
|
}
|
}
|
}
|
}
|
|
void onDraw(SkCanvas* canvas) override {
|
this->createImages(canvas->getGrContext());
|
|
int x = kLabelWidth;
|
for (int cs = kJPEG_SkYUVColorSpace; cs <= kLastEnum_SkYUVColorSpace; ++cs) {
|
for (int opaque : { 0, 1 }) {
|
int y = kLabelHeight;
|
|
draw_col_label(canvas, x+kTileWidthHeight/2, cs, opaque);
|
|
canvas->drawBitmap(fOriginalBMs[opaque], x, y);
|
y += kTileWidthHeight + kPad;
|
|
for (int format = kAYUV_YUVFormat; format <= kLast_YUVFormat; ++format) {
|
draw_row_label(canvas, y, format);
|
if (fUseTargetColorSpace && fImages[opaque][cs][format]) {
|
sk_sp<SkImage> csImage =
|
fImages[opaque][cs][format]->makeColorSpace(fTargetColorSpace);
|
canvas->drawImage(csImage, x, y);
|
} else {
|
canvas->drawImage(fImages[opaque][cs][format], x, y);
|
}
|
y += kTileWidthHeight + kPad;
|
}
|
|
x += kTileWidthHeight + kPad;
|
}
|
}
|
if (auto context = canvas->getGrContext()) {
|
if (!context->abandoned()) {
|
context->flush();
|
GrGpu* gpu = context->contextPriv().getGpu();
|
SkASSERT(gpu);
|
gpu->testingOnly_flushGpuAndSync();
|
for (const auto& tex : fBackendTextures) {
|
gpu->deleteTestingOnlyBackendTexture(tex);
|
}
|
fBackendTextures.reset();
|
}
|
}
|
SkASSERT(!fBackendTextures.count());
|
}
|
|
private:
|
SkBitmap fOriginalBMs[2];
|
sk_sp<SkImage> fImages[2][kLastEnum_SkYUVColorSpace + 1][kLast_YUVFormat + 1];
|
SkTArray<GrBackendTexture> fBackendTextures;
|
bool fUseTargetColorSpace;
|
sk_sp<SkColorSpace> fTargetColorSpace;
|
|
typedef GM INHERITED;
|
};
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
DEF_GM(return new WackyYUVFormatsGM(false);)
|
DEF_GM(return new WackyYUVFormatsGM(true);)
|
}
|
