GrMtlUtil.h File Reference

import <Metal/Metal.h>
#include "include/gpu/GrBackendSurface.h"
#include "include/gpu/GrContextOptions.h"
#include "include/gpu/ganesh/mtl/GrMtlBackendSurface.h"
#include "include/private/gpu/ganesh/GrTypesPriv.h"
#include "src/gpu/ganesh/mtl/GrMtlTypesPriv.h"
#include "src/sksl/ir/SkSLProgram.h"

Go to the source code of this file.

Namespaces
namespace	SkSL

Enumerations
enum class	GrMtlErrorCode { kTimeout = 1 }

Functions
GR_NORETAIN_BEGIN SK_ALWAYS_INLINE id< MTLTexture >	GrGetMTLTexture (const void *mtlTexture)
SK_ALWAYS_INLINE const void *	GrGetPtrFromId (id idObject)
SK_ALWAYS_INLINE CF_RETURNS_RETAINED const void *	GrRetainPtrFromId (id idObject)
NSError *	GrCreateMtlError (NSString *description, GrMtlErrorCode errorCode)
MTLTextureDescriptor *	GrGetMTLTextureDescriptor (id< MTLTexture > mtlTexture)
id< MTLLibrary >	GrCompileMtlShaderLibrary (const GrMtlGpu *gpu, const std::string &msl, GrContextOptions::ShaderErrorHandler *errorHandler)
void	GrPrecompileMtlShaderLibrary (const GrMtlGpu *gpu, const std::string &msl)
id< MTLLibrary >	GrMtlNewLibraryWithSource (id< MTLDevice >, NSString *mslCode, MTLCompileOptions *, NSError **)
id< MTLRenderPipelineState >	GrMtlNewRenderPipelineStateWithDescriptor (id< MTLDevice >, MTLRenderPipelineDescriptor *, NSError **)
id< MTLTexture >	GrGetMTLTextureFromSurface (GrSurface *surface)
static MTLPixelFormat	GrBackendFormatAsMTLPixelFormat (const GrBackendFormat &format)
SkTextureCompressionType	GrMtlFormatToCompressionType (MTLPixelFormat)
int	GrMtlFormatStencilBits (MTLPixelFormat)
GrColorFormatDesc	GrMtlFormatDesc (MTLPixelFormat)

Enumeration Type Documentation

GrMtlErrorCode

enum class GrMtlErrorCode

strong

Enumerator
kTimeout

Definition at line 63 of file GrMtlUtil.h.

                          {
    kTimeout = 1,
};

Function Documentation

GrBackendFormatAsMTLPixelFormat()

static MTLPixelFormat GrBackendFormatAsMTLPixelFormat ( const GrBackendFormat &  format )

inlinestatic

Definition at line 106 of file GrMtlUtil.h.

                                                                                            {
    return static_cast<MTLPixelFormat>(GrBackendFormats::AsMtlFormat(format));
}

GrCompileMtlShaderLibrary()

id< MTLLibrary > GrCompileMtlShaderLibrary	(	const GrMtlGpu *	gpu,
		const std::string &	msl,
		GrContextOptions::ShaderErrorHandler *	errorHandler
	)

Returns a compiled MTLLibrary created from MSL code

Definition at line 52 of file GrMtlUtil.mm.

                                                                                           {
    TRACE_EVENT0("skia.shaders", "driver_compile_shader");
    NSString* nsSource = [[NSString alloc] initWithBytesNoCopy:const_cast<char*>(msl.c_str())
                                                        length:msl.size()
                                                      encoding:NSUTF8StringEncoding
                                                  freeWhenDone:NO];
    if (!nsSource) {
        return nil;
    }
    MTLCompileOptions* options = [[MTLCompileOptions alloc] init];
    // array<> is supported in MSL 2.0 on MacOS 10.13+ and iOS 11+,
    // and in MSL 1.2 on iOS 10+ (but not MacOS).
    if (@available(macOS 10.13, iOS 11.0, tvOS 11.0, *)) {
        options.languageVersion = MTLLanguageVersion2_0;
#if defined(SK_BUILD_FOR_IOS)
    } else if (@available(macOS 10.12, iOS 10.0, tvOS 10.0, *)) {
        options.languageVersion = MTLLanguageVersion1_2;
#endif
    }
    options.fastMathEnabled = YES;
 
    NSError* error = nil;
    id<MTLLibrary> compiledLibrary;
    if (@available(macOS 10.15, *)) {
        compiledLibrary = [gpu->device() newLibraryWithSource:(NSString* _Nonnull)nsSource
                                                      options:options
                                                        error:&error];
    } else {
        compiledLibrary = GrMtlNewLibraryWithSource(gpu->device(), (NSString* _Nonnull)nsSource,
                                                    options, &error);
    }
    if (!compiledLibrary) {
        errorHandler->compileError(
                msl.c_str(), error.debugDescription.UTF8String, /*shaderWasCached=*/false);
        return nil;
    }
 
    return compiledLibrary;
}

GrCreateMtlError()

NSError * GrCreateMtlError	(	NSString *	description,
		GrMtlErrorCode	errorCode
	)

Definition at line 28 of file GrMtlUtil.mm.

                                                                           {
    NSDictionary* userInfo = [NSDictionary dictionaryWithObject:description
                                                         forKey:NSLocalizedDescriptionKey];
    return [NSError errorWithDomain:@"org.skia.ganesh"
                               code:(NSInteger)errorCode
                           userInfo:userInfo];
}

GrGetMTLTexture()

GR_NORETAIN_BEGIN SK_ALWAYS_INLINE id< MTLTexture > GrGetMTLTexture

(

const void *

mtlTexture

)

Returns a id<MTLTexture> to the MTLTexture pointed at by the const void*.

TODO: Remove this and the other bridging functions? It's better to cast on the calling side so ARC has more context, and they don't add much value.

Definition at line 36 of file GrMtlUtil.h.

                                                                        {
#if __has_feature(objc_arc)
    return (__bridge id<MTLTexture>)mtlTexture;
#else
    return (id<MTLTexture>)mtlTexture;
#endif
}

GrGetMTLTextureDescriptor()

MTLTextureDescriptor * GrGetMTLTextureDescriptor

(

id< MTLTexture >

mtlTexture

)

Returns a MTLTextureDescriptor which describes the MTLTexture. Useful when creating a duplicate MTLTexture without the same storage allocation.

Definition at line 36 of file GrMtlUtil.mm.

                                                                           {
    MTLTextureDescriptor* texDesc = [[MTLTextureDescriptor alloc] init];
    texDesc.textureType = mtlTexture.textureType;
    texDesc.pixelFormat = mtlTexture.pixelFormat;
    texDesc.width = mtlTexture.width;
    texDesc.height = mtlTexture.height;
    texDesc.depth = mtlTexture.depth;
    texDesc.mipmapLevelCount = mtlTexture.mipmapLevelCount;
    texDesc.arrayLength = mtlTexture.arrayLength;
    texDesc.sampleCount = mtlTexture.sampleCount;
    if (@available(macOS 10.11, iOS 9.0, tvOS 9.0, *)) {
        texDesc.usage = mtlTexture.usage;
    }
    return texDesc;
}

GrGetMTLTextureFromSurface()

id< MTLTexture > GrGetMTLTextureFromSurface

(

GrSurface *

surface

)

Returns a MTLTexture corresponding to the GrSurface.

Definition at line 201 of file GrMtlUtil.mm.

                                                              {
    id<MTLTexture> mtlTexture = nil;
 
    GrMtlRenderTarget* renderTarget = static_cast<GrMtlRenderTarget*>(surface->asRenderTarget());
    GrMtlTexture* texture;
    if (renderTarget) {
        // We should not be using this for multisampled rendertargets with a separate resolve
        // texture.
        if (renderTarget->resolveAttachment()) {
            SkASSERT(renderTarget->numSamples() > 1);
            SkASSERT(false);
            return nil;
        }
        mtlTexture = renderTarget->colorMTLTexture();
    } else {
        texture = static_cast<GrMtlTexture*>(surface->asTexture());
        if (texture) {
            mtlTexture = texture->mtlTexture();
        }
    }
    return mtlTexture;
}

GrGetPtrFromId()

SK_ALWAYS_INLINE const void * GrGetPtrFromId

(

id

idObject

)

Returns a const void* to whatever the id object is pointing to.

Definition at line 47 of file GrMtlUtil.h.

                                                         {
#if __has_feature(objc_arc)
    return (__bridge const void*)idObject;
#else
    return (const void*)idObject;
#endif
}

GrMtlFormatDesc()

GrColorFormatDesc GrMtlFormatDesc

(

MTLPixelFormat

mtlFormat

)

Definition at line 233 of file GrMtlUtil.mm.

                                                            {
    switch (mtlFormat) {
        case MTLPixelFormatRGBA8Unorm:
            return GrColorFormatDesc::MakeRGBA(8, GrColorTypeEncoding::kUnorm);
        case MTLPixelFormatR8Unorm:
            return GrColorFormatDesc::MakeR(8, GrColorTypeEncoding::kUnorm);
        case MTLPixelFormatA8Unorm:
            return GrColorFormatDesc::MakeAlpha(8, GrColorTypeEncoding::kUnorm);
        case MTLPixelFormatBGRA8Unorm:
            return GrColorFormatDesc::MakeRGBA(8, GrColorTypeEncoding::kUnorm);
        case MTLPixelFormatB5G6R5Unorm:
            return GrColorFormatDesc::MakeRGB(5, 6, 5, GrColorTypeEncoding::kUnorm);
        case MTLPixelFormatRGBA16Float:
            return GrColorFormatDesc::MakeRGBA(16, GrColorTypeEncoding::kFloat);
        case MTLPixelFormatR16Float:
            return GrColorFormatDesc::MakeR(16, GrColorTypeEncoding::kFloat);
        case MTLPixelFormatRG8Unorm:
            return GrColorFormatDesc::MakeRG(8, GrColorTypeEncoding::kUnorm);
        case MTLPixelFormatRGB10A2Unorm:
            return GrColorFormatDesc::MakeRGBA(10, 2, GrColorTypeEncoding::kUnorm);
        case MTLPixelFormatBGR10A2Unorm:
            return GrColorFormatDesc::MakeRGBA(10, 2, GrColorTypeEncoding::kUnorm);
        case MTLPixelFormatABGR4Unorm:
            return GrColorFormatDesc::MakeRGBA(4, GrColorTypeEncoding::kUnorm);
        case MTLPixelFormatRGBA8Unorm_sRGB:
            return GrColorFormatDesc::MakeRGBA(8, GrColorTypeEncoding::kSRGBUnorm);
        case MTLPixelFormatR16Unorm:
            return GrColorFormatDesc::MakeR(16, GrColorTypeEncoding::kUnorm);
        case MTLPixelFormatRG16Unorm:
            return GrColorFormatDesc::MakeRG(16, GrColorTypeEncoding::kUnorm);
        case MTLPixelFormatRGBA16Unorm:
            return GrColorFormatDesc::MakeRGBA(16, GrColorTypeEncoding::kUnorm);
        case MTLPixelFormatRG16Float:
            return GrColorFormatDesc::MakeRG(16, GrColorTypeEncoding::kFloat);
 
        // Compressed texture formats are not expected to have a description.
        case MTLPixelFormatETC2_RGB8: return GrColorFormatDesc::MakeInvalid();
#ifdef SK_BUILD_FOR_MAC
        case MTLPixelFormatBC1_RGBA:  return GrColorFormatDesc::MakeInvalid();
#endif
 
        // This type only describes color channels.
        case MTLPixelFormatStencil8: return GrColorFormatDesc::MakeInvalid();
 
        default:
            return GrColorFormatDesc::MakeInvalid();
    }
}

GrMtlFormatStencilBits()

int GrMtlFormatStencilBits

(

MTLPixelFormat

format

)

Definition at line 302 of file GrMtlUtil.mm.

                                                  {
    switch (format) {
        case MTLPixelFormatStencil8:
            return 8;
        default:
            return 0;
    }
}

GrMtlFormatToCompressionType()

SkTextureCompressionType GrMtlFormatToCompressionType

(

MTLPixelFormat

format

)

Maps a MTLPixelFormat into the CompressionType enum if applicable.

Definition at line 282 of file GrMtlUtil.mm.

                                                                             {
    switch (format) {
        case MTLPixelFormatETC2_RGB8: return SkTextureCompressionType::kETC2_RGB8_UNORM;
#ifdef SK_BUILD_FOR_MAC
        case MTLPixelFormatBC1_RGBA:  return SkTextureCompressionType::kBC1_RGBA8_UNORM;
#endif
        default:                      return SkTextureCompressionType::kNone;
    }
 
    SkUNREACHABLE;
}

GrMtlNewLibraryWithSource()

id< MTLLibrary > GrMtlNewLibraryWithSource	(	id< MTLDevice >	device,
		NSString *	mslCode,
		MTLCompileOptions *	options,
		NSError **	error
	)

Replacement for newLibraryWithSource:options:error that has a timeout.

Definition at line 130 of file GrMtlUtil.mm.

                                                                                      {
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
    sk_sp<MtlCompileResult> compileResult(new MtlCompileResult);
    // We have to increment the ref for the Obj-C block manually because it won't do it for us
    compileResult->ref();
    MTLNewLibraryCompletionHandler completionHandler =
            ^(id<MTLLibrary> library, NSError* compileError) {
                compileResult->set(library, compileError);
                dispatch_semaphore_signal(semaphore);
                compileResult->unref();
            };
 
    [device newLibraryWithSource: mslCode
                         options: options
               completionHandler: completionHandler];
 
    // Wait 1 second for the compiler
    constexpr auto kTimeoutNS = 1000000000UL;
    if (dispatch_semaphore_wait(semaphore, dispatch_time(DISPATCH_TIME_NOW, kTimeoutNS))) {
        if (error) {
            constexpr auto kTimeoutMS = kTimeoutNS/1000000UL;
            NSString* description =
                    [NSString stringWithFormat:@"Compilation took longer than %lu ms",
                                               kTimeoutMS];
            *error = GrCreateMtlError(description, GrMtlErrorCode::kTimeout);
        }
        return nil;
    }
 
    id<MTLLibrary> compiledLibrary;
    std::tie(compiledLibrary, *error) = compileResult->get();
 
    return compiledLibrary;
}

GrMtlNewRenderPipelineStateWithDescriptor()

id< MTLRenderPipelineState > GrMtlNewRenderPipelineStateWithDescriptor	(	id< MTLDevice >	device,
		MTLRenderPipelineDescriptor *	pipelineDescriptor,
		NSError **	error
	)

Replacement for newRenderPipelineStateWithDescriptor:error that has a timeout.

Definition at line 166 of file GrMtlUtil.mm.

                                                                                                {
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
    sk_sp<MtlCompileResult> compileResult(new MtlCompileResult);
    // We have to increment the ref for the Obj-C block manually because it won't do it for us
    compileResult->ref();
    MTLNewRenderPipelineStateCompletionHandler completionHandler =
            ^(id<MTLRenderPipelineState> state, NSError* compileError) {
                compileResult->set(state, compileError);
                dispatch_semaphore_signal(semaphore);
                compileResult->unref();
            };
 
    [device newRenderPipelineStateWithDescriptor: pipelineDescriptor
                               completionHandler: completionHandler];
 
    // Wait 1 second for pipeline creation
    constexpr auto kTimeoutNS = 1000000000UL;
    if (dispatch_semaphore_wait(semaphore, dispatch_time(DISPATCH_TIME_NOW, kTimeoutNS))) {
        if (error) {
            constexpr auto kTimeoutMS = kTimeoutNS/1000000UL;
            NSString* description =
                    [NSString stringWithFormat:@"Pipeline creation took longer than %lu ms",
                                               kTimeoutMS];
            *error = GrCreateMtlError(description, GrMtlErrorCode::kTimeout);
        }
        return nil;
    }
 
    id<MTLRenderPipelineState> pipelineState;
    std::tie(pipelineState, *error) = compileResult->get();
 
    return pipelineState;
}

GrPrecompileMtlShaderLibrary()

void GrPrecompileMtlShaderLibrary	(	const GrMtlGpu *	gpu,
		const std::string &	msl
	)

Attempts to compile an MSL shader asynchronously. We are not concerned about the result, which will be cached in the Apple shader cache.

Definition at line 94 of file GrMtlUtil.mm.

                                                        {
    NSString* nsSource = [[NSString alloc] initWithBytesNoCopy:const_cast<char*>(msl.c_str())
                                                        length:msl.size()
                                                      encoding:NSUTF8StringEncoding
                                                  freeWhenDone:NO];
    if (!nsSource) {
        return;
    }
    // Do nothing after completion for now.
    // TODO: cache the result somewhere so we can use it later.
    MTLNewLibraryCompletionHandler completionHandler = ^(id<MTLLibrary> library, NSError* error) {};
    [gpu->device() newLibraryWithSource:(NSString* _Nonnull)nsSource
                                options:nil
                      completionHandler:completionHandler];
}

GrRetainPtrFromId()

SK_ALWAYS_INLINE CF_RETURNS_RETAINED const void * GrRetainPtrFromId

(

id

idObject

)

Returns a const void* to whatever the id object is pointing to. Will call CFRetain on the object.

Definition at line 59 of file GrMtlUtil.h.

                                                                                {
    return CFBridgingRetain(idObject);
}