VVBuffer.h

Go to the documentation of this file.

#import <Cocoa/Cocoa.h>
#import <OpenGL/CGLMacro.h>
#import <CoreVideo/CoreVideo.h>
#import <IOSurface/IOSurface.h>



typedef enum _VVBufferType  {
    VVBufferType_None = 0,  
    VVBufferType_RB,    
    VVBufferType_FBO,   
    VVBufferType_Tex,   
    VVBufferType_PBO,   //  PBO
    VVBufferType_VBO,   //  VBO
    VVBufferType_DispList,  //  display list
} VVBufferType;
typedef enum _VVBufferIntFormat {
    VVBufferIF_None = 0,    
    VVBufferIF_Lum8 = GL_LUMINANCE8,    
    VVBufferIF_LumFloat = GL_LUMINANCE32F_ARB,  
    VVBufferIF_R = GL_RED,  
    VVBufferIF_RGB = GL_RGB,    
    VVBufferIF_RGBA = GL_RGBA,  
    VVBufferIF_RGBA8 = GL_RGBA8,    
    VVBufferIF_Depth24 = GL_DEPTH_COMPONENT24,  
    VVBufferIF_RGBA32F = GL_RGBA32F_ARB,    
    VVBufferIF_RGB_DXT1 = GL_COMPRESSED_RGB_S3TC_DXT1_EXT,  
    VVBufferIF_RGBA_DXT5 = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,    
    VVBufferIF_YCoCg_DXT5 = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,   
} VVBufferIntFormat;
typedef enum _VVBufferPixFormat {
    VVBufferPF_None = 0,    
    VVBufferPF_Depth = GL_DEPTH_COMPONENT,  
    VVBufferPF_Lum = GL_LUMINANCE,  
    VVBufferPF_R = GL_RED,  
    VVBufferPF_RGBA = GL_RGBA,  
    VVBufferPF_BGRA = GL_BGRA,  
    VVBufferPF_YCBCR_422 = GL_YCBCR_422_APPLE,  
} VVBufferPixFormat;
typedef enum _VVBufferPixType   {
    VVBufferPT_None = 0,    
    VVBufferPT_Float = GL_FLOAT,    
    VVBufferPT_U_Byte = GL_UNSIGNED_BYTE,   
    VVBufferPT_U_Int_8888_Rev = GL_UNSIGNED_INT_8_8_8_8_REV,    
    VVBufferPT_U_Short_88 = GL_UNSIGNED_SHORT_8_8_APPLE,    
} VVBufferPixType;
typedef enum _VVBufferCPUBack   {
    VVBufferCPUBack_None = 0,   
    VVBufferCPUBack_Internal,   
    VVBufferCPUBack_External,   
} VVBufferCPUBack;
typedef enum _VVBufferGPUBack   {
    VVBufferGPUBack_None = 0,   
    VVBufferGPUBack_Internal,   
    VVBufferGPUBack_External,   
} VVBufferGPUBack;

typedef enum _VVBufferBackID    {
    VVBufferBackID_None = 0,    
    VVBufferBackID_GWorld,  //< the buffer was created from a gworld
    VVBufferBackID_Pixels,  
    VVBufferBackID_CVPixBuf,    
    VVBufferBackID_CVTex,   
    VVBufferBackID_NSBitImgRep, 
    VVBufferBackID_RemoteIOSrf, 
    VVBufferBackID_External 
} VVBufferBackID;
typedef struct _VVBufferDescriptor  {
    VVBufferType        type;           
    GLuint              target;         
    VVBufferIntFormat   internalFormat; 
    VVBufferPixFormat   pixelFormat;    
    VVBufferPixType     pixelType;      
    VVBufferCPUBack     cpuBackingType; 
    VVBufferGPUBack     gpuBackingType; 
    GLuint              name;           
    BOOL                texRangeFlag;   
    BOOL                texClientStorageFlag;   
    GLuint              msAmount;       
    unsigned long       localSurfaceID; 
} VVBufferDescriptor;




void VVBufferDescriptorPopulateDefault(VVBufferDescriptor *d);
void VVBufferDescriptorCopy(VVBufferDescriptor *src, VVBufferDescriptor *dst);
BOOL VVBufferDescriptorCompare(VVBufferDescriptor *a, VVBufferDescriptor *b);
BOOL VVBufferDescriptorCompareForRecycling(VVBufferDescriptor *a, VVBufferDescriptor *b);
unsigned long VVBufferDescriptorCalculateCPUBackingForSize(VVBufferDescriptor *b, NSSize s);





typedef void (*VVBufferBackingReleaseCallback)(id VVBufferBeingFreed, void *callbackContext);

@interface VVBuffer : NSObject <NSCopying> {
    VVBufferDescriptor  descriptor; //  struct that describes the GL resource this instance of VVBuffer represents
    
    BOOL                preferDeletion; //  NO by default.  if YES, this instance will be freed immediately (rather than put back in a pool).  note that some resources will be freed immediately no matter what- even if this is NO!
    NSSize              size;   //  the dimensions of the GL resource, expressed in pixels (even if it's a 2D texture- this is pixel-based!)
    NSRect              srcRect;    //  rect describing the area of this buffer to use.  again, always pixel-based, even when the target is GL_TEXTURE_2D.
    BOOL                flipped;    //  if YES, the area described by "srcRect" should be flipped vertically before display
    NSSize              backingSize;    //  sometimes, the backing has a different size (gworlds backing compressed textures)
    GLfloat             *auxTransMatrix;    //  "retained", nil by default. sometimes it's convenient to store transform matrices necessary to do scaling/translation/perspective distortion with the buffers that use them.
    GLfloat             auxOpacity; //  like "auxTransMatrix", sometimes it's convenient to store an auxiliary "opacity" value. this opacity value isn't reflected by the contents of this VVBuffer- rather, it's intended to store a value for later application to this buffer.
    struct timeval      contentTimestamp;   //  set by the buffer pool's class method.  this variable is *NOT* set automatically- its use is entirely optional and up to the implementation
    id                  userInfo;   //  RETAINED, nil by default.  not used by this class- stick whatever you want here and it will be retained for the lifetime of this buffer.  retained if you copy the buffer!
    
    VVBufferBackID      backingID;  //  totally optional, used to describe where the backing came from. sometimes you want to know what kind of backing a VVBuffer has, and access it.  there's an enum describing some of the more common sources, and you can define and use your own values here.
    void                *cpuBackingPtr; //  weak ref, only non-nil if there's a cpu backing for the GL resource.  ptr to the raw pixel data (this ptr is passed to GL upload/download functions)
    
    /*      this callback and callback context are used when the VVBuffer and its resources need to be freed.  these can be used to quickly and easily add support for other image processing frameworks (using VVBuffer to wrap opaque image types)        */
    VVBufferBackingReleaseCallback  backingReleaseCallback; //  this function is called when the image resources need to be released
    void                *backingReleaseCallbackContext; //  weak ref. this is an arbitrary data pointer that is stored with a buffer for use with the buffer release callback
    
    /*      if this instance of VVBuffer has a corresponding IOSurfaceRef, it's retained here.  these will always be valid- even if you copy a VVBuffer.        */
    IOSurfaceRef        localSurfaceRef;    //  RETAINED, nil by default.  the "local" surface ref was created by this process.
    IOSurfaceRef        remoteSurfaceRef;   //  RETAINED, nil by default.  the "remote" surface ref was created by another process (so this should probably be released immediately).
    
    /*      these variables pertain to the buffer in its pool- idle counts, the original buffer for this resource (in the case of copied buffers), that sort of thing.      */
    id                  parentBufferPool;   //  RETAINED! the pool exists until all its buffers are gone!
    id                  copySourceBuffer;   //  RETAINED, nil by default. if you copy a VVBuffer using the NSCopying protocol, the original buffer is retained here (so the underlying resources don't get freed until all VVBuffer instances referring to them get freed).
    int                 idleCount;  //  when a buffer's in a pool waiting to be re-used, its idleCount is incremented- if it gets high enough, the buffer is actually freed and its resources released
}

+ (id) createWithPool:(id)p;
- (id) initWithPool:(id)p;

- (VVBufferDescriptor *) descriptorPtr;
- (void) setDescriptorFromPtr:(VVBufferDescriptor *)n;
@property (assign, readwrite) BOOL preferDeletion;
@property (readonly) NSSize size;
- (void) setSize:(NSSize)n;
@property (assign, readwrite) NSRect srcRect;
@property (assign, readwrite) BOOL flipped;
@property (assign, readwrite) NSSize backingSize;
- (struct timeval *) contentTimestampPtr;
- (void) getContentTimestamp:(struct timeval *)n;
- (void) setContentTimestampFromPtr:(struct timeval *)n;
- (void) setUserInfo:(id)n;
- (id) userInfo;
- (void) setAuxTransMatrix:(GLfloat *)n;
- (GLfloat *) auxTransMatrix;
@property (assign, readwrite) GLfloat auxOpacity;
@property (readonly) NSRect normalizedSrcRect;
@property (readonly) NSRect glReadySrcRect;

- (NSRect) srcRectCroppedWith:(NSRect)cropRect takingFlipIntoAccount:(BOOL)f;
@property (readonly) BOOL isFullFrame;
@property (readonly) GLuint name;
@property (readonly) GLuint target;
@property (readonly) BOOL safeToPublishToSyphon;
- (BOOL) isContentMatchToBuffer:(VVBuffer *)n;

- (GLuint *) pixels;
- (CVPixelBufferRef) cvPixBuf;
- (CVOpenGLTextureRef) cvTexRef;
- (NSBitmapImageRep *) bitmapRep;
- (void *) externalBacking;
#ifndef __LP64__
- (GWorldPtr) gWorld;
#endif

@property (assign,readwrite) VVBufferBackID backingID;
- (void) setCpuBackingPtr:(void *)n;
- (void *) cpuBackingPtr;

- (void) setBackingReleaseCallback:(VVBufferBackingReleaseCallback)n;
- (VVBufferBackingReleaseCallback) backingReleaseCallback;

- (void) setBackingReleaseCallbackContext:(void *)n;
- (void *) backingReleaseCallbackContext;
- (IOSurfaceRef) localSurfaceRef;
- (void) setLocalSurfaceRef:(IOSurfaceRef)n;
- (IOSurfaceRef) remoteSurfaceRef;
- (void) setRemoteSurfaceRef:(IOSurfaceRef)n;

@property (retain,readwrite) id copySourceBuffer;
@property (assign,readwrite) int idleCount;
- (void) _incrementIdleCount;


@end




void VVBuffer_ReleasePixelsCallback(id b, void *c);
void VVBuffer_ReleaseCVGLT(id b, void *c);
void VVBuffer_ReleaseCVPixBuf(id b, void *c);
void VVBuffer_ReleaseBitmapRep(id b, void *c);
#ifndef __LP64__
void VVBuffer_ReleaseGWorld(id b, void *c);
#endif