FlutterDarwinExternalTextureMetal Class Reference

#include <FlutterDarwinExternalTextureMetal.h>

Inheritance diagram for FlutterDarwinExternalTextureMetal:

Instance Methods
(nullable instancetype)	- initWithTextureCache:textureID:texture:enableImpeller:
(void)	- paintContext:bounds:freeze:sampling:
(void)	- onGrContextCreated
(void)	- onGrContextDestroyed
(void)	- markNewFrameAvailable
(void)	- onTextureUnregistered
(instancetype)	- initWithTextureCache:textureID:texture:enableImpeller: [implementation]
(void)	- dealloc [implementation]
(void)	- onNeedsUpdatedTexture: [implementation]
(sk_sp< flutter::DlImage >)	- wrapExternalPixelBuffer:context: [implementation]
(sk_sp< flutter::DlImage >)	- wrapNV12ExternalPixelBuffer:context: [implementation]
(sk_sp< flutter::DlImage >)	- wrapBGRAExternalPixelBuffer:context: [implementation]

Properties
int64_t	textureID

Detailed Description

Definition at line 32 of file FlutterDarwinExternalTextureMetal.h.

Method Documentation

dealloc

- (void) dealloc

implementation

Definition at line 31 of file FlutterDarwinExternalTextureMetal.mm.

                {
  CVPixelBufferRelease(_lastPixelBuffer);
  if (_textureCache) {
    CVMetalTextureCacheFlush(_textureCache,  // cache
                             0               // options (must be zero)
    );
    CFRelease(_textureCache);
  }
}

initWithTextureCache:textureID:texture:enableImpeller: [1/2]

- (instancetype) initWithTextureCache: (nonnull CVMetalTextureCacheRef)  textureCache textureID: (int64_t)  textureID texture: (NSObject<FlutterTexture>*)  texture enableImpeller: (BOOL)  enableImpeller

implementation

Definition at line 31 of file FlutterDarwinExternalTextureMetal.mm.

                                    :(nonnull CVMetalTextureCacheRef)textureCache
                           textureID:(int64_t)textureID
                             texture:(NSObject<FlutterTexture>*)texture
                      enableImpeller:(BOOL)enableImpeller {
  if (self = [super init]) {
    _textureCache = textureCache;
    CFRetain(_textureCache);
    _textureID = textureID;
    _externalTexture = texture;
    _enableImpeller = enableImpeller;
    return self;
  }
  return nil;
}

initWithTextureCache:textureID:texture:enableImpeller: [2/2]

- (nullable instancetype) initWithTextureCache:		(nonnull CVMetalTextureCacheRef)	textureCache
textureID:		(int64_t)	textureID
texture:		(nonnull NSObject< FlutterTexture > *)	texture
enableImpeller:		(BOOL)	enableImpeller

markNewFrameAvailable

- (void) markNewFrameAvailable

Definition at line 31 of file FlutterDarwinExternalTextureMetal.mm.

                              {
  _textureFrameAvailable = YES;
}

onGrContextCreated

- (void) onGrContextCreated

Definition at line 31 of file FlutterDarwinExternalTextureMetal.mm.

                           {
  // External images in this backend have no thread affinity and are not tied to the context in any
  // way. Instead, they are tied to the Metal device which is associated with the cache already and
  // is consistent throughout the shell run.
}

onGrContextDestroyed

- (void) onGrContextDestroyed

Definition at line 31 of file FlutterDarwinExternalTextureMetal.mm.

                             {
  // The image must be reset because it is tied to the onscreen context. But the pixel buffer that
  // created the image is still around. In case of context reacquisition, that last pixel
  // buffer will be used to materialize the image in case the application fails to provide a new
  // one.
  _externalImage.reset();
  CVMetalTextureCacheFlush(_textureCache,  // cache
                           0               // options (must be zero)
  );
}

onNeedsUpdatedTexture:

- (void) onNeedsUpdatedTexture: (flutter::Texture::PaintContext&)  context

implementation

Definition at line 31 of file FlutterDarwinExternalTextureMetal.mm.

                             :(flutter::Texture::PaintContext&)context {
  CVPixelBufferRef pixelBuffer = [_externalTexture copyPixelBuffer];
  if (pixelBuffer) {
    CVPixelBufferRelease(_lastPixelBuffer);
    _lastPixelBuffer = pixelBuffer;
    _pixelFormat = CVPixelBufferGetPixelFormatType(_lastPixelBuffer);
  }
 
  // If the application told us there was a texture frame available but did not provide one when
  // asked for it, reuse the previous texture but make sure to ask again the next time around.
  sk_sp<flutter::DlImage> image = [self wrapExternalPixelBuffer:_lastPixelBuffer context:context];
  if (image) {
    _externalImage = image;
    _textureFrameAvailable = false;
  }
}

onTextureUnregistered

- (void) onTextureUnregistered

Definition at line 31 of file FlutterDarwinExternalTextureMetal.mm.

                              {
  if ([_externalTexture respondsToSelector:@selector(onTextureUnregistered:)]) {
    [_externalTexture onTextureUnregistered:_externalTexture];
  }
}

paintContext:bounds:freeze:sampling:

- (void) paintContext:		(flutter::Texture::PaintContext&)	context
bounds:		(const SkRect&)	bounds
freeze:		(BOOL)	freeze
sampling:		(const flutter::DlImageSampling)	sampling

Definition at line 31 of file FlutterDarwinExternalTextureMetal.mm.

                    :(flutter::Texture::PaintContext&)context
              bounds:(const SkRect&)bounds
              freeze:(BOOL)freeze
            sampling:(const flutter::DlImageSampling)sampling {
  const bool needsUpdatedTexture = (!freeze && _textureFrameAvailable) || !_externalImage;
 
  if (needsUpdatedTexture) {
    [self onNeedsUpdatedTexture:context];
  }
 
  if (_externalImage) {
    context.canvas->DrawImageRect(_externalImage,                                // image
                                  SkRect::Make(_externalImage->bounds()),        // source rect
                                  bounds,                                        // destination rect
                                  sampling,                                      // sampling
                                  context.paint,                                 // paint
                                  flutter::DlCanvas::SrcRectConstraint::kStrict  // enforce edges
    );
  }
}

wrapBGRAExternalPixelBuffer:context:

- (sk_sp< DlImage >) FlutterDarwinExternalTextureMetal: (CVPixelBufferRef)  pixelBuffer context: (flutter::Texture::PaintContext&)  context

implementation

Definition at line 31 of file FlutterDarwinExternalTextureMetal.mm.

                                                    :(CVPixelBufferRef)pixelBuffer
                                               context:(flutter::Texture::PaintContext&)context {
  SkISize textureSize =
      SkISize::Make(CVPixelBufferGetWidth(pixelBuffer), CVPixelBufferGetHeight(pixelBuffer));
  CVMetalTextureRef metalTexture = nullptr;
  CVReturn cvReturn =
      CVMetalTextureCacheCreateTextureFromImage(/*allocator=*/kCFAllocatorDefault,
                                                /*textureCache=*/_textureCache,
                                                /*sourceImage=*/pixelBuffer,
                                                /*textureAttributes=*/nullptr,
                                                /*pixelFormat=*/MTLPixelFormatBGRA8Unorm,
                                                /*width=*/textureSize.width(),
                                                /*height=*/textureSize.height(),
                                                /*planeIndex=*/0u,
                                                /*texture=*/&metalTexture);
 
  if (cvReturn != kCVReturnSuccess) {
    FML_DLOG(ERROR) << "Could not create Metal texture from pixel buffer: CVReturn " << cvReturn;
    return nullptr;
  }
 
  id<MTLTexture> rgbaTex = CVMetalTextureGetTexture(metalTexture);
  CVBufferRelease(metalTexture);
 
  if (_enableImpeller) {
    impeller::TextureDescriptor desc;
    desc.storage_mode = impeller::StorageMode::kHostVisible;
    desc.format = impeller::PixelFormat::kB8G8R8A8UNormInt;
    desc.size = {textureSize.width(), textureSize.height()};
    desc.mip_count = 1;
    auto texture = impeller::TextureMTL::Wrapper(desc, rgbaTex);
    texture->SetCoordinateSystem(impeller::TextureCoordinateSystem::kUploadFromHost);
    return impeller::DlImageImpeller::Make(texture);
  }
 
  auto skImage = [FlutterDarwinExternalTextureSkImageWrapper wrapRGBATexture:rgbaTex
                                                                   grContext:context.gr_context
                                                                       width:textureSize.width()
                                                                      height:textureSize.height()];
  if (!skImage) {
    return nullptr;
  }
 
  // This image should not escape local use by this flutter::Texture implementation
  return flutter::DlImage::Make(skImage);
}

wrapExternalPixelBuffer:context:

- (sk_sp< DlImage >) FlutterDarwinExternalTextureMetal: (CVPixelBufferRef)  pixelBuffer context: (flutter::Texture::PaintContext&)  context

implementation

Definition at line 31 of file FlutterDarwinExternalTextureMetal.mm.

                                                :(CVPixelBufferRef)pixelBuffer
                                           context:(flutter::Texture::PaintContext&)context {
  if (!pixelBuffer) {
    return nullptr;
  }
 
  sk_sp<flutter::DlImage> image = nullptr;
  if (_pixelFormat == kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange ||
      _pixelFormat == kCVPixelFormatType_420YpCbCr8BiPlanarFullRange) {
    image = [self wrapNV12ExternalPixelBuffer:pixelBuffer context:context];
  } else if (_pixelFormat == kCVPixelFormatType_32BGRA) {
    image = [self wrapBGRAExternalPixelBuffer:pixelBuffer context:context];
  } else {
    FML_LOG(ERROR) << "Unsupported pixel format: " << _pixelFormat;
    return nullptr;
  }
 
  if (!image) {
    FML_DLOG(ERROR) << "Could not wrap Metal texture as a display list image.";
  }
 
  return image;
}

wrapNV12ExternalPixelBuffer:context:

- (sk_sp< DlImage >) FlutterDarwinExternalTextureMetal: (CVPixelBufferRef)  pixelBuffer context: (flutter::Texture::PaintContext&)  context

implementation

Definition at line 31 of file FlutterDarwinExternalTextureMetal.mm.

                                                    :(CVPixelBufferRef)pixelBuffer
                                               context:(flutter::Texture::PaintContext&)context {
  SkISize textureSize =
      SkISize::Make(CVPixelBufferGetWidth(pixelBuffer), CVPixelBufferGetHeight(pixelBuffer));
  CVMetalTextureRef yMetalTexture = nullptr;
  {
    CVReturn cvReturn =
        CVMetalTextureCacheCreateTextureFromImage(/*allocator=*/kCFAllocatorDefault,
                                                  /*textureCache=*/_textureCache,
                                                  /*sourceImage=*/pixelBuffer,
                                                  /*textureAttributes=*/nullptr,
                                                  /*pixelFormat=*/MTLPixelFormatR8Unorm,
                                                  /*width=*/textureSize.width(),
                                                  /*height=*/textureSize.height(),
                                                  /*planeIndex=*/0u,
                                                  /*texture=*/&yMetalTexture);
 
    if (cvReturn != kCVReturnSuccess) {
      FML_DLOG(ERROR) << "Could not create Metal texture from pixel buffer: CVReturn " << cvReturn;
      return nullptr;
    }
  }
 
  CVMetalTextureRef uvMetalTexture = nullptr;
  {
    CVReturn cvReturn =
        CVMetalTextureCacheCreateTextureFromImage(/*allocator=*/kCFAllocatorDefault,
                                                  /*textureCache=*/_textureCache,
                                                  /*sourceImage=*/pixelBuffer,
                                                  /*textureAttributes=*/nullptr,
                                                  /*pixelFormat=*/MTLPixelFormatRG8Unorm,
                                                  /*width=*/textureSize.width() / 2,
                                                  /*height=*/textureSize.height() / 2,
                                                  /*planeIndex=*/1u,
                                                  /*texture=*/&uvMetalTexture);
 
    if (cvReturn != kCVReturnSuccess) {
      FML_DLOG(ERROR) << "Could not create Metal texture from pixel buffer: CVReturn " << cvReturn;
      return nullptr;
    }
  }
 
  id<MTLTexture> yTex = CVMetalTextureGetTexture(yMetalTexture);
  CVBufferRelease(yMetalTexture);
 
  id<MTLTexture> uvTex = CVMetalTextureGetTexture(uvMetalTexture);
  CVBufferRelease(uvMetalTexture);
 
  if (_enableImpeller) {
    impeller::TextureDescriptor yDesc;
    yDesc.storage_mode = impeller::StorageMode::kHostVisible;
    yDesc.format = impeller::PixelFormat::kR8UNormInt;
    yDesc.size = {textureSize.width(), textureSize.height()};
    yDesc.mip_count = 1;
    auto yTexture = impeller::TextureMTL::Wrapper(yDesc, yTex);
    yTexture->SetCoordinateSystem(impeller::TextureCoordinateSystem::kUploadFromHost);
 
    impeller::TextureDescriptor uvDesc;
    uvDesc.storage_mode = impeller::StorageMode::kHostVisible;
    uvDesc.format = impeller::PixelFormat::kR8G8UNormInt;
    uvDesc.size = {textureSize.width() / 2, textureSize.height() / 2};
    uvDesc.mip_count = 1;
    auto uvTexture = impeller::TextureMTL::Wrapper(uvDesc, uvTex);
    uvTexture->SetCoordinateSystem(impeller::TextureCoordinateSystem::kUploadFromHost);
 
    impeller::YUVColorSpace yuvColorSpace =
        _pixelFormat == kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange
            ? impeller::YUVColorSpace::kBT601LimitedRange
            : impeller::YUVColorSpace::kBT601FullRange;
 
    return impeller::DlImageImpeller::MakeFromYUVTextures(context.aiks_context, yTexture, uvTexture,
                                                          yuvColorSpace);
  }
 
  SkYUVColorSpace colorSpace = _pixelFormat == kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange
                                   ? kRec601_Limited_SkYUVColorSpace
                                   : kJPEG_Full_SkYUVColorSpace;
  auto skImage = [FlutterDarwinExternalTextureSkImageWrapper wrapYUVATexture:yTex
                                                                       UVTex:uvTex
                                                               YUVColorSpace:colorSpace
                                                                   grContext:context.gr_context
                                                                       width:textureSize.width()
                                                                      height:textureSize.height()];
  if (!skImage) {
    return nullptr;
  }
 
  // This image should not escape local use by this flutter::Texture implementation
  return flutter::DlImage::Make(skImage);
}

Property Documentation

textureID

- (int64_t) textureID

readnonatomicassign

Definition at line 52 of file FlutterDarwinExternalTextureMetal.h.

---

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

• shell/platform/darwin/graphics/FlutterDarwinExternalTextureMetal.h
• shell/platform/darwin/graphics/FlutterDarwinExternalTextureMetal.mm