MPSCNNMultiaryKernel (moe.platform.ios API)

java.lang.Object
- org.moe.natj.general.NativeObject
- - org.moe.natj.objc.ObjCObject
  - - apple.NSObject
    - - apple.metalperformanceshaders.MPSKernel
      - apple.metalperformanceshaders.MPSCNNMultiaryKernel

All Implemented Interfaces:

NSCoding, NSCopying, NSSecureCoding, NSObject
```
public class MPSCNNMultiaryKernel
extends MPSKernel
```
MPSCNNMultiaryKernel [@dependency] This depends on Metal.framework
Describes a neural network kernel with multiple image sources.
A MPSCNNKernel consumes multiple MPSImages, possibly a MPSState, and produces one MPSImage.

Nested Class Summary
- Nested classes/interfaces inherited from class apple.NSObject
  NSObject.Function_instanceMethodForSelector_ret, NSObject.Function_methodForSelector_ret

Constructor Summary

Constructors
Modifier Constructor and Description

protected MPSCNNMultiaryKernel(org.moe.natj.general.Pointer peer)

Constructors
Modifier	Constructor and Description
`protected`	`MPSCNNMultiaryKernel(org.moe.natj.general.Pointer peer)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`boolean`	`_supportsSecureCoding()` This property must return YES on all classes that allow secure coding.
`static boolean`	`accessInstanceVariablesDirectly()`
`static MPSCNNMultiaryKernel`	`alloc()`
`static MPSCNNMultiaryKernel`	`allocWithZone(org.moe.natj.general.ptr.VoidPtr zone)`
`boolean`	`appendBatchBarrier()` Returns YES if the filter must be run over the entire batch before its results may be used
`static boolean`	`automaticallyNotifiesObserversForKey(java.lang.String key)`
`static void`	`cancelPreviousPerformRequestsWithTarget(java.lang.Object aTarget)`
`static void`	`cancelPreviousPerformRequestsWithTargetSelectorObject(java.lang.Object aTarget, org.moe.natj.objc.SEL aSelector, java.lang.Object anArgument)`
`static NSArray<java.lang.String>`	`classFallbacksForKeyedArchiver()`
`static org.moe.natj.objc.Class`	`classForKeyedUnarchiver()`
`MTLRegion`	`clipRect()` [@property] clipRect
`static java.lang.String`	`debugDescription_static()`
`static java.lang.String`	`description_static()`
`long`	`destinationFeatureChannelOffset()` [@property] destinationFeatureChannelOffset
`MPSImageAllocator`	`destinationImageAllocator()` Method to allocate the result image for -encodeToCommandBuffer:sourceImage:
`MPSImageDescriptor`	`destinationImageDescriptorForSourceImagesSourceStates(NSArray<? extends MPSImage> sourceImages, NSArray<? extends MPSState> sourceStates)` Get a suggested destination image descriptor for a source image
`long`	`dilationRateXatIndex(long index)` Stride in source coordinates from one kernel tap to the next in the X dimension.
`long`	`dilationRateYatIndex(long index)` Stride in source coordinates from one kernel tap to the next in the Y dimension.
`long`	`edgeModeAtIndex(long index)` The MPSImageEdgeMode to use when texture reads stray off the edge of the primary source image
`MPSImage`	`encodeToCommandBufferSourceImages(MTLCommandBuffer commandBuffer, NSArray<? extends MPSImage> sourceImages)` Encode a MPSCNNKernel into a command Buffer.
`void`	`encodeToCommandBufferSourceImagesDestinationImage(MTLCommandBuffer commandBuffer, NSArray<? extends MPSImage> sourceImages, MPSImage destinationImage)` Encode a MPSCNNKernel into a command Buffer.
`MPSImage`	`encodeToCommandBufferSourceImagesDestinationStateDestinationStateIsTemporary(MTLCommandBuffer commandBuffer, NSArray<? extends MPSImage> sourceImages, org.moe.natj.general.ptr.Ptr<MPSState> outState, boolean isTemporary)` Encode a MPSCNNKernel into a command Buffer.
`static long`	`hash_static()`
`MPSCNNMultiaryKernel`	`init()`
`MPSCNNMultiaryKernel`	`initWithCoder(NSCoder aDecoder)` NS_DESIGNATED_INITIALIZER
`MPSCNNMultiaryKernel`	`initWithCoderDevice(NSCoder aDecoder, java.lang.Object device)` NSSecureCoding compatability
`MPSCNNMultiaryKernel`	`initWithDevice(java.lang.Object device)` Standard init with default properties per filter type
`MPSCNNMultiaryKernel`	`initWithDeviceSourceCount(MTLDevice device, long sourceCount)` Standard init with default properties per filter type
`static NSObject.Function_instanceMethodForSelector_ret`	`instanceMethodForSelector(org.moe.natj.objc.SEL aSelector)`
`static NSMethodSignature`	`instanceMethodSignatureForSelector(org.moe.natj.objc.SEL aSelector)`
`static boolean`	`instancesRespondToSelector(org.moe.natj.objc.SEL aSelector)`
`boolean`	`isBackwards()` [@property] isBackwards
`boolean`	`isResultStateReusedAcrossBatch()` Returns YES if the same state is used for every operation in a batch
`boolean`	`isStateModified()` Returns true if the -encode call modifies the state object it accepts.
`static boolean`	`isSubclassOfClass(org.moe.natj.objc.Class aClass)`
`long`	`kernelHeightAtIndex(long index)` The height of the kernel filter window
`long`	`kernelWidthAtIndex(long index)` The width of the kernel filter window
`static NSSet<java.lang.String>`	`keyPathsForValuesAffectingValueForKey(java.lang.String key)`
`static MPSCNNMultiaryKernel`	`new_objc()`
`MPSOffset`	`offsetAtIndex(long index)` The positon of the destination clip rectangle origin relative to each source buffer
`MPSNNPadding`	`padding()` [@property] padding
`static boolean`	`resolveClassMethod(org.moe.natj.objc.SEL sel)`
`static boolean`	`resolveInstanceMethod(org.moe.natj.objc.SEL sel)`
`MPSState`	`resultStateForSourceImagesSourceStatesDestinationImage(NSArray<? extends MPSImage> sourceImages, NSArray<? extends MPSState> sourceStates, MPSImage destinationImage)` Allocate a MPSState (subclass) to hold the results from a -encodeBatchToCommandBuffer...
`void`	`setClipRect(MTLRegion value)` [@property] clipRect
`void`	`setDestinationFeatureChannelOffset(long value)` [@property] destinationFeatureChannelOffset
`void`	`setDestinationImageAllocator(MPSImageAllocator value)` Method to allocate the result image for -encodeToCommandBuffer:sourceImage:
`void`	`setDilationRateXAtIndex(long dilationRate, long index)` Set the stride in source coordinates from one kernel tap to the next in the X dimension.
`void`	`setDilationRateYAtIndex(long dilationRate, long index)` Set the stride in source coordinates from one kernel tap to the next in the Y dimension.
`void`	`setEdgeModeAtIndex(long edgeMode, long index)` Set the MPSImageEdgeMode to use when texture reads stray off the edge of the primary source image
`void`	`setKernelHeightAtIndex(long height, long index)` Set the height of the kernel filter window
`void`	`setKernelWidthAtIndex(long width, long index)` Set the width of the kernel filter window
`void`	`setOffsetAtIndex(MPSOffset offset, long index)` Set the positon of the destination clip rectangle origin relative to each source buffer
`void`	`setPadding(MPSNNPadding value)` [@property] padding
`void`	`setSourceFeatureChannelMaxCountAtIndex(long count, long index)` Set the maximum number of channels in the source MPSImage to use
`void`	`setSourceFeatureChannelOffsetAtIndex(long offset, long index)` Set the number of channels in the source MPSImage to skip before reading the input.
`void`	`setStrideInPixelsXAtIndex(long stride, long index)` The downsampling factor in the horizontal dimension for the source image
`void`	`setStrideInPixelsYAtIndex(long stride, long index)` The downsampling factor in the vertical dimension for the source image
`static void`	`setVersion_static(long aVersion)`
`long`	`sourceCount()` The number of source images accepted by the kernel
`long`	`sourceFeatureChannelMaxCountAtIndex(long index)` The maximum number of channels in the source MPSImage to use
`long`	`sourceFeatureChannelOffsetAtIndex(long index)` The number of channels in the source MPSImage to skip before reading the input.
`long`	`strideInPixelsXatIndex(long index)` The downsampling factor in the horizontal dimension for the source image
`long`	`strideInPixelsYatIndex(long index)` The downsampling factor in the vertical dimension for the source image
`static org.moe.natj.objc.Class`	`superclass_static()`
`static boolean`	`supportsSecureCoding()`
`MPSState`	`temporaryResultStateForCommandBufferSourceImagesSourceStatesDestinationImage(MTLCommandBuffer commandBuffer, NSArray<? extends MPSImage> sourceImage, NSArray<? extends MPSState> sourceStates, MPSImage destinationImage)` Allocate a temporary MPSState (subclass) to hold the results from a -encodeBatchToCommandBuffer...
`static long`	`version_static()`

Methods inherited from class apple.metalperformanceshaders.MPSKernel
copyWithZone, copyWithZoneDevice, device, encodeWithCoder, label, options, setLabel, setOptions

Methods inherited from class apple.NSObject
accessibilityActivate, accessibilityActivationPoint, accessibilityAssistiveTechnologyFocusedIdentifiers, accessibilityAttributedHint, accessibilityAttributedLabel, accessibilityAttributedUserInputLabels, accessibilityAttributedValue, accessibilityContainerType, accessibilityCustomActions, accessibilityCustomRotors, accessibilityDecrement, accessibilityDragSourceDescriptors, accessibilityDropPointDescriptors, accessibilityElementAtIndex, accessibilityElementCount, accessibilityElementDidBecomeFocused, accessibilityElementDidLoseFocus, accessibilityElementIsFocused, accessibilityElements, accessibilityElementsHidden, accessibilityFrame, accessibilityHint, accessibilityIncrement, accessibilityLabel, accessibilityLanguage, accessibilityNavigationStyle, accessibilityPath, accessibilityPerformEscape, accessibilityPerformMagicTap, accessibilityRespondsToUserInteraction, accessibilityScroll, accessibilityTextualContext, accessibilityTraits, accessibilityUserInputLabels, accessibilityValue, accessibilityViewIsModal, addObserverForKeyPathOptionsContext, attemptRecoveryFromErrorOptionIndex, attemptRecoveryFromErrorOptionIndexDelegateDidRecoverSelectorContextInfo, autoContentAccessingProxy, awakeAfterUsingCoder, awakeFromNib, class_objc, classForCoder, classForKeyedArchiver, copy, dealloc, debugDescription, description, dictionaryWithValuesForKeys, didChangeValueForKey, didChangeValueForKeyWithSetMutationUsingObjects, didChangeValuesAtIndexesForKey, doesNotRecognizeSelector, fileManagerShouldProceedAfterError, fileManagerWillProcessPath, finalize_objc, forwardingTargetForSelector, forwardInvocation, hash, indexOfAccessibilityElement, isAccessibilityElement, isEqual, isKindOfClass, isMemberOfClass, isProxy, methodForSelector, methodSignatureForSelector, mutableArrayValueForKey, mutableArrayValueForKeyPath, mutableCopy, mutableOrderedSetValueForKey, mutableOrderedSetValueForKeyPath, mutableSetValueForKey, mutableSetValueForKeyPath, observationInfo, observeValueForKeyPathOfObjectChangeContext, performSelector, performSelectorInBackgroundWithObject, performSelectorOnMainThreadWithObjectWaitUntilDone, performSelectorOnMainThreadWithObjectWaitUntilDoneModes, performSelectorOnThreadWithObjectWaitUntilDone, performSelectorOnThreadWithObjectWaitUntilDoneModes, performSelectorWithObject, performSelectorWithObjectAfterDelay, performSelectorWithObjectAfterDelayInModes, performSelectorWithObjectWithObject, prepareForInterfaceBuilder, provideImageDataBytesPerRowOrigin_Size_UserInfo, removeObserverForKeyPath, removeObserverForKeyPathContext, replacementObjectForCoder, replacementObjectForKeyedArchiver, respondsToSelector, self, setAccessibilityActivationPoint, setAccessibilityAttributedHint, setAccessibilityAttributedLabel, setAccessibilityAttributedUserInputLabels, setAccessibilityAttributedValue, setAccessibilityContainerType, setAccessibilityCustomActions, setAccessibilityCustomRotors, setAccessibilityDragSourceDescriptors, setAccessibilityDropPointDescriptors, setAccessibilityElements, setAccessibilityElementsHidden, setAccessibilityFrame, setAccessibilityHint, setAccessibilityLabel, setAccessibilityLanguage, setAccessibilityNavigationStyle, setAccessibilityPath, setAccessibilityRespondsToUserInteraction, setAccessibilityTextualContext, setAccessibilityTraits, setAccessibilityUserInputLabels, setAccessibilityValue, setAccessibilityViewIsModal, setIsAccessibilityElement, setNilValueForKey, setObservationInfo, setShouldGroupAccessibilityChildren, setValueForKey, setValueForKeyPath, setValueForUndefinedKey, setValuesForKeysWithDictionary, shouldGroupAccessibilityChildren, superclass, validateValueForKeyError, validateValueForKeyPathError, valueForKey, valueForKeyPath, valueForUndefinedKey, willChangeValueForKey, willChangeValueForKeyWithSetMutationUsingObjects, willChangeValuesAtIndexesForKey

Methods inherited from class org.moe.natj.objc.ObjCObject
equals, toString

Methods inherited from class org.moe.natj.general.NativeObject
finalize, getPeer, getPeerPointer

Methods inherited from class java.lang.Object
clone, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - MPSCNNMultiaryKernel
```
protected MPSCNNMultiaryKernel(org.moe.natj.general.Pointer peer)
```
- Method Detail
  - accessInstanceVariablesDirectly
```
public static boolean accessInstanceVariablesDirectly()
```
  - alloc
```
public static MPSCNNMultiaryKernel alloc()
```
  - allocWithZone
```
public static MPSCNNMultiaryKernel allocWithZone(org.moe.natj.general.ptr.VoidPtr zone)
```
  - appendBatchBarrier
```
public boolean appendBatchBarrier()
```
    Returns YES if the filter must be run over the entire batch before its results may be used
    Nearly all filters do not need to see the entire batch all at once and can operate correctly with partial batches. This allows the graph to strip-mine the problem, processing the graph top to bottom on a subset of the batch at a time, dramatically reducing memory usage. As the full nominal working set for a graph is often so large that it may not fit in memory, sub-batching may be required forward progress.
    Batch normalization statistics on the other hand must complete the batch before the statistics may be used to normalize the images in the batch in the ensuing normalization filter. Consequently, batch normalization statistics requests the graph insert a batch barrier following it by returning YES from -appendBatchBarrier. This tells the graph to complete the batch before any dependent filters can start. Note that the filter itself may still be subject to sub-batching in its operation. All filters must be able to function without seeing the entire batch in a single -encode call. Carry over state that is accumulated across sub-batches is commonly carried in a shared MPSState containing a MTLBuffer. See -isResultStateReusedAcrossBatch.
    Caution: on most supported devices, the working set may be so large that the graph may be forced to throw away and recalculate most intermediate images in cases where strip-mining can not occur because -appendBatchBarrier returns YES. A single batch barrier can commonly cause a memory size increase and/or performance reduction by many fold over the entire graph. Filters of this variety should be avoided.
    Default: NO
  - automaticallyNotifiesObserversForKey
```
public static boolean automaticallyNotifiesObserversForKey(java.lang.String key)
```
  - cancelPreviousPerformRequestsWithTarget
```
public static void cancelPreviousPerformRequestsWithTarget(java.lang.Object aTarget)
```
  - cancelPreviousPerformRequestsWithTargetSelectorObject
```
public static void cancelPreviousPerformRequestsWithTargetSelectorObject(java.lang.Object aTarget,
                                                                         org.moe.natj.objc.SEL aSelector,
                                                                         java.lang.Object anArgument)
```
  - classFallbacksForKeyedArchiver
```
public static NSArray<java.lang.String> classFallbacksForKeyedArchiver()
```
  - classForKeyedUnarchiver
```
public static org.moe.natj.objc.Class classForKeyedUnarchiver()
```
  - clipRect
```
public MTLRegion clipRect()
```
    [@property] clipRect
    An optional clip rectangle to use when writing data. Only the pixels in the rectangle will be overwritten.
    A MTLRegion that indicates which part of the destination to overwrite. If the clipRect does not lie completely within the destination image, the intersection between clip rectangle and destination bounds is used. Default: MPSRectNoClip (MPSKernel::MPSRectNoClip) indicating the entire image. clipRect.origin.z is the index of starting destination image in batch processing mode. clipRect.size.depth is the number of images to process in batch processing mode.
    See Also: @ref subsubsection_clipRect
  - debugDescription_static
```
public static java.lang.String debugDescription_static()
```
  - description_static
```
public static java.lang.String description_static()
```
  - destinationFeatureChannelOffset
```
public long destinationFeatureChannelOffset()
```
    [@property] destinationFeatureChannelOffset
    The number of channels in the destination MPSImage to skip before writing output.
    This is the starting offset into the destination image in the feature channel dimension at which destination data is written. This allows an application to pass a subset of all the channels in MPSImage as output of MPSKernel. E.g. Suppose MPSImage has 24 channels and a MPSKernel outputs 8 channels. If we want channels 8 to 15 of this MPSImage to be used as output, we can set destinationFeatureChannelOffset = 8. Note that this offset applies independently to each image when the MPSImage is a container for multiple images and the MPSCNNKernel is processing multiple images (clipRect.size.depth > 1). The default value is 0 and any value specifed shall be a multiple of 4. If MPSKernel outputs N channels, destination image MUST have at least destinationFeatureChannelOffset + N channels. Using a destination image with insufficient number of feature channels result in an error. E.g. if the MPSCNNConvolution outputs 32 channels, and destination has 64 channels, then it is an error to set destinationFeatureChannelOffset > 32.
  - destinationImageAllocator
```
public MPSImageAllocator destinationImageAllocator()
```
    Method to allocate the result image for -encodeToCommandBuffer:sourceImage:
    Default: MPSTemporaryImage.defaultAllocator
  - destinationImageDescriptorForSourceImagesSourceStates
```
public MPSImageDescriptor destinationImageDescriptorForSourceImagesSourceStates(NSArray<? extends MPSImage> sourceImages,
                                                                                NSArray<? extends MPSState> sourceStates)
```
    Get a suggested destination image descriptor for a source image
    Your application is certainly free to pass in any destinationImage it likes to encodeToCommandBuffer:sourceImage:destinationImage, within reason. This is the basic design for iOS 10. This method is therefore not required.
    However, calculating the MPSImage size and MPSCNNKernel properties for each filter can be tedious and complicated work, so this method is made available to automate the process. The application may modify the properties of the descriptor before a MPSImage is made from it, so long as the choice is sensible for the kernel in question. Please see individual kernel descriptions for restrictions.
    The expected timeline for use is as follows:
    1) This method is called: a) The default MPS padding calculation is applied. It uses the MPSNNPaddingMethod of the .padding property to provide a consistent addressing scheme over the graph. It creates the MPSImageDescriptor and adjusts the .offset property of the MPSNNKernel. When using a MPSNNGraph, the padding is set using the MPSNNFilterNode as a proxy.
    b) This method may be overridden by MPSCNNKernel subclass to achieve any customization appropriate to the object type.
    c) Source states are then applied in order. These may modify the descriptor and may update other object properties. See: -destinationImageDescriptorForSourceImages:sourceStates: forKernel:suggestedDescriptor: This is the typical way in which MPS may attempt to influence the operation of its kernels.
    d) If the .padding property has a custom padding policy method of the same name, it is called. Similarly, it may also adjust the descriptor and any MPSCNNKernel properties. This is the typical way in which your application may attempt to influence the operation of the MPS kernels.
    2) A result is returned from this method and the caller may further adjust the descriptor and kernel properties directly.
    3) The caller uses the descriptor to make a new MPSImage to use as the destination image for the -encode call in step 5.
    4) The caller calls -resultStateForSourceImage:sourceStates:destinationImage: to make any result states needed for the kernel. If there isn't one, it will return nil. A variant is available to return a temporary state instead.
    5) a -encode method is called to encode the kernel.
    The entire process 1-5 is more simply achieved by just calling an -encode... method that returns a MPSImage out the left hand sid of the method. Simpler still, use the MPSNNGraph to coordinate the entire process from end to end. Opportunities to influence the process are of course reduced, as (2) is no longer possible with either method. Your application may opt to use the five step method if it requires greater customization as described, or if it would like to estimate storage in advance based on the sum of MPSImageDescriptors before processing a graph. Storage estimation is done by using the MPSImageDescriptor to create a MPSImage (without passing it a texture), and then call -resourceSize. As long as the MPSImage is not used in an encode call and the .texture property is not invoked, the underlying MTLTexture is not created.
    No destination state or destination image is provided as an argument to this function because it is expected they will be made / configured after this is called. This method is expected to auto-configure important object properties that may be needed in the ensuing destination image and state creation steps.
    
    Parameters:
    
    sourceImages - A array of source images that will be passed into the -encode call Since MPSCNNKernel is a unary kernel, it is an array of length 1.
    
    sourceStates - An optional array of source states that will be passed into the -encode call
    
    Returns:
    
    an image descriptor allocated on the autorelease pool
  - dilationRateXatIndex
```
public long dilationRateXatIndex(long index)
```
    Stride in source coordinates from one kernel tap to the next in the X dimension.
    
    Parameters:
    
    index - The index of the source image to which the dilation rate applies
    
    Returns:
    
    The dilation rate
  - dilationRateYatIndex
```
public long dilationRateYatIndex(long index)
```
    Stride in source coordinates from one kernel tap to the next in the Y dimension.
    
    Parameters:
    
    index - The index of the source image to which the dilation rate applies
    
    Returns:
    
    The dilation rate
  - edgeModeAtIndex
```
public long edgeModeAtIndex(long index)
```
    The MPSImageEdgeMode to use when texture reads stray off the edge of the primary source image
    Most MPSKernel objects can read off the edge of the source image. This can happen because of a negative offset property, because the offset + clipRect.size is larger than the source image or because the filter looks at neighboring pixels, such as a Convolution filter. Default: MPSImageEdgeModeZero.
    See Also: @ref subsubsection_edgemode
    
    Parameters:
    
    index - The index of the source image to which the edge mode refers
    
    Returns:
    
    The edge mode for that source image
  - encodeToCommandBufferSourceImages
```
public MPSImage encodeToCommandBufferSourceImages(MTLCommandBuffer commandBuffer,
                                                  NSArray<? extends MPSImage> sourceImages)
```
    Encode a MPSCNNKernel into a command Buffer. Create a texture to hold the result and return it.
    In the first iteration on this method, encodeToCommandBuffer:sourceImage:destinationImage: some work was left for the developer to do in the form of correctly setting the offset property and sizing the result buffer. With the introduction of the padding policy (see padding property) the filter can do this work itself. If you would like to have some input into what sort of MPSImage (e.g. temporary vs. regular) or what size it is or where it is allocated, you may set the destinationImageAllocator to allocate the image yourself.
    This method uses the MPSNNPadding padding property to figure out how to size the result image and to set the offset property. See discussion in MPSNeuralNetworkTypes.h.
    
    Parameters:
    
    commandBuffer - The command buffer
    
    sourceImages - An array of MPSImages to use as the source images for the filter.
    
    Returns:
    
    A MPSImage or MPSTemporaryImage allocated per the destinationImageAllocator containing the output of the graph. The returned image will be automatically released when the command buffer completes. If you want to keep it around for longer, retain the image. (ARC will do this for you if you use it later.)
  - encodeToCommandBufferSourceImagesDestinationImage
```
public void encodeToCommandBufferSourceImagesDestinationImage(MTLCommandBuffer commandBuffer,
                                                              NSArray<? extends MPSImage> sourceImages,
                                                              MPSImage destinationImage)
```
    Encode a MPSCNNKernel into a command Buffer. The operation shall proceed out-of-place.
    This is the older style of encode which reads the offset, doesn't change it, and ignores the padding method.
    
    Parameters:
    
    commandBuffer - A valid MTLCommandBuffer to receive the encoded filter
    
    sourceImages - An array containing the source images
    
    destinationImage - A valid MPSImage to be overwritten by result image. destinationImage may not alias primarySourceImage or secondarySourceImage.
  - encodeToCommandBufferSourceImagesDestinationStateDestinationStateIsTemporary
```
public MPSImage encodeToCommandBufferSourceImagesDestinationStateDestinationStateIsTemporary(MTLCommandBuffer commandBuffer,
                                                                                             NSArray<? extends MPSImage> sourceImages,
                                                                                             org.moe.natj.general.ptr.Ptr<MPSState> outState,
                                                                                             boolean isTemporary)
```
    Encode a MPSCNNKernel into a command Buffer. Create a texture and state to hold the results and return them.
    In the first iteration on this method, encodeToCommandBuffer:sourceImage:destinationState:destinationImage: some work was left for the developer to do in the form of correctly setting the offset property and sizing the result buffer. With the introduction of the padding policy (see padding property) the filter can do this work itself. If you would like to have some input into what sort of MPSImage (e.g. temporary vs. regular) or what size it is or where it is allocated, you may set the destinationImageAllocator to allocate the image yourself.
    This method uses the MPSNNPadding padding property to figure out how to size the result image and to set the offset property. See discussion in MPSNeuralNetworkTypes.h. All images in a batch must have MPSImage.numberOfImages = 1.
    
    Parameters:
    
    commandBuffer - The command buffer
    
    sourceImages - An array of MPSImages to use as the source images for the filter.
    
    outState - The address of location to write the pointer to the result state of the operation
    
    isTemporary - YES if the outState should be a temporary object
    
    Returns:
    
    A MPSImage or MPSTemporaryImage allocated per the destinationImageAllocator containing the output of the graph. The offset property will be adjusted to reflect the offset used during the encode. The returned image will be automatically released when the command buffer completes. If you want to keep it around for longer, retain the image. (ARC will do this for you if you use it later.)
  - hash_static
```
public static long hash_static()
```
  - init
```
public MPSCNNMultiaryKernel init()
```
    Overrides:
    
    init in class MPSKernel
  - initWithCoder
```
public MPSCNNMultiaryKernel initWithCoder(NSCoder aDecoder)
```
    Description copied from interface: NSCoding
    
    NS_DESIGNATED_INITIALIZER
    
    Specified by:
    
    initWithCoder in interface NSCoding
    
    Overrides:
    
    initWithCoder in class MPSKernel
  - initWithCoderDevice
```
public MPSCNNMultiaryKernel initWithCoderDevice(NSCoder aDecoder,
                                                java.lang.Object device)
```
    NSSecureCoding compatability
    While the standard NSSecureCoding/NSCoding method -initWithCoder: should work, since the file can't know which device your data is allocated on, we have to guess and may guess incorrectly. To avoid that problem, use initWithCoder:device instead.
    
    Overrides:
    
    initWithCoderDevice in class MPSKernel
    
    Parameters:
    
    aDecoder - The NSCoder subclass with your serialized MPSKernel
    
    device - The MTLDevice on which to make the MPSKernel
    
    Returns:
    
    A new MPSKernel object, or nil if failure.
  - initWithDevice
```
public MPSCNNMultiaryKernel initWithDevice(java.lang.Object device)
```
    Description copied from class: MPSKernel
    
    Standard init with default properties per filter type
    
    Overrides:
    
    initWithDevice in class MPSKernel
    
    Parameters:
    
    device - The device that the filter will be used on. May not be NULL.
    
    Returns:
    
    a pointer to the newly initialized object. This will fail, returning nil if the device is not supported. Devices must be MTLFeatureSet_iOS_GPUFamily2_v1 or later.
  - initWithDeviceSourceCount
```
public MPSCNNMultiaryKernel initWithDeviceSourceCount(MTLDevice device,
                                                      long sourceCount)
```
    Standard init with default properties per filter type
    
    Parameters:
    
    device - The device that the filter will be used on. May not be NULL.
    
    sourceCount - The number of source images or MPSImageBatches
    
    Returns:
    
    A pointer to the newly initialized object. This will fail, returning nil if the device is not supported. Devices must be MTLFeatureSet_iOS_GPUFamily2_v1 or later.
  - instanceMethodForSelector
```
public static NSObject.Function_instanceMethodForSelector_ret instanceMethodForSelector(org.moe.natj.objc.SEL aSelector)
```
  - instanceMethodSignatureForSelector
```
public static NSMethodSignature instanceMethodSignatureForSelector(org.moe.natj.objc.SEL aSelector)
```
  - instancesRespondToSelector
```
public static boolean instancesRespondToSelector(org.moe.natj.objc.SEL aSelector)
```
  - isBackwards
```
public boolean isBackwards()
```
    [@property] isBackwards
    YES if the filter operates backwards.
    This influences how strideInPixelsX/Y should be interpreted.
  - isResultStateReusedAcrossBatch
```
public boolean isResultStateReusedAcrossBatch()
```
    Returns YES if the same state is used for every operation in a batch
    If NO, then each image in a MPSImageBatch will need a corresponding (and different) state to go with it. Set to YES to avoid allocating redundant state in the case when the same state is used all the time. Default: NO
  - isStateModified
```
public boolean isStateModified()
```
    Returns true if the -encode call modifies the state object it accepts.
  - isSubclassOfClass
```
public static boolean isSubclassOfClass(org.moe.natj.objc.Class aClass)
```
  - kernelHeightAtIndex
```
public long kernelHeightAtIndex(long index)
```
    The height of the kernel filter window
    This is the horizontal diameter of the region read by the filter for each result pixel. If the MPSCNNKernel does not have a filter window, then 1 will be returned.
    
    Parameters:
    
    index - The index of the source image to which the kernel width refers
  - kernelWidthAtIndex
```
public long kernelWidthAtIndex(long index)
```
    The width of the kernel filter window
    This is the horizontal diameter of the region read by the filter for each result pixel. If the MPSCNNKernel does not have a filter window, then 1 will be returned.
    
    Parameters:
    
    index - The index of the source image to which the kernel width refers
  - keyPathsForValuesAffectingValueForKey
```
public static NSSet<java.lang.String> keyPathsForValuesAffectingValueForKey(java.lang.String key)
```
  - new_objc
```
public static MPSCNNMultiaryKernel new_objc()
```
  - offsetAtIndex
```
public MPSOffset offsetAtIndex(long index)
```
    The positon of the destination clip rectangle origin relative to each source buffer
    The offset is defined to be the position of clipRect.origin in source coordinates. Default: {0,0,0}, indicating that the top left corners of the clipRect and source image align. offset.z is the index of starting source image in batch processing mode.
    
    Parameters:
    
    index - The index of the source image described by the offset
    
    Returns:
    
    A MPSOffset for that image
  - padding
```
public MPSNNPadding padding()
```
    [@property] padding
    The padding method used by the filter
    This influences how strideInPixelsX/Y should be interpreted. Default: MPSNNPaddingMethodAlignCentered | MPSNNPaddingMethodAddRemainderToTopLeft | MPSNNPaddingMethodSizeSame Some object types (e.g. MPSCNNFullyConnected) may override this default with something appropriate to its operation.
  - resolveClassMethod
```
public static boolean resolveClassMethod(org.moe.natj.objc.SEL sel)
```
  - resolveInstanceMethod
```
public static boolean resolveInstanceMethod(org.moe.natj.objc.SEL sel)
```
  - resultStateForSourceImagesSourceStatesDestinationImage
```
public MPSState resultStateForSourceImagesSourceStatesDestinationImage(NSArray<? extends MPSImage> sourceImages,
                                                                       NSArray<? extends MPSState> sourceStates,
                                                                       MPSImage destinationImage)
```
    Allocate a MPSState (subclass) to hold the results from a -encodeBatchToCommandBuffer... operation
    A graph may need to allocate storage up front before executing. This may be necessary to avoid using too much memory and to manage large batches. The function should allocate any MPSState objects that will be produced by an -encode call with the indicated sourceImages and sourceStates inputs. Though the states can be further adjusted in the ensuing -encode call, the states should be initialized with all important data and all MTLResource storage allocated. The data stored in the MTLResource need not be initialized, unless the ensuing -encode call expects it to be.
    The MTLDevice used by the result is derived from the source image. The padding policy will be applied to the filter before this is called to give it the chance to configure any properties like MPSCNNKernel.offset.
    CAUTION: The kernel must have all properties set to values that will ultimately be passed to the -encode call that writes to the state, before -resultStateForSourceImages:sourceStates:destinationImage: is called or behavior is undefined. Please note that -destinationImageDescriptorForSourceImages:sourceStates: will alter some of these properties automatically based on the padding policy. If you intend to call that to make the destination image, then you should call that before -resultStateForSourceImages:sourceStates:destinationImage:. This will ensure the properties used in the encode call and in the destination image creation match those used to configure the state.
    The following order is recommended:
    // Configure MPSCNNKernel properties first kernel.edgeMode = MPSImageEdgeModeZero; kernel.destinationFeatureChannelOffset = 128; // concatenation without the copy ...
    // ALERT: will change MPSCNNKernel properties MPSImageDescriptor * d = [kernel destinationImageDescriptorForSourceImage: source sourceStates: states]; MPSTemporaryImage * dest = [MPSTemporaryImage temporaryImageWithCommandBuffer: cmdBuf imageDescriptor: d];
    // Now that all properties are configured properly, we can make the result state // and call encode. MPSState * __nullable destState = [kernel resultStateForSourceImage: source sourceStates: states destinationImage: dest];
    // This form of -encode will be declared by the MPSCNNKernel subclass [kernel encodeToCommandBuffer: cmdBuf sourceImage: source destinationState: destState destinationImage: dest ];
    Default: returns nil
    
    Parameters:
    
    sourceImages - The MPSImage consumed by the associated -encode call.
    
    sourceStates - The list of MPSStates consumed by the associated -encode call, for a batch size of 1.
    
    destinationImage - The destination image for the encode call
    
    Returns:
    
    The list of states produced by the -encode call for batch size of 1. When the batch size is not 1, this function will be called repeatedly unless -isResultStateReusedAcrossBatch returns YES. If -isResultStateReusedAcrossBatch returns YES, then it will be called once per batch and the MPSStateBatch array will contain MPSStateBatch.length references to the same object.
  - setClipRect
```
public void setClipRect(MTLRegion value)
```
    [@property] clipRect
    An optional clip rectangle to use when writing data. Only the pixels in the rectangle will be overwritten.
    A MTLRegion that indicates which part of the destination to overwrite. If the clipRect does not lie completely within the destination image, the intersection between clip rectangle and destination bounds is used. Default: MPSRectNoClip (MPSKernel::MPSRectNoClip) indicating the entire image. clipRect.origin.z is the index of starting destination image in batch processing mode. clipRect.size.depth is the number of images to process in batch processing mode.
    See Also: @ref subsubsection_clipRect
  - setDestinationFeatureChannelOffset
```
public void setDestinationFeatureChannelOffset(long value)
```
    [@property] destinationFeatureChannelOffset
    The number of channels in the destination MPSImage to skip before writing output.
    This is the starting offset into the destination image in the feature channel dimension at which destination data is written. This allows an application to pass a subset of all the channels in MPSImage as output of MPSKernel. E.g. Suppose MPSImage has 24 channels and a MPSKernel outputs 8 channels. If we want channels 8 to 15 of this MPSImage to be used as output, we can set destinationFeatureChannelOffset = 8. Note that this offset applies independently to each image when the MPSImage is a container for multiple images and the MPSCNNKernel is processing multiple images (clipRect.size.depth > 1). The default value is 0 and any value specifed shall be a multiple of 4. If MPSKernel outputs N channels, destination image MUST have at least destinationFeatureChannelOffset + N channels. Using a destination image with insufficient number of feature channels result in an error. E.g. if the MPSCNNConvolution outputs 32 channels, and destination has 64 channels, then it is an error to set destinationFeatureChannelOffset > 32.
  - setDestinationImageAllocator
```
public void setDestinationImageAllocator(MPSImageAllocator value)
```
    Method to allocate the result image for -encodeToCommandBuffer:sourceImage:
    Default: MPSTemporaryImage.defaultAllocator
  - setDilationRateXAtIndex
```
public void setDilationRateXAtIndex(long dilationRate,
                                    long index)
```
    Set the stride in source coordinates from one kernel tap to the next in the X dimension.
    
    Parameters:
    
    index - The index of the source image to which the dilation rate applies
    
    dilationRate - The dilation rate
  - setDilationRateYAtIndex
```
public void setDilationRateYAtIndex(long dilationRate,
                                    long index)
```
    Set the stride in source coordinates from one kernel tap to the next in the Y dimension.
    
    Parameters:
    
    index - The index of the source image to which the dilation rate applies
    
    dilationRate - The dilation rate
  - setEdgeModeAtIndex
```
public void setEdgeModeAtIndex(long edgeMode,
                               long index)
```
    Set the MPSImageEdgeMode to use when texture reads stray off the edge of the primary source image
    Most MPSKernel objects can read off the edge of the source image. This can happen because of a negative offset property, because the offset + clipRect.size is larger than the source image or because the filter looks at neighboring pixels, such as a Convolution filter. Default: MPSImageEdgeModeZero.
    See Also: @ref subsubsection_edgemode
    
    Parameters:
    
    edgeMode - The new edge mode to use
    
    index - The index of the source image to which the edge mode refers
  - setKernelHeightAtIndex
```
public void setKernelHeightAtIndex(long height,
                                   long index)
```
    Set the height of the kernel filter window
    This is the horizontal diameter of the region read by the filter for each result pixel. If the MPSCNNKernel does not have a filter window, then 1 will be returned.
    
    Parameters:
    
    height - The new width
    
    index - The index of the source image to which the kernel width refers
  - setKernelWidthAtIndex
```
public void setKernelWidthAtIndex(long width,
                                  long index)
```
    Set the width of the kernel filter window
    This is the horizontal diameter of the region read by the filter for each result pixel. If the MPSCNNKernel does not have a filter window, then 1 will be returned.
    
    Parameters:
    
    width - The new width
    
    index - The index of the source image to which the kernel width refers
  - setOffsetAtIndex
```
public void setOffsetAtIndex(MPSOffset offset,
                             long index)
```
    Set the positon of the destination clip rectangle origin relative to each source buffer
    The offset is defined to be the position of clipRect.origin in source coordinates. Default: {0,0,0}, indicating that the top left corners of the clipRect and source image align. offset.z is the index of starting source image in batch processing mode.
    
    Parameters:
    
    offset - The new offset
    
    index - The index of the source image described by the offset
  - setPadding
```
public void setPadding(MPSNNPadding value)
```
    [@property] padding
    The padding method used by the filter
    This influences how strideInPixelsX/Y should be interpreted. Default: MPSNNPaddingMethodAlignCentered | MPSNNPaddingMethodAddRemainderToTopLeft | MPSNNPaddingMethodSizeSame Some object types (e.g. MPSCNNFullyConnected) may override this default with something appropriate to its operation.
  - setSourceFeatureChannelMaxCountAtIndex
```
public void setSourceFeatureChannelMaxCountAtIndex(long count,
                                                   long index)
```
    Set the maximum number of channels in the source MPSImage to use
    Most filters can insert a slice operation into the filter for free. Use this to limit the size of the feature channel slice taken from the input image. If the value is too large, it is truncated to be the remaining size in the image after the sourceFeatureChannelOffset is taken into account. Default: ULONG_MAX
    
    Parameters:
    
    count - The new source feature channel max count
    
    index - The index of the source image to which the max count refers
  - setSourceFeatureChannelOffsetAtIndex
```
public void setSourceFeatureChannelOffsetAtIndex(long offset,
                                                 long index)
```
    Set the number of channels in the source MPSImage to skip before reading the input.
    This is the starting offset into the source image in the feature channel dimension at which source data is read. Unit: feature channels This allows an application to read a subset of all the channels in MPSImage as input of MPSKernel. E.g. Suppose MPSImage has 24 channels and a MPSKernel needs to read 8 channels. If we want channels 8 to 15 of this MPSImage to be used as input, we can set sourceFeatureChannelOffset[0] = 8. Note that this offset applies independently to each image when the MPSImage is a container for multiple images and the MPSCNNKernel is processing multiple images (clipRect.size.depth > 1). The default value is 0 and any value specifed shall be a multiple of 4. If MPSKernel inputs N channels, the source image MUST have at least primarySourceFeatureChannelOffset + N channels. Using a source image with insufficient number of feature channels will result in an error. E.g. if the MPSCNNConvolution inputs 32 channels, and the source has 64 channels, then it is an error to set primarySourceFeatureChannelOffset > 32.
    
    Parameters:
    
    index - The index of the source image that the feature channel offset describes
    
    offset - The source feature channel offset
  - setStrideInPixelsXAtIndex
```
public void setStrideInPixelsXAtIndex(long stride,
                                      long index)
```
    The downsampling factor in the horizontal dimension for the source image
    If the filter does not do up or downsampling, 1 is returned. Default: 1
    
    Parameters:
    
    index - The index of the source Image
    
    stride - The stride for the source image
  - setStrideInPixelsYAtIndex
```
public void setStrideInPixelsYAtIndex(long stride,
                                      long index)
```
    The downsampling factor in the vertical dimension for the source image
    If the filter does not do up or downsampling, 1 is returned. Default: 1
    
    Parameters:
    
    index - The index of the source Image
    
    stride - The stride for the source image
  - setVersion_static
```
public static void setVersion_static(long aVersion)
```
  - sourceCount
```
public long sourceCount()
```
    The number of source images accepted by the kernel
  - sourceFeatureChannelMaxCountAtIndex
```
public long sourceFeatureChannelMaxCountAtIndex(long index)
```
    The maximum number of channels in the source MPSImage to use
    Most filters can insert a slice operation into the filter for free. Use this to limit the size of the feature channel slice taken from the input image. If the value is too large, it is truncated to be the remaining size in the image after the sourceFeatureChannelOffset is taken into account. Default: ULONG_MAX
    
    Parameters:
    
    index - The index of the source image to which the max count refers
    
    Returns:
    
    The source feature channel max count
  - sourceFeatureChannelOffsetAtIndex
```
public long sourceFeatureChannelOffsetAtIndex(long index)
```
    The number of channels in the source MPSImage to skip before reading the input.
    This is the starting offset into the source image in the feature channel dimension at which source data is read. Unit: feature channels This allows an application to read a subset of all the channels in MPSImage as input of MPSKernel. E.g. Suppose MPSImage has 24 channels and a MPSKernel needs to read 8 channels. If we want channels 8 to 15 of this MPSImage to be used as input, we can set sourceFeatureChannelOffset[0] = 8. Note that this offset applies independently to each image when the MPSImage is a container for multiple images and the MPSCNNKernel is processing multiple images (clipRect.size.depth > 1). The default value is 0 and any value specifed shall be a multiple of 4. If MPSKernel inputs N channels, the source image MUST have at least primarySourceFeatureChannelOffset + N channels. Using a source image with insufficient number of feature channels will result in an error. E.g. if the MPSCNNConvolution inputs 32 channels, and the source has 64 channels, then it is an error to set primarySourceFeatureChannelOffset > 32.
    
    Parameters:
    
    index - The index of the source image that the feature channel offset describes
    
    Returns:
    
    The source feature channel offset
  - strideInPixelsXatIndex
```
public long strideInPixelsXatIndex(long index)
```
    The downsampling factor in the horizontal dimension for the source image
    If the filter does not do up or downsampling, 1 is returned.
    
    Parameters:
    
    index - The index of the source Image
    
    Returns:
    
    The stride
  - strideInPixelsYatIndex
```
public long strideInPixelsYatIndex(long index)
```
    The downsampling factor in the vertical dimension for the source image
    If the filter does not do up or downsampling, 1 is returned.
    
    Parameters:
    
    index - The index of the source Image
    
    Returns:
    
    The stride
  - superclass_static
```
public static org.moe.natj.objc.Class superclass_static()
```
  - supportsSecureCoding
```
public static boolean supportsSecureCoding()
```
  - _supportsSecureCoding
```
public boolean _supportsSecureCoding()
```
    Description copied from interface: NSSecureCoding
    
    This property must return YES on all classes that allow secure coding. Subclasses of classes that adopt NSSecureCoding and override initWithCoder: must also override this method and return YES. The Secure Coding Guide should be consulted when writing methods that decode data.
    
    Specified by:
    
    _supportsSecureCoding in interface NSSecureCoding
    
    Overrides:
    
    _supportsSecureCoding in class MPSKernel
  - temporaryResultStateForCommandBufferSourceImagesSourceStatesDestinationImage
```
public MPSState temporaryResultStateForCommandBufferSourceImagesSourceStatesDestinationImage(MTLCommandBuffer commandBuffer,
                                                                                             NSArray<? extends MPSImage> sourceImage,
                                                                                             NSArray<? extends MPSState> sourceStates,
                                                                                             MPSImage destinationImage)
```
    Allocate a temporary MPSState (subclass) to hold the results from a -encodeBatchToCommandBuffer... operation
    A graph may need to allocate storage up front before executing. This may be necessary to avoid using too much memory and to manage large batches. The function should allocate any MPSState objects that will be produced by an -encode call with the indicated sourceImages and sourceStates inputs. Though the states can be further adjusted in the ensuing -encode call, the states should be initialized with all important data and all MTLResource storage allocated. The data stored in the MTLResource need not be initialized, unless the ensuing -encode call expects it to be.
    The MTLDevice used by the result is derived from the command buffer. The padding policy will be applied to the filter before this is called to give it the chance to configure any properties like MPSCNNKernel.offset.
    CAUTION: The kernel must have all properties set to values that will ultimately be passed to the -encode call that writes to the state, before -resultStateForSourceImages:sourceStates:destinationImage: is called or behavior is undefined. Please note that -destinationImageDescriptorForSourceImages:sourceStates:destinationImage: will alter some of these properties automatically based on the padding policy. If you intend to call that to make the destination image, then you should call that before -resultStateForSourceImages:sourceStates:destinationImage:. This will ensure the properties used in the encode call and in the destination image creation match those used to configure the state.
    The following order is recommended:
    // Configure MPSCNNKernel properties first kernel.edgeMode = MPSImageEdgeModeZero; kernel.destinationFeatureChannelOffset = 128; // concatenation without the copy ...
    // ALERT: will change MPSCNNKernel properties MPSImageDescriptor * d = [kernel destinationImageDescriptorForSourceImage: source sourceStates: states]; MPSTemporaryImage * dest = [MPSTemporaryImage temporaryImageWithCommandBuffer: cmdBuf imageDescriptor: d];
    // Now that all properties are configured properly, we can make the result state // and call encode. MPSState * __nullable destState = [kernel temporaryResultStateForCommandBuffer: cmdBuf sourceImage: source sourceStates: states];
    // This form of -encode will be declared by the MPSCNNKernel subclass [kernel encodeToCommandBuffer: cmdBuf sourceImage: source destinationState: destState destinationImage: dest ];
    Default: returns nil
    
    Parameters:
    
    commandBuffer - The command buffer to allocate the temporary storage against The state will only be valid on this command buffer.
    
    sourceImage - The MPSImage consumed by the associated -encode call.
    
    sourceStates - The list of MPSStates consumed by the associated -encode call, for a batch size of 1.
    
    destinationImage - The destination image for the encode call
    
    Returns:
    
    The list of states produced by the -encode call for batch size of 1. When the batch size is not 1, this function will be called repeatedly unless -isResultStateReusedAcrossBatch returns YES. If -isResultStateReusedAcrossBatch returns YES, then it will be called once per batch and the MPSStateBatch array will contain MPSStateBatch.length references to the same object.
  - version_static
```
public static long version_static()
```

Class MPSCNNMultiaryKernel

Nested Class Summary

Nested classes/interfaces inherited from class apple.NSObject

Constructor Summary

Method Summary

Methods inherited from class apple.metalperformanceshaders.MPSKernel

Methods inherited from class apple.NSObject

Methods inherited from class org.moe.natj.objc.ObjCObject

Methods inherited from class org.moe.natj.general.NativeObject

Methods inherited from class java.lang.Object

Constructor Detail

MPSCNNMultiaryKernel

Method Detail

accessInstanceVariablesDirectly

alloc

allocWithZone

appendBatchBarrier

automaticallyNotifiesObserversForKey

cancelPreviousPerformRequestsWithTarget

cancelPreviousPerformRequestsWithTargetSelectorObject

classFallbacksForKeyedArchiver

classForKeyedUnarchiver

clipRect

debugDescription_static

description_static

destinationFeatureChannelOffset

destinationImageAllocator

destinationImageDescriptorForSourceImagesSourceStates

dilationRateXatIndex

dilationRateYatIndex

edgeModeAtIndex

encodeToCommandBufferSourceImages

encodeToCommandBufferSourceImagesDestinationImage

encodeToCommandBufferSourceImagesDestinationStateDestinationStateIsTemporary

hash_static

init

initWithCoder

initWithCoderDevice

initWithDevice

initWithDeviceSourceCount

instanceMethodForSelector

instanceMethodSignatureForSelector

instancesRespondToSelector

isBackwards

isResultStateReusedAcrossBatch

isStateModified

isSubclassOfClass

kernelHeightAtIndex

kernelWidthAtIndex

keyPathsForValuesAffectingValueForKey

new_objc

offsetAtIndex

padding

resolveClassMethod

resolveInstanceMethod

resultStateForSourceImagesSourceStatesDestinationImage

setClipRect

setDestinationFeatureChannelOffset

setDestinationImageAllocator

setDilationRateXAtIndex

setDilationRateYAtIndex

setEdgeModeAtIndex

setKernelHeightAtIndex

setKernelWidthAtIndex

setOffsetAtIndex

setPadding

setSourceFeatureChannelMaxCountAtIndex

setSourceFeatureChannelOffsetAtIndex

setStrideInPixelsXAtIndex

setStrideInPixelsYAtIndex

setVersion_static

sourceCount

sourceFeatureChannelMaxCountAtIndex

sourceFeatureChannelOffsetAtIndex

strideInPixelsXatIndex

strideInPixelsYatIndex

superclass_static

supportsSecureCoding

_supportsSecureCoding

temporaryResultStateForCommandBufferSourceImagesSourceStatesDestinationImage