skiagm::YUVMakeColorSpaceGM Class Reference

Inheritance diagram for skiagm::YUVMakeColorSpaceGM:

Public Member Functions
	YUVMakeColorSpaceGM ()
Public Member Functions inherited from skiagm::GM
	GM (SkColor backgroundColor=SK_ColorWHITE)
virtual	~GM ()
void	setMode (Mode mode)
Mode	getMode () const
DrawResult	gpuSetup (SkCanvas *, SkString *errorMsg, GraphiteTestContext *=nullptr)
void	gpuTeardown ()
void	onceBeforeDraw ()
DrawResult	draw (SkCanvas *canvas)
DrawResult	draw (SkCanvas *, SkString *errorMsg)
void	drawBackground (SkCanvas *)
DrawResult	drawContent (SkCanvas *canvas)
DrawResult	drawContent (SkCanvas *, SkString *errorMsg)
virtual SkISize	getISize ()=0
virtual SkString	getName () const =0
virtual bool	runAsBench () const
SkScalar	width ()
SkScalar	height ()
SkColor	getBGColor () const
void	setBGColor (SkColor)
void	drawSizeBounds (SkCanvas *, SkColor)
bool	animate (double)
virtual bool	onChar (SkUnichar)
bool	getControls (SkMetaData *controls)
void	setControls (const SkMetaData &controls)
virtual void	modifyGrContextOptions (GrContextOptions *)
virtual void	modifyGraphiteContextOptions (skgpu::graphite::ContextOptions *) const
virtual bool	isBazelOnly () const
virtual std::map< std::string, std::string >	getGoldKeys () const

Protected Member Functions
SkString	getName () const override
SkISize	getISize () override
void	createBitmaps ()
bool	createImages (GrDirectContext *context)
DrawResult	onGpuSetup (SkCanvas *canvas, SkString *errorMsg, GraphiteTestContext *) override
void	onGpuTeardown () override
DrawResult	onDraw (SkCanvas *canvas, SkString *msg) override
Protected Member Functions inherited from skiagm::GM
virtual DrawResult	onGpuSetup (SkCanvas *, SkString *, GraphiteTestContext *)
virtual void	onGpuTeardown ()
virtual void	onOnceBeforeDraw ()
virtual DrawResult	onDraw (SkCanvas *, SkString *errorMsg)
virtual void	onDraw (SkCanvas *)
virtual bool	onAnimate (double)
virtual bool	onGetControls (SkMetaData *)
virtual void	onSetControls (const SkMetaData &)
GraphiteTestContext *	graphiteTestContext () const

Additional Inherited Members
Public Types inherited from skiagm::GM
enum	Mode { kGM_Mode , kSample_Mode , kBench_Mode }
using	DrawResult = skiagm::DrawResult
using	GraphiteTestContext = skiatest::graphite::GraphiteTestContext
Static Public Attributes inherited from skiagm::GM
static constexpr char	kErrorMsg_DrawSkippedGpuOnly []

Detailed Description

Definition at line 1065 of file wacky_yuv_formats.cpp.

Constructor & Destructor Documentation

YUVMakeColorSpaceGM()

skiagm::YUVMakeColorSpaceGM::YUVMakeColorSpaceGM ( )

inline

Definition at line 1067 of file wacky_yuv_formats.cpp.

                          {
        this->setBGColor(0xFFCCCCCC);
    }

Member Function Documentation

createBitmaps()

void skiagm::YUVMakeColorSpaceGM::createBitmaps ( )

inlineprotected

Definition at line 1081 of file wacky_yuv_formats.cpp.

                         {
        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(kN32_SkColorType, path, circles, false, false);
        }
 
        {
            // opaque
            SkTDArray<SkRect> circles;
            SkPath path = create_splat(origin, innerRadius, outerRadius, 1.0f, 7, &circles);
            fOriginalBMs[1] = make_bitmap(kN32_SkColorType, path, circles, true, false);
        }
 
        fTargetColorSpace = SkColorSpace::MakeSRGB()->makeColorSpin();
    }

createImages()

bool skiagm::YUVMakeColorSpaceGM::createImages ( GrDirectContext *  context )

inlineprotected

Definition at line 1103 of file wacky_yuv_formats.cpp.

                                                {
        for (bool opaque : { false, true }) {
            PlaneData planes;
            extract_planes(fOriginalBMs[opaque],
                           kJPEG_SkYUVColorSpace,
                           kTopLeft_SkEncodedOrigin,
                           &planes);
 
            SkBitmap resultBMs[4];
 
            create_YUV(planes, kAYUV_YUVFormat, resultBMs, opaque);
 
            YUVAPlanarConfig planarConfig(kAYUV_YUVFormat, opaque, kTopLeft_SkEncodedOrigin);
 
            auto yuvaPixmaps = planarConfig.makeYUVAPixmaps(fOriginalBMs[opaque].dimensions(),
                                                            kJPEG_Full_SkYUVColorSpace,
                                                            resultBMs,
                                                            std::size(resultBMs));
 
            int i = 0;
            for (sk_sp<SkColorSpace> cs : {sk_sp<SkColorSpace>(nullptr),
                                           SkColorSpace::MakeSRGB()}) {
                auto lazyYUV = sk_gpu_test::LazyYUVImage::Make(
                        yuvaPixmaps, skgpu::Mipmapped::kNo, std::move(cs));
                fImages[opaque][i++] =
                        lazyYUV->refImage(context, sk_gpu_test::LazyYUVImage::Type::kFromTextures);
            }
        }
 
        // Some backends (e.g., Vulkan) require all work be completed for backend textures before
        // they are deleted. Since we don't know when we'll next have access to a direct context,
        // flush all the work now.
        context->flush();
        context->submit(GrSyncCpu::kYes);
 
        return true;
    }

getISize()

SkISize skiagm::YUVMakeColorSpaceGM::getISize ( )

inlineoverrideprotectedvirtual

Implements skiagm::GM.

Definition at line 1074 of file wacky_yuv_formats.cpp.

                                {
        int numCols = 4; // (transparent, opaque) x (untagged, tagged)
        int numRows = 5; // original, YUV, subset, makeNonTextureImage, readPixels
        return SkISize::Make(numCols * (kTileWidthHeight + kPad) + kPad,
                             numRows * (kTileWidthHeight + kPad) + kPad);
    }

getName()

SkString skiagm::YUVMakeColorSpaceGM::getName ( ) const

inlineoverrideprotectedvirtual

Implements skiagm::GM.

Definition at line 1072 of file wacky_yuv_formats.cpp.

{ return SkString("yuv_make_color_space"); }

onDraw()

DrawResult skiagm::YUVMakeColorSpaceGM::onDraw ( SkCanvas *  canvas, SkString *  msg  )

inlineoverrideprotectedvirtual

Reimplemented from skiagm::GM.

Definition at line 1161 of file wacky_yuv_formats.cpp.

                                                                {
        SkASSERT(fImages[0][0] && fImages[0][1] && fImages[1][0] && fImages[1][1]);
 
        auto dContext = GrAsDirectContext(canvas->recordingContext());
        if (!dContext) {
            *msg = "YUV ColorSpace image creation requires a direct context.";
            return DrawResult::kSkip;
        }
 
        int x = kPad;
        for (int tagged : { 0, 1 }) {
            for (int opaque : { 0, 1 }) {
                int y = kPad;
 
                auto raster = fOriginalBMs[opaque].asImage()->makeColorSpace(
                      nullptr, fTargetColorSpace);
                canvas->drawImage(raster, x, y);
                y += kTileWidthHeight + kPad;
 
                if (fImages[opaque][tagged]) {
                    auto yuv = fImages[opaque][tagged]->makeColorSpace(dContext, fTargetColorSpace);
                    SkASSERT(yuv);
                    SkASSERT(SkColorSpace::Equals(yuv->colorSpace(), fTargetColorSpace.get()));
                    canvas->drawImage(yuv, x, y);
                    y += kTileWidthHeight + kPad;
 
                    SkIRect bounds = SkIRect::MakeWH(kTileWidthHeight / 2, kTileWidthHeight / 2);
                    auto subset = SkImages::SubsetTextureFrom(dContext, yuv.get(), bounds);
                    SkASSERT(subset);
                    canvas->drawImage(subset, x, y);
                    y += kTileWidthHeight + kPad;
 
                    auto nonTexture = yuv->makeNonTextureImage();
                    SkASSERT(nonTexture);
                    canvas->drawImage(nonTexture, x, y);
                    y += kTileWidthHeight + kPad;
 
                    SkBitmap readBack;
                    readBack.allocPixels(yuv->imageInfo());
                    SkAssertResult(yuv->readPixels(dContext, readBack.pixmap(), 0, 0));
                    canvas->drawImage(readBack.asImage(), x, y);
                }
                x += kTileWidthHeight + kPad;
            }
        }
        return DrawResult::kOk;
    }

onGpuSetup()

DrawResult skiagm::YUVMakeColorSpaceGM::onGpuSetup ( SkCanvas *  canvas, SkString *  errorMsg, GraphiteTestContext *    )

inlineoverrideprotectedvirtual

Reimplemented from skiagm::GM.

Definition at line 1141 of file wacky_yuv_formats.cpp.

                                                                                               {
        auto dContext = GrAsDirectContext(canvas->recordingContext());
        if (!dContext || dContext->abandoned()) {
            *errorMsg = "DirectContext required to create YUV images";
            return DrawResult::kSkip;
        }
 
        this->createBitmaps();
        if (!this->createImages(dContext)) {
            *errorMsg = "Failed to create YUV images";
            return DrawResult::kFail;
        }
 
        return DrawResult::kOk;
    }

onGpuTeardown()

void skiagm::YUVMakeColorSpaceGM::onGpuTeardown ( )

inlineoverrideprotectedvirtual

Reimplemented from skiagm::GM.

Definition at line 1157 of file wacky_yuv_formats.cpp.

                                  {
        fImages[0][0] = fImages[0][1] = fImages[1][0] = fImages[1][1] = nullptr;
    }

---

The documentation for this class was generated from the following file:

• third_party/skia/gm/wacky_yuv_formats.cpp