#include "gm/gm.h"
#include "include/core/SkBitmap.h"
#include "include/core/SkBlendMode.h"
#include "include/core/SkCanvas.h"
#include "include/core/SkColor.h"
#include "include/core/SkColorFilter.h"
#include "include/core/SkColorPriv.h"
#include "include/core/SkColorSpace.h"
#include "include/core/SkFont.h"
#include "include/core/SkFontStyle.h"
#include "include/core/SkFontTypes.h"
#include "include/core/SkImage.h"
#include "include/core/SkImageGenerator.h"
#include "include/core/SkImageInfo.h"
#include "include/core/SkMatrix.h"
#include "include/core/SkPaint.h"
#include "include/core/SkPath.h"
#include "include/core/SkPixmap.h"
#include "include/core/SkPoint.h"
#include "include/core/SkRect.h"
#include "include/core/SkRefCnt.h"
#include "include/core/SkScalar.h"
#include "include/core/SkSize.h"
#include "include/core/SkString.h"
#include "include/core/SkTypeface.h"
#include "include/core/SkTypes.h"
#include "include/gpu/GrBackendSurface.h"
#include "include/gpu/GrDirectContext.h"
#include "include/gpu/GrRecordingContext.h"
#include "include/gpu/GrTypes.h"
#include "include/gpu/ganesh/SkImageGanesh.h"
#include "include/private/base/SkTArray.h"
#include "include/private/base/SkTDArray.h"
#include "include/private/base/SkTPin.h"
#include "include/private/base/SkTemplates.h"
#include "include/private/gpu/ganesh/GrTypesPriv.h"
#include "include/utils/SkTextUtils.h"
#include "src/base/SkHalf.h"
#include "src/core/SkConvertPixels.h"
#include "src/core/SkYUVMath.h"
#include "src/gpu/ganesh/GrCaps.h"
#include "src/gpu/ganesh/GrRecordingContextPriv.h"
#include "tools/DecodeUtils.h"
#include "tools/ToolUtils.h"
#include "tools/fonts/FontToolUtils.h"
#include "tools/gpu/YUVUtils.h"
#include <math.h>
#include <string.h>
#include <initializer_list>
#include <memory>
#include <utility>
#include <vector>
#include "include/effects/SkColorMatrix.h"
#include "src/core/SkAutoPixmapStorage.h"
#include "tools/Resources.h"

Classes
class	YUVAPlanarConfig

struct	PlaneData

class	skiagm::WackyYUVFormatsGM

class	skiagm::YUVMakeColorSpaceGM

class	YUVSplitterGM

Namespaces
namespace	skiagm

Typedefs
using	Recorder = skgpu::graphite::Recorder

Enumerations
enum	YUVFormat { kP016_YUVFormat , kP010_YUVFormat , kP016F_YUVFormat , kY416_YUVFormat , kAYUV_YUVFormat , kY410_YUVFormat , kNV12_YUVFormat , kNV21_YUVFormat , kI420_YUVFormat , kYV12_YUVFormat , kLast_YUVFormat = kYV12_YUVFormat }

Functions
static bool	has_alpha_channel (YUVFormat format)

static void	add_arc (SkPath path, const SkPoint &o1, const SkVector &v1, const SkPoint &o2, const SkVector &v2, SkTDArray< SkRect > circles, bool takeLongWayRound)

static SkPath	create_splat (const SkPoint &o, SkScalar innerRadius, SkScalar outerRadius, SkScalar ratio, int numLobes, SkTDArray< SkRect > *circles)

static SkBitmap	make_bitmap (SkColorType colorType, const SkPath &path, const SkTDArray< SkRect > &circles, bool opaque, bool padWithRed)

static void	convert_rgba_to_yuva (const float mtx[20], SkColor col, uint8_t yuv[4])

static void	extract_planes (const SkBitmap &origBM, SkYUVColorSpace yuvColorSpace, SkEncodedOrigin origin, PlaneData *planes)

static SkBitmap	make_quarter_2_channel (const SkBitmap &fullY, const SkBitmap &quarterU, const SkBitmap &quarterV, bool uv)

static SkBitmap	make_16 (const SkBitmap &src, SkColorType dstCT, std::function< void(uint16_t dstPixel, const float srcPixel)> convert)

static uint16_t	flt_2_uint16 (float flt)

static int	create_YUV (const PlaneData &planes, YUVFormat yuvFormat, SkBitmap resultBMs[], bool opaque)

static void	draw_col_label (SkCanvas *canvas, int x, int yuvColorSpace, bool opaque)

static void	draw_row_label (SkCanvas *canvas, int y, int yuvFormat)

static sk_sp< SkColorFilter >	yuv_to_rgb_colorfilter ()

	skiagm::DEF_GM (return new WackyYUVFormatsGM(false, false, false, WackyYUVFormatsGM::Type::kFromTextures);) DEF_GM(return new WackyYUVFormatsGM(false

	skiagm::DEF_GM (return new WackyYUVFormatsGM(true, false, false, WackyYUVFormatsGM::Type::kFromTextures);) DEF_GM(return new WackyYUVFormatsGM(false

	skiagm::DEF_GM (return new WackyYUVFormatsGM(false, false, false, WackyYUVFormatsGM::Type::kFromGenerator);) DEF_GM(return new WackyYUVFormatsGM(false

static void	draw_diff (SkCanvas canvas, SkScalar x, SkScalar y, const SkImage a, const SkImage *b)

Variables
static const int	kTileWidthHeight = 128

static const int	kLabelWidth = 64

static const int	kLabelHeight = 32

static const int	kSubsetPadding = 8

static const int	kPad = 1

const SkYUVColorSpace	color_space_array []

	skiagm::true

	skiagm::false

Typedef Documentation

◆ Recorder

using Recorder = skgpu::graphite::Recorder

Definition at line 68 of file wacky_yuv_formats.cpp.

Enumeration Type Documentation

◆ YUVFormat

enum YUVFormat

Enumerator
kP016_YUVFormat
kP010_YUVFormat
kP016F_YUVFormat
kY416_YUVFormat
kAYUV_YUVFormat
kY410_YUVFormat
kNV12_YUVFormat
kNV21_YUVFormat
kI420_YUVFormat
kYV12_YUVFormat
kLast_YUVFormat

Definition at line 70 of file wacky_yuv_formats.cpp.

               {
    // 4:2:0 formats, 24 bpp
    kP016_YUVFormat, // 16-bit Y plane + 2x2 down sampled interleaved U/V plane (2 textures)
    // 4:2:0 formats, "15 bpp" (but really 24 bpp)
    kP010_YUVFormat, // same as kP016 except "10 bpp". Note that it is the same memory layout
                     // except that the bottom 6 bits are zeroed out (2 textures)
    // TODO: we're cheating a bit w/ P010 and just treating it as unorm 16. This means its
    // fully saturated values are 65504 rather than 65535 (that is just .9995 out of 1.0 though).
 
    // This is laid out the same as kP016 and kP010 but uses F16 unstead of U16. In this case
    // the 10 bits/channel vs 16 bits/channel distinction isn't relevant.
    kP016F_YUVFormat,
 
    // 4:4:4 formats, 64 bpp
    kY416_YUVFormat,  // 16-bit AVYU values all interleaved (1 texture)
 
    // 4:4:4 formats, 32 bpp
    kAYUV_YUVFormat,  // 8-bit YUVA values all interleaved (1 texture)
    kY410_YUVFormat,  // AVYU w/ 10bpp for YUV and 2 for A all interleaved (1 texture)
 
    // 4:2:0 formats, 12 bpp
    kNV12_YUVFormat, // 8-bit Y plane + 2x2 down sampled interleaved U/V planes (2 textures)
    kNV21_YUVFormat, // same as kNV12 but w/ U/V reversed in the interleaved texture (2 textures)
 
    kI420_YUVFormat, // 8-bit Y plane + separate 2x2 down sampled U and V planes (3 textures)
    kYV12_YUVFormat, // 8-bit Y plane + separate 2x2 down sampled V and U planes (3 textures)
 
    kLast_YUVFormat = kYV12_YUVFormat
};

Function Documentation

◆ add_arc()

static void add_arc	(	SkPath *	path,
		const SkPoint &	o1,
		const SkVector &	v1,
		const SkPoint &	o2,
		const SkVector &	v2,
		SkTDArray< SkRect > *	circles,
		bool	takeLongWayRound
	)

static

Definition at line 248 of file wacky_yuv_formats.cpp.

                                                                       {
 
    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);
}

◆ convert_rgba_to_yuva()

static void convert_rgba_to_yuva	(	const float	mtx[20],
		SkColor	col,
		uint8_t	yuv[4]
	)

static

Definition at line 397 of file wacky_yuv_formats.cpp.

                                                                                   {
    const uint8_t r = SkColorGetR(col);
    const uint8_t g = SkColorGetG(col);
    const uint8_t b = SkColorGetB(col);
 
    yuv[0] = SkTPin(SkScalarRoundToInt(mtx[ 0]*r + mtx[ 1]*g + mtx[ 2]*b + mtx[ 4]*255), 0, 255);
    yuv[1] = SkTPin(SkScalarRoundToInt(mtx[ 5]*r + mtx[ 6]*g + mtx[ 7]*b + mtx[ 9]*255), 0, 255);
    yuv[2] = SkTPin(SkScalarRoundToInt(mtx[10]*r + mtx[11]*g + mtx[12]*b + mtx[14]*255), 0, 255);
    yuv[3] = SkColorGetA(col);
}

◆ create_splat()

static SkPath create_splat	(	const SkPoint &	o,
		SkScalar	innerRadius,
		SkScalar	outerRadius,
		SkScalar	ratio,
		int	numLobes,
		SkTDArray< SkRect > *	circles
	)

static

Definition at line 290 of file wacky_yuv_formats.cpp.

                                                                                     {
    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;
}

◆ create_YUV()

static int create_YUV	(	const PlaneData &	planes,
		YUVFormat	yuvFormat,
		SkBitmap	resultBMs[],
		bool	opaque
	)

static

Definition at line 566 of file wacky_yuv_formats.cpp.

                                   {
    int nextLayer = 0;
 
    switch (yuvFormat) {
        case kY416_YUVFormat: {
            resultBMs[nextLayer++] = make_16(planes.fFull, kR16G16B16A16_unorm_SkColorType,
                                             [] (uint16_t* dstPixel, const float* srcPixel) {
                                                 dstPixel[0] = flt_2_uint16(srcPixel[1]); // U
                                                 dstPixel[1] = flt_2_uint16(srcPixel[0]); // Y
                                                 dstPixel[2] = flt_2_uint16(srcPixel[2]); // V
                                                 dstPixel[3] = flt_2_uint16(srcPixel[3]); // A
                                             });
            break;
        }
        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
                    SkColor c = SkColorSetARGB(A, V, U, Y);
                    *yuvaFull.getAddr32(x, y) = c;
                }
            }
 
            resultBMs[nextLayer++] = yuvaFull;
            break;
        }
        case kY410_YUVFormat: {
            SkBitmap yuvaFull;
            uint32_t Y, U, V;
            uint8_t A;
 
            yuvaFull.allocPixels(SkImageInfo::Make(planes.fYFull.width(), planes.fYFull.height(),
                                                   kRGBA_1010102_SkColorType,
                                                   kUnpremul_SkAlphaType));
 
            for (int y = 0; y < planes.fYFull.height(); ++y) {
                for (int x = 0; x < planes.fYFull.width(); ++x) {
 
                    Y = SkScalarRoundToInt((*planes.fYFull.getAddr8(x, y) / 255.0f) * 1023.0f);
                    U = SkScalarRoundToInt((*planes.fUFull.getAddr8(x, y) / 255.0f) * 1023.0f);
                    V = SkScalarRoundToInt((*planes.fVFull.getAddr8(x, y) / 255.0f) * 1023.0f);
                    A = SkScalarRoundToInt((*planes.fAFull.getAddr8(x, y) / 255.0f) * 3.0f);
 
                    // NOT premul!
                    *yuvaFull.getAddr32(x, y) = (A << 30) | (V << 20) | (Y << 10) | (U << 0);
                }
            }
 
            resultBMs[nextLayer++] = yuvaFull;
            break;
        }
        case kP016_YUVFormat:     // fall through
        case kP010_YUVFormat: {
            resultBMs[nextLayer++] = make_16(planes.fFull, kA16_unorm_SkColorType,
                                             [tenBitsPP = (yuvFormat == kP010_YUVFormat)]
                                             (uint16_t* dstPixel, const float* srcPixel) {
                                                 uint16_t val16 = flt_2_uint16(srcPixel[0]);
                                                 dstPixel[0] = tenBitsPP ? (val16 & 0xFFC0)
                                                                         : val16;
                                              });
            resultBMs[nextLayer++] = make_16(planes.fQuarter, kR16G16_unorm_SkColorType,
                                             [tenBitsPP = (yuvFormat == kP010_YUVFormat)]
                                             (uint16_t* dstPixel, const float* srcPixel) {
                                                 uint16_t u16 = flt_2_uint16(srcPixel[1]);
                                                 uint16_t v16 = flt_2_uint16(srcPixel[2]);
                                                 dstPixel[0] = tenBitsPP ? (u16 & 0xFFC0) : u16;
                                                 dstPixel[1] = tenBitsPP ? (v16 & 0xFFC0) : v16;
                                             });
            if (!opaque) {
                resultBMs[nextLayer++] = make_16(planes.fFull, kA16_unorm_SkColorType,
                                                 [tenBitsPP = (yuvFormat == kP010_YUVFormat)]
                                                 (uint16_t* dstPixel, const float* srcPixel) {
                                                     uint16_t val16 = flt_2_uint16(srcPixel[3]);
                                                     dstPixel[0] = tenBitsPP ? (val16 & 0xFFC0)
                                                                             : val16;
                                                 });
            }
            return nextLayer;
        }
        case kP016F_YUVFormat: {
            resultBMs[nextLayer++] = make_16(planes.fFull, kA16_float_SkColorType,
                                             [] (uint16_t* dstPixel, const float* srcPixel) {
                                                 dstPixel[0] = SkFloatToHalf(srcPixel[0]);
                                             });
            resultBMs[nextLayer++] = make_16(planes.fQuarter, kR16G16_float_SkColorType,
                                             [] (uint16_t* dstPixel, const float* srcPixel) {
                                                 dstPixel[0] = SkFloatToHalf(srcPixel[1]);
                                                 dstPixel[1] = SkFloatToHalf(srcPixel[2]);
                                             });
            if (!opaque) {
                resultBMs[nextLayer++] = make_16(planes.fFull, kA16_float_SkColorType,
                                                 [] (uint16_t* dstPixel, const float* srcPixel) {
                                                     dstPixel[0] = SkFloatToHalf(srcPixel[3]);
                                                 });
            }
            return nextLayer;
        }
        case kNV12_YUVFormat: {
            SkBitmap uvQuarter = make_quarter_2_channel(planes.fYFull,
                                                        planes.fUQuarter,
                                                        planes.fVQuarter, true);
            resultBMs[nextLayer++] = planes.fYFull;
            resultBMs[nextLayer++] = uvQuarter;
            break;
        }
        case kNV21_YUVFormat: {
            SkBitmap vuQuarter = make_quarter_2_channel(planes.fYFull,
                                                        planes.fUQuarter,
                                                        planes.fVQuarter, false);
            resultBMs[nextLayer++] = planes.fYFull;
            resultBMs[nextLayer++] = vuQuarter;
            break;
        }
        case kI420_YUVFormat:
            resultBMs[nextLayer++] = planes.fYFull;
            resultBMs[nextLayer++] = planes.fUQuarter;
            resultBMs[nextLayer++] = planes.fVQuarter;
            break;
        case kYV12_YUVFormat:
            resultBMs[nextLayer++] = planes.fYFull;
            resultBMs[nextLayer++] = planes.fVQuarter;
            resultBMs[nextLayer++] = planes.fUQuarter;
            break;
    }
 
    if (!opaque && !has_alpha_channel(yuvFormat)) {
        resultBMs[nextLayer++] = planes.fAFull;
    }
    return nextLayer;
}

◆ draw_col_label()

static void draw_col_label	(	SkCanvas *	canvas,
		int	x,
		int	yuvColorSpace,
		bool	opaque
	)

static

Definition at line 712 of file wacky_yuv_formats.cpp.

                                                                                    {
    static const char* kYUVColorSpaceNames[] = {"JPEG",     "601",      "709F",     "709L",
                                                "2020_8F",  "2020_8L",  "2020_10L", "2020_12F",
                                                "FCCL",     "SMPTE240L","YDZDXL",   "GBRL",
                                                "YCGCO_8F", "YCGCO_8L", "YCGCO_10F","YCGCO_12F",
                                                "YCGCO_12L","Identity"};
    static_assert(std::size(kYUVColorSpaceNames) == std::size(color_space_array));
 
    SkPaint paint;
    SkFont  font(ToolUtils::CreatePortableTypeface("Sans", SkFontStyle::Bold()), 16);
    font.setEdging(SkFont::Edging::kAlias);
 
    SkRect textRect;
    SkString colLabel;
 
    colLabel.printf("%s", kYUVColorSpaceNames[yuvColorSpace]);
    font.measureText(colLabel.c_str(), colLabel.size(), SkTextEncoding::kUTF8, &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(), SkTextEncoding::kUTF8, &textRect);
    y += textRect.height();
 
    SkTextUtils::DrawString(canvas, colLabel.c_str(), x, y, font, paint, SkTextUtils::kCenter_Align);
}

◆ draw_diff()

static void draw_diff	(	SkCanvas *	canvas,
		SkScalar	x,
		SkScalar	y,
		const SkImage *	a,
		const SkImage *	b
	)

static

Definition at line 1227 of file wacky_yuv_formats.cpp.

                                                          {
    auto sh = SkShaders::Blend(SkBlendMode::kDifference,
                               a->makeShader(SkSamplingOptions()),
                               b->makeShader(SkSamplingOptions()));
    SkPaint paint;
    paint.setShader(sh);
    canvas->save();
    canvas->translate(x, y);
    canvas->drawRect(SkRect::MakeWH(a->width(), a->height()), paint);
 
    SkColorMatrix cm;
    cm.setScale(64, 64, 64);
    paint.setShader(sh->makeWithColorFilter(SkColorFilters::Matrix(cm)));
    canvas->translate(0, a->height());
    canvas->drawRect(SkRect::MakeWH(a->width(), a->height()), paint);
 
    canvas->restore();
}

◆ draw_row_label()

static void draw_row_label	(	SkCanvas *	canvas,
		int	y,
		int	yuvFormat
	)

static

Definition at line 741 of file wacky_yuv_formats.cpp.

                                                                   {
    static const char* kYUVFormatNames[] = {
        "P016", "P010", "P016F", "Y416", "AYUV", "Y410", "NV12", "NV21", "I420", "YV12"
    };
    static_assert(std::size(kYUVFormatNames) == kLast_YUVFormat + 1);
 
    SkPaint paint;
    SkFont  font(ToolUtils::CreatePortableTypeface("Sans", SkFontStyle::Bold()), 16);
    font.setEdging(SkFont::Edging::kAlias);
 
    SkRect textRect;
    SkString rowLabel;
 
    rowLabel.printf("%s", kYUVFormatNames[yuvFormat]);
    font.measureText(rowLabel.c_str(), rowLabel.size(), SkTextEncoding::kUTF8, &textRect);
    y += kTileWidthHeight/2 + textRect.height()/2;
 
    canvas->drawString(rowLabel, 0, y, font, paint);
}

◆ extract_planes()

static void extract_planes	(	const SkBitmap &	origBM,
		SkYUVColorSpace	yuvColorSpace,
		SkEncodedOrigin	origin,
		PlaneData *	planes
	)

static

Definition at line 408 of file wacky_yuv_formats.cpp.

                                              {
    SkImageInfo ii = origBM.info();
    if (SkEncodedOriginSwapsWidthHeight(origin)) {
        ii = ii.makeWH(ii.height(), ii.width());
    }
    SkBitmap orientedBM;
    orientedBM.allocPixels(ii);
    SkCanvas canvas(orientedBM);
    SkMatrix matrix = SkEncodedOriginToMatrix(origin, origBM.width(), origBM.height());
    SkAssertResult(matrix.invert(&matrix));
    canvas.concat(matrix);
    canvas.drawImage(origBM.asImage(), 0, 0);
 
    if (yuvColorSpace == kIdentity_SkYUVColorSpace) {
        // To test the identity color space we use JPEG YUV planes
        yuvColorSpace = kJPEG_SkYUVColorSpace;
    }
 
    SkASSERT(!(ii.width() % 2));
    SkASSERT(!(ii.height() % 2));
    planes->fYFull.allocPixels(
            SkImageInfo::Make(ii.dimensions(), kGray_8_SkColorType, kUnpremul_SkAlphaType));
    planes->fUFull.allocPixels(
            SkImageInfo::Make(ii.dimensions(), kGray_8_SkColorType, kUnpremul_SkAlphaType));
    planes->fVFull.allocPixels(
            SkImageInfo::Make(ii.dimensions(), kGray_8_SkColorType, kUnpremul_SkAlphaType));
    planes->fAFull.allocPixels(SkImageInfo::MakeA8(ii.dimensions()));
    planes->fUQuarter.allocPixels(SkImageInfo::Make(ii.width()/2, ii.height()/2,
                                  kGray_8_SkColorType, kUnpremul_SkAlphaType));
    planes->fVQuarter.allocPixels(SkImageInfo::Make(ii.width()/2, ii.height()/2,
                                  kGray_8_SkColorType, kUnpremul_SkAlphaType));
 
    planes->fFull.allocPixels(
            SkImageInfo::Make(ii.dimensions(), kRGBA_F32_SkColorType, kUnpremul_SkAlphaType));
    planes->fQuarter.allocPixels(SkImageInfo::Make(ii.width()/2, ii.height()/2,
                                 kRGBA_F32_SkColorType, kUnpremul_SkAlphaType));
 
    float mtx[20];
    SkColorMatrix_RGB2YUV(yuvColorSpace, mtx);
 
    SkColor4f* dst = (SkColor4f *) planes->fFull.getAddr(0, 0);
    for (int y = 0; y < orientedBM.height(); ++y) {
        for (int x = 0; x < orientedBM.width(); ++x) {
            SkColor col = orientedBM.getColor(x, y);
 
            uint8_t yuva[4];
 
            convert_rgba_to_yuva(mtx, 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];
 
            // TODO: render in F32 rather than converting here
            dst->fR = yuva[0] / 255.0f;
            dst->fG = yuva[1] / 255.0f;
            dst->fB = yuva[2] / 255.0f;
            dst->fA = yuva[3] / 255.0f;
            ++dst;
        }
    }
 
    dst = (SkColor4f *) planes->fQuarter.getAddr(0, 0);
    for (int y = 0; y < orientedBM.height()/2; ++y) {
        for (int x = 0; x < orientedBM.width()/2; ++x) {
            uint32_t yAccum = 0, uAccum = 0, vAccum = 0, aAccum = 0;
 
            yAccum += *planes->fYFull.getAddr8(2*x, 2*y);
            yAccum += *planes->fYFull.getAddr8(2*x+1, 2*y);
            yAccum += *planes->fYFull.getAddr8(2*x, 2*y+1);
            yAccum += *planes->fYFull.getAddr8(2*x+1, 2*y+1);
 
            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;
 
            aAccum += *planes->fAFull.getAddr8(2*x, 2*y);
            aAccum += *planes->fAFull.getAddr8(2*x+1, 2*y);
            aAccum += *planes->fAFull.getAddr8(2*x, 2*y+1);
            aAccum += *planes->fAFull.getAddr8(2*x+1, 2*y+1);
 
            // TODO: render in F32 rather than converting here
            dst->fR = yAccum / (4.0f * 255.0f);
            dst->fG = uAccum / (4.0f * 255.0f);
            dst->fB = vAccum / (4.0f * 255.0f);
            dst->fA = aAccum / (4.0f * 255.0f);
            ++dst;
        }
    }
}

◆ flt_2_uint16()

static uint16_t flt_2_uint16 ( float flt )

static

Definition at line 563 of file wacky_yuv_formats.cpp.

563{ return SkScalarRoundToInt(flt * 65535.0f); }

◆ has_alpha_channel()

static bool has_alpha_channel ( YUVFormat format )

static

Definition at line 102 of file wacky_yuv_formats.cpp.

                                                {
    switch (format) {
        case kP016_YUVFormat:  return false;
        case kP010_YUVFormat:  return false;
        case kP016F_YUVFormat: return false;
        case kY416_YUVFormat:  return true;
        case kAYUV_YUVFormat:  return true;
        case kY410_YUVFormat:  return true;
        case kNV12_YUVFormat:  return false;
        case kNV21_YUVFormat:  return false;
        case kI420_YUVFormat:  return false;
        case kYV12_YUVFormat:  return false;
    }
    SkUNREACHABLE;
}

◆ make_16()

static SkBitmap make_16	(	const SkBitmap &	src,
		SkColorType	dstCT,
		std::function< void(uint16_t dstPixel, const float srcPixel)>	convert
	)

static

Definition at line 543 of file wacky_yuv_formats.cpp.

                                                                                              {
    SkASSERT(src.colorType() == kRGBA_F32_SkColorType);
 
    SkBitmap result;
 
    result.allocPixels(SkImageInfo::Make(src.dimensions(), dstCT, kUnpremul_SkAlphaType));
 
    for (int y = 0; y < src.height(); ++y) {
        for (int x = 0; x < src.width(); ++x) {
            const float* srcPixel = (const float*) src.getAddr(x, y);
            uint16_t* dstPixel = (uint16_t*) result.getAddr(x, y);
 
            convert(dstPixel, srcPixel);
        }
    }
 
    return result;
}

◆ make_bitmap()

static SkBitmap make_bitmap	(	SkColorType	colorType,
		const SkPath &	path,
		const SkTDArray< SkRect > &	circles,
		bool	opaque,
		bool	padWithRed
	)

static

Definition at line 347 of file wacky_yuv_formats.cpp.

                                                                                            {
    const SkColor kGreen   = ToolUtils::color_to_565(SkColorSetARGB(0xFF, 178, 240, 104));
    const SkColor kBlue    = ToolUtils::color_to_565(SkColorSetARGB(0xFF, 173, 167, 252));
    const SkColor kYellow  = ToolUtils::color_to_565(SkColorSetARGB(0xFF, 255, 221, 117));
    const SkColor kMagenta = ToolUtils::color_to_565(SkColorSetARGB(0xFF, 255,  60, 217));
    const SkColor kCyan    = ToolUtils::color_to_565(SkColorSetARGB(0xFF,  45, 237, 205));
 
    int widthHeight = kTileWidthHeight + (padWithRed ? 2 * kSubsetPadding : 0);
 
    SkImageInfo ii = SkImageInfo::Make(widthHeight, widthHeight,
                                       colorType, kPremul_SkAlphaType);
 
    SkBitmap bm;
    bm.allocPixels(ii);
 
    std::unique_ptr<SkCanvas> canvas = SkCanvas::MakeRasterDirect(ii,
                                                                  bm.getPixels(),
                                                                  bm.rowBytes());
    if (padWithRed) {
        canvas->clear(SK_ColorRED);
        canvas->translate(kSubsetPadding, kSubsetPadding);
        canvas->clipRect(SkRect::MakeWH(kTileWidthHeight, kTileWidthHeight));
    }
    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.setBlendMode(SkBlendMode::kSrc);
    for (int i = 0; i < circles.size(); ++i) {
        SkColor color;
        switch (i % 3) {
            case 0:  color = kYellow;  break;
            case 1:  color = kMagenta; break;
            default: color = kCyan;    break;
        }
        paint.setColor(color);
        paint.setAlpha(opaque ? 0xFF : 0x40);
        SkRect r = circles[i];
        r.inset(r.width()/4, r.height()/4);
        canvas->drawOval(r, paint);
    }
 
    return bm;
}

◆ make_quarter_2_channel()

static SkBitmap make_quarter_2_channel	(	const SkBitmap &	fullY,
		const SkBitmap &	quarterU,
		const SkBitmap &	quarterV,
		bool	uv
	)

static

Definition at line 515 of file wacky_yuv_formats.cpp.

                                                {
    SkBitmap result;
 
    result.allocPixels(SkImageInfo::Make(fullY.width()/2,
                                         fullY.height()/2,
                                         kR8G8_unorm_SkColorType,
                                         kUnpremul_SkAlphaType));
 
    for (int y = 0; y < fullY.height()/2; ++y) {
        for (int x = 0; x < fullY.width()/2; ++x) {
            uint8_t u8 = *quarterU.getAddr8(x, y);
            uint8_t v8 = *quarterV.getAddr8(x, y);
 
            if (uv) {
                *result.getAddr16(x, y) = (v8 << 8) | u8;
            } else {
                *result.getAddr16(x, y) = (u8 << 8) | v8;
            }
        }
    }
 
    return result;
}

◆ yuv_to_rgb_colorfilter()

static sk_sp< SkColorFilter > yuv_to_rgb_colorfilter ( )

static

Definition at line 761 of file wacky_yuv_formats.cpp.

                                                     {
    static const float kJPEGConversionMatrix[20] = {
        1.0f,  0.0f,       1.402f,    0.0f, -180.0f/255,
        1.0f, -0.344136f, -0.714136f, 0.0f,  136.0f/255,
        1.0f,  1.772f,     0.0f,      0.0f, -227.6f/255,
        0.0f,  0.0f,       0.0f,      1.0f,    0.0f
    };
 
    return SkColorFilters::Matrix(kJPEGConversionMatrix);
}

Variable Documentation

◆ color_space_array

const SkYUVColorSpace color_space_array[]

Initial value:

= {
    kJPEG_Full_SkYUVColorSpace,                 
    kRec601_Limited_SkYUVColorSpace,            
    kRec709_Full_SkYUVColorSpace,               
    kRec709_Limited_SkYUVColorSpace,
    kBT2020_8bit_Full_SkYUVColorSpace,          
    kBT2020_8bit_Limited_SkYUVColorSpace,
    kBT2020_10bit_Limited_SkYUVColorSpace,
    kBT2020_12bit_Full_SkYUVColorSpace,
    kFCC_Limited_SkYUVColorSpace,               
    kSMPTE240_Limited_SkYUVColorSpace,          
    kYDZDX_Limited_SkYUVColorSpace,             
    kGBR_Limited_SkYUVColorSpace,               
    kYCgCo_8bit_Full_SkYUVColorSpace,           
    kYCgCo_8bit_Limited_SkYUVColorSpace,
    kYCgCo_10bit_Full_SkYUVColorSpace,
    kYCgCo_12bit_Full_SkYUVColorSpace,
    kYCgCo_12bit_Limited_SkYUVColorSpace,
    kIdentity_SkYUVColorSpace
}

Definition at line 225 of file wacky_yuv_formats.cpp.

                                            {
    kJPEG_Full_SkYUVColorSpace,                 //!< describes full range
    kRec601_Limited_SkYUVColorSpace,            //!< describes SDTV range
    kRec709_Full_SkYUVColorSpace,               //!< describes HDTV range
    kRec709_Limited_SkYUVColorSpace,
    kBT2020_8bit_Full_SkYUVColorSpace,          //!< describes UHDTV range, non-constant-luminance
    kBT2020_8bit_Limited_SkYUVColorSpace,
    kBT2020_10bit_Limited_SkYUVColorSpace,
    kBT2020_12bit_Full_SkYUVColorSpace,
    kFCC_Limited_SkYUVColorSpace,               //!< describes FCC range
    kSMPTE240_Limited_SkYUVColorSpace,          //!< describes SMPTE240M range
    kYDZDX_Limited_SkYUVColorSpace,             //!< describes YDZDX range
    kGBR_Limited_SkYUVColorSpace,               //!< describes GBR range
    kYCgCo_8bit_Full_SkYUVColorSpace,           //!< describes YCgCo matrix
    kYCgCo_8bit_Limited_SkYUVColorSpace,
    kYCgCo_10bit_Full_SkYUVColorSpace,
    kYCgCo_12bit_Full_SkYUVColorSpace,
    kYCgCo_12bit_Limited_SkYUVColorSpace,
    kIdentity_SkYUVColorSpace
};

◆ kLabelHeight

const int kLabelHeight = 32

static

Definition at line 64 of file wacky_yuv_formats.cpp.

◆ kLabelWidth

const int kLabelWidth = 64

static

Definition at line 63 of file wacky_yuv_formats.cpp.

◆ kPad

const int kPad = 1

static

Definition at line 66 of file wacky_yuv_formats.cpp.

◆ kSubsetPadding

const int kSubsetPadding = 8

static

Definition at line 65 of file wacky_yuv_formats.cpp.

◆ kTileWidthHeight

const int kTileWidthHeight = 128

static

Definition at line 62 of file wacky_yuv_formats.cpp.

Classes

Namespaces

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ Recorder

Enumeration Type Documentation

◆ YUVFormat

Function Documentation

◆ add_arc()

◆ convert_rgba_to_yuva()

◆ create_splat()

◆ create_YUV()

◆ draw_col_label()

◆ draw_diff()

◆ draw_row_label()

◆ extract_planes()

◆ flt_2_uint16()

◆ has_alpha_channel()

◆ make_16()

◆ make_bitmap()

◆ make_quarter_2_channel()

◆ yuv_to_rgb_colorfilter()

Variable Documentation

◆ color_space_array

◆ kLabelHeight

◆ kLabelWidth

◆ kPad

◆ kSubsetPadding

◆ kTileWidthHeight