skiagm::WackyYUVFormatsGM Class Reference

Inheritance diagram for skiagm::WackyYUVFormatsGM:

Public Types
using	Type = sk_gpu_test::LazyYUVImage::Type
Public Types inherited from skiagm::GM
enum	Mode { kGM_Mode , kSample_Mode , kBench_Mode }
using	DrawResult = skiagm::DrawResult
using	GraphiteTestContext = skiatest::graphite::GraphiteTestContext

Public Member Functions
	WackyYUVFormatsGM (bool useTargetColorSpace, bool useSubset, bool useCubicSampling, Type type)
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 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 *dContext, Recorder *recorder)
DrawResult	onGpuSetup (SkCanvas *canvas, SkString *errorMsg, GraphiteTestContext *) override
void	onGpuTeardown () override
void	onDraw (SkCanvas *canvas) override
Protected Member Functions inherited from skiagm::GM
virtual void	onOnceBeforeDraw ()
virtual DrawResult	onDraw (SkCanvas *, SkString *errorMsg)
virtual bool	onAnimate (double)
virtual bool	onGetControls (SkMetaData *)
virtual void	onSetControls (const SkMetaData &)
GraphiteTestContext *	graphiteTestContext () const

Additional Inherited Members
Static Public Attributes inherited from skiagm::GM
static constexpr char	kErrorMsg_DrawSkippedGpuOnly []

Detailed Description

Definition at line 790 of file wacky_yuv_formats.cpp.

Member Typedef Documentation

Type

using skiagm::WackyYUVFormatsGM::Type = sk_gpu_test::LazyYUVImage::Type

Definition at line 792 of file wacky_yuv_formats.cpp.

Constructor & Destructor Documentation

WackyYUVFormatsGM()

skiagm::WackyYUVFormatsGM::WackyYUVFormatsGM ( bool  useTargetColorSpace, bool  useSubset, bool  useCubicSampling, Type  type  )

inline

Definition at line 794 of file wacky_yuv_formats.cpp.

            : fUseTargetColorSpace(useTargetColorSpace)
            , fUseSubset(useSubset)
            , fUseCubicSampling(useCubicSampling)
            , fImageType(type) {
        this->setBGColor(0xFFCCCCCC);
    }

Member Function Documentation

createBitmaps()

void skiagm::WackyYUVFormatsGM::createBitmaps ( )

inlineprotected

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

createImages()

bool skiagm::WackyYUVFormatsGM::createImages ( GrDirectContext *  dContext, Recorder *  recorder  )

inlineprotected

Definition at line 863 of file wacky_yuv_formats.cpp.

                                                                     {
        int origin = 0;
        for (bool opaque : { false, true }) {
            for (size_t cs = 0; cs < std::size(color_space_array); ++cs) {
                PlaneData planes;
                extract_planes(fOriginalBMs[opaque],
                               color_space_array[cs],
                               static_cast<SkEncodedOrigin>(origin + 1),  // valid origins are 1...8
                               &planes);
 
                for (int f = kP016_YUVFormat; f <= kLast_YUVFormat; ++f) {
                    auto format = static_cast<YUVFormat>(f);
                    SkBitmap resultBMs[4];
 
                    int numPlanes = create_YUV(planes, format, resultBMs, opaque);
                    const YUVAPlanarConfig planarConfig(format,
                                                        opaque,
                                                        static_cast<SkEncodedOrigin>(origin + 1));
                    SkYUVAPixmaps pixmaps =
                            planarConfig.makeYUVAPixmaps(fOriginalBMs[opaque].dimensions(),
                                                         color_space_array[cs],
                                                         resultBMs,
                                                         numPlanes);
                    auto lazyYUV = sk_gpu_test::LazyYUVImage::Make(std::move(pixmaps));
#if defined(SK_GRAPHITE)
                    if (recorder) {
                        fImages[opaque][cs][format] = lazyYUV->refImage(recorder, fImageType);
                    } else
#endif
                    {
                        fImages[opaque][cs][format] = lazyYUV->refImage(dContext, fImageType);
                    }
                }
                origin = (origin + 1) % 8;
            }
        }
 
        if (dContext) {
            // 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.
            dContext->flush();
            dContext->submit(GrSyncCpu::kYes);
        }
 
        return true;
    }

getISize()

SkISize skiagm::WackyYUVFormatsGM::getISize ( )

inlineoverrideprotectedvirtual

Implements skiagm::GM.

Definition at line 831 of file wacky_yuv_formats.cpp.

                                {
        int numCols = 2 * (std::size(color_space_array)); // opacity x #-color-spaces
        int numRows = 1 + (kLast_YUVFormat + 1);  // original + #-yuv-formats
        int wh = SkScalarCeilToInt(kTileWidthHeight * (fUseSubset ? 1.5f : 1.f));
        return SkISize::Make(kLabelWidth  + numCols * (wh + kPad),
                             kLabelHeight + numRows * (wh + kPad));
    }

getName()

SkString skiagm::WackyYUVFormatsGM::getName ( ) const

inlineoverrideprotectedvirtual

Implements skiagm::GM.

Definition at line 803 of file wacky_yuv_formats.cpp.

                                      {
        SkString name("wacky_yuv_formats");
        if (fUseTargetColorSpace) {
            name += "_cs";
        }
        if (fUseSubset) {
            name += "_domain";
        }
        if (fUseCubicSampling) {
            name += "_cubic";
        }
        switch (fImageType) {
            case Type::kFromPixmaps:
                name += "_frompixmaps";
                break;
            case Type::kFromTextures:
                break;
            case Type::kFromGenerator:
                name += "_imggen";
                break;
            case Type::kFromImages:
                name += "_fromimages";
                break;
        }
 
        return name;
    }

onDraw()

void skiagm::WackyYUVFormatsGM::onDraw ( SkCanvas *  canvas )

inlineoverrideprotectedvirtual

Reimplemented from skiagm::GM.

Definition at line 945 of file wacky_yuv_formats.cpp.

                                           {
        auto direct = GrAsDirectContext(canvas->recordingContext());
#if defined(SK_GRAPHITE)
        auto recorder = canvas->recorder();
#endif
 
        float cellWidth = kTileWidthHeight, cellHeight = kTileWidthHeight;
        if (fUseSubset) {
            cellWidth *= 1.5f;
            cellHeight *= 1.5f;
        }
 
        SkRect srcRect = SkRect::Make(fOriginalBMs[0].dimensions());
        SkRect dstRect = SkRect::MakeXYWH(kLabelWidth, 0.f, srcRect.width(), srcRect.height());
 
        SkCanvas::SrcRectConstraint constraint = SkCanvas::kFast_SrcRectConstraint;
        if (fUseSubset) {
            srcRect.inset(kSubsetPadding, kSubsetPadding);
            // Draw a larger rectangle to ensure bilerp filtering would normally read outside the
            // srcRect and hit the red pixels, if strict constraint weren't used.
            dstRect.fRight = kLabelWidth + 1.5f * srcRect.width();
            dstRect.fBottom = 1.5f * srcRect.height();
            constraint = SkCanvas::kStrict_SrcRectConstraint;
        }
 
        SkSamplingOptions sampling = fUseCubicSampling
                                         ? SkSamplingOptions(SkCubicResampler::Mitchell())
                                         : SkSamplingOptions(SkFilterMode::kLinear);
        for (size_t cs = kJPEG_SkYUVColorSpace; cs < std::size(color_space_array); ++cs) {
            SkPaint paint;
            if (kIdentity_SkYUVColorSpace == color_space_array[cs]) {
                // The identity color space needs post processing to appear correctly
                paint.setColorFilter(yuv_to_rgb_colorfilter());
            }
 
            for (int opaque : { 0, 1 }) {
                dstRect.offsetTo(dstRect.fLeft, kLabelHeight);
 
                draw_col_label(canvas, dstRect.fLeft + cellWidth / 2, cs, opaque);
 
                canvas->drawImageRect(fOriginalBMs[opaque].asImage(), srcRect, dstRect,
                                      SkSamplingOptions(), nullptr, constraint);
                dstRect.offset(0.f, cellHeight + kPad);
 
                for (int format = kP016_YUVFormat; format <= kLast_YUVFormat; ++format) {
                    draw_row_label(canvas, dstRect.fTop, format);
                    if (fUseTargetColorSpace && fImages[opaque][cs][format]) {
                        // Making a CS-specific version of a kIdentity_SkYUVColorSpace YUV image
                        // doesn't make a whole lot of sense. The colorSpace conversion will
                        // operate on the YUV components rather than the RGB components.
                        sk_sp<SkImage> csImage;
#if defined(SK_GRAPHITE)
                        if (recorder) {
                            csImage = fImages[opaque][cs][format]->makeColorSpace(
                                    recorder, fTargetColorSpace, {});
                        } else
#endif
                        {
                            csImage = fImages[opaque][cs][format]->makeColorSpace(
                                    direct, fTargetColorSpace);
                        }
                        canvas->drawImageRect(csImage, srcRect, dstRect, sampling,
                                              &paint, constraint);
                    } else {
                        canvas->drawImageRect(fImages[opaque][cs][format], srcRect, dstRect,
                                              sampling, &paint, constraint);
                    }
                    dstRect.offset(0.f, cellHeight + kPad);
                }
 
                dstRect.offset(cellWidth + kPad, 0.f);
            }
        }
    }

onGpuSetup()

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

inlineoverrideprotectedvirtual

Reimplemented from skiagm::GM.

Definition at line 911 of file wacky_yuv_formats.cpp.

                                                                                               {
        auto dContext = GrAsDirectContext(canvas->recordingContext());
        auto recorder = canvas->recorder();
        this->createBitmaps();
 
        if (dContext && dContext->abandoned()) {
            // This isn't a GpuGM so a null 'context' is okay but an abandoned context
            // if forbidden.
            return DrawResult::kSkip;
        }
 
        // Only the generator is expected to work with the CPU backend.
        if (fImageType != Type::kFromGenerator && !dContext && !recorder) {
            return DrawResult::kSkip;
        }
 
        if (!this->createImages(dContext, recorder)) {
            *errorMsg = "Failed to create YUV images";
            return DrawResult::kFail;
        }
 
        return DrawResult::kOk;
    }

onGpuTeardown()

void skiagm::WackyYUVFormatsGM::onGpuTeardown ( )

inlineoverrideprotectedvirtual

Reimplemented from skiagm::GM.

Definition at line 935 of file wacky_yuv_formats.cpp.

                                  {
        for (int i = 0; i < 2; ++i) {
            for (size_t j = 0; j < std::size(color_space_array); ++j) {
                for (int k = 0; k <= kLast_YUVFormat; ++k) {
                    fImages[i][j][k] = nullptr;
                }
            }
        }
    }

---

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

• third_party/skia/gm/wacky_yuv_formats.cpp