sdl-ios-xcode: src/video/quartz/SDL_QuartzVideo.m comparison

comparison src/video/quartz/SDL_QuartzVideo.m @ 501:74262d2647ca

Lots of cleanups by Darrell, added the ability to resize Cocoa windows.

author	Sam Lantinga <slouken@libsdl.org>
date	Sat, 05 Oct 2002 05:07:57 +0000
parents	c335456c421d
children	2536446a92de

comparison

equal deleted inserted replaced

-:c335456c421d
+:74262d2647ca
 Sam Lantinga
 slouken@libsdl.org
 */
 #include "SDL_QuartzVideo.h"
-/* Some variables to share among files, put in device structure eventually */
-static SDL_GrabMode currentGrabMode = SDL_GRAB_OFF;
-static BOOL   inForeground = YES;
-static char QZ_Error[255]; /* Global error buffer to temporarily store more informative error messages */
 /* Include files into one compile unit...break apart eventually */
 #include "SDL_QuartzWM.m"
 #include "SDL_QuartzEvents.m"
 #include "SDL_QuartzWindow.m"
 CFNumberGetValue (CFDictionaryGetValue (save_mode, kCGDisplayHeight),
 kCFNumberSInt32Type, &device_height);
 video_format->BitsPerPixel = device_bpp;
+/* Set misc globals */
+current_grab_mode = SDL_GRAB_OFF;
+in_foreground     = YES;
 return 0;
 }
 static SDL_Rect** QZ_ListModes (_THIS, SDL_PixelFormat *format, Uint32 flags) {
 CFIndex num_modes;
 CFIndex i;
-static SDL_Rect **list = NULL;
 int list_size = 0;
 /* Any windowed mode is acceptable */
 if ( (flags & SDL_FULLSCREEN) == 0 )
 return (SDL_Rect**)-1;
 /* Free memory from previous call, if any */
-if ( list != NULL ) {
+if ( client_mode_list != NULL ) {
 int i;
-for (i = 0; list[i] != NULL; i++)
+for (i = 0; client_mode_list[i] != NULL; i++)
-free (list[i]);
+free (client_mode_list[i]);
-free (list);
+free (client_mode_list);
-list = NULL;
+client_mode_list = NULL;
 }
 num_modes = CFArrayGetCount (mode_list);
 /* Build list of modes with the requested bpp */
 /* Check if mode is already in the list */
 {
 int i;
 hasMode = SDL_FALSE;
 for (i = 0; i < list_size; i++) {
-if (list[i]->w == width && list[i]->h == height) {
+if (client_mode_list[i]->w == width &&
+client_mode_list[i]->h == height) {
 hasMode = SDL_TRUE;
 break;
 }
 }
 }
 SDL_Rect *rect;
 list_size++;
-if (list == NULL)
+if (client_mode_list == NULL)
-list = (SDL_Rect**) malloc (sizeof(*list) * (list_size+1) );
+client_mode_list = (SDL_Rect**)
+malloc (sizeof(*client_mode_list) * (list_size+1) );
 else
-list = (SDL_Rect**) realloc (list, sizeof(*list) * (list_size+1));
+client_mode_list = (SDL_Rect**)
+realloc (client_mode_list, sizeof(*client_mode_list) * (list_size+1));
-rect = (SDL_Rect*) malloc (sizeof(**list));
+rect = (SDL_Rect*) malloc (sizeof(**client_mode_list));
-if (list == NULL || rect == NULL) {
+if (client_mode_list == NULL || rect == NULL) {
 SDL_OutOfMemory ();
 return NULL;
 }
 rect->w = width;
 rect->h = height;
-list[list_size-1] = rect;
+client_mode_list[list_size-1] = rect;
-list[list_size]   = NULL;
+client_mode_list[list_size]   = NULL;
 }
 }
 }
 /* Sort list largest to smallest (by area) */
 int i, j;
 for (i = 0; i < list_size; i++) {
 for (j = 0; j < list_size-1; j++) {
 int area1, area2;
-area1 = list[j]->w * list[j]->h;
+area1 = client_mode_list[j]->w * client_mode_list[j]->h;
-area2 = list[j+1]->w * list[j+1]->h;
+area2 = client_mode_list[j+1]->w * client_mode_list[j+1]->h;
 if (area1 < area2) {
-SDL_Rect *tmp = list[j];
+SDL_Rect *tmp = client_mode_list[j];
-list[j] = list[j+1];
+client_mode_list[j] = client_mode_list[j+1];
-list[j+1] = tmp;
+client_mode_list[j+1] = tmp;
 }
 }
 }
 }
-return list;
+return client_mode_list;
 }
-/* Gamma functions to try to hide the flash from a rez switch */
+/*
-/* Fade the display from normal to black */
+Gamma functions to try to hide the flash from a rez switch
-/* Save gamma tables for fade back to normal */
+Fade the display from normal to black
+Save gamma tables for fade back to normal
+*/
 static UInt32 QZ_FadeGammaOut (_THIS, SDL_QuartzGammaTable *table) {
 CGGammaValue redTable[QZ_GAMMA_TABLE_SIZE],
 greenTable[QZ_GAMMA_TABLE_SIZE],
 blueTable[QZ_GAMMA_TABLE_SIZE];
 }
 return 0;
 }
-/* Fade the display from black to normal */
+/*
-/* Restore previously saved gamma values */
+Fade the display from black to normal
+Restore previously saved gamma values
+*/
 static UInt32 QZ_FadeGammaIn (_THIS, SDL_QuartzGammaTable *table) {
 CGGammaValue redTable[QZ_GAMMA_TABLE_SIZE],
 greenTable[QZ_GAMMA_TABLE_SIZE],
 blueTable[QZ_GAMMA_TABLE_SIZE];
 }
 static void QZ_UnsetVideoMode (_THIS) {
 /* Reset values that may change between switches */
-this->info.blit_fill = 0;
+this->info.blit_fill  = 0;
-this->FillHWRect     = NULL;
+this->FillHWRect      = NULL;
-this->UpdateRects    = NULL;
+this->UpdateRects     = NULL;
+this->LockHWSurface   = NULL;
+this->UnlockHWSurface = NULL;
 /* Release fullscreen resources */
 if ( mode_flags & SDL_FULLSCREEN ) {
 SDL_QuartzGammaTable gamma_table;
 int gamma_error;
 NSRect screen_rect;
 gamma_error = QZ_FadeGammaOut (this, &gamma_table);
-/* Release the OpenGL context */
+/*
-/* Do this first to avoid trash on the display before fade */
+Release the OpenGL context
-if ( mode_flags & SDL_OPENGL )
+Do this first to avoid trash on the display before fade
+*/
+if ( mode_flags & SDL_OPENGL ) {
 QZ_TearDownOpenGL (this);
+CGLSetFullScreen (NULL);
-if (mode_flags & SDL_OPENGL)
+}
-CGLSetFullScreen(NULL);
 /* Restore original screen resolution/bpp */
 CGDisplaySwitchToMode (display_id, save_mode);
 CGDisplayRelease (display_id);
 ShowMenuBar ();
 /*
-reset the main screen's rectangle, see comment
+Reset the main screen's rectangle
-in QZ_SetVideoFullscreen
+See comment in QZ_SetVideoFullscreen for why we do this
 */
 screen_rect = NSMakeRect(0,0,device_width,device_height);
 [ [ NSScreen mainScreen ] setFrame:screen_rect ];
 if (! gamma_error)
 QZ_FadeGammaIn (this, &gamma_table);
 }
 /* Release window mode resources */
 else {
-if ( (mode_flags & SDL_OPENGL) == 0 ) {
-UnlockPortBits ( [ window_view qdPort ] );
-[ window_view release  ];
-}
-[ qz_window setContentView:nil ];
-[ qz_window setDelegate:nil ];
 [ qz_window close ];
 [ qz_window release ];
 qz_window = nil;
+window_view = nil;
 /* Release the OpenGL context */
 if ( mode_flags & SDL_OPENGL )
 QZ_TearDownOpenGL (this);
 }
 /* Restore gamma settings */
 CGDisplayRestoreColorSyncSettings ();
-/* Set pixels to null (so other code doesn't try to free it) */
-if (this->screen != NULL)
-this->screen->pixels = NULL;
 /* Ensure the cursor will be visible and working when we quit */
 CGDisplayShowCursor (display_id);
 CGAssociateMouseAndMouseCursorPosition (1);
 int exact_match;
 int gamma_error;
 SDL_QuartzGammaTable gamma_table;
 NSRect screen_rect;
+/* Destroy any previous mode */
+if (video_set == SDL_TRUE)
+QZ_UnsetVideoMode (this);
 /* See if requested mode exists */
 mode = CGDisplayBestModeForParameters (display_id, bpp, width,
 height, &exact_match);
 /* Require an exact match to the requested mode */
 if ( ! exact_match ) {
-sprintf (QZ_Error, "Failed to find display resolution: %dx%dx%d", width, height, bpp);
+SDL_SetError ("Failed to find display resolution: %dx%dx%d", width, height, bpp);
-SDL_SetError (QZ_Error);
 goto ERR_NO_MATCH;
 }
 /* Fade display to zero gamma */
 gamma_error = QZ_FadeGammaOut (this, &gamma_table);
 /* Put up the blanking window (a window above all other windows) */
 if ( CGDisplayNoErr != CGDisplayCapture (display_id) ) {
 SDL_SetError ("Failed capturing display");
 goto ERR_NO_CAPTURE;
 }
 /* Do the physical switch */
 if ( CGDisplayNoErr != CGDisplaySwitchToMode (display_id, mode) ) {
 SDL_SetError ("Failed switching display resolution");
 goto ERR_NO_SWITCH;
 current->flags = 0;
 current->w = width;
 current->h = height;
 current->flags |= SDL_FULLSCREEN;
 current->flags |= SDL_HWSURFACE;
+current->flags |= SDL_PREALLOC;
-this->UpdateRects = QZ_DirectUpdate;
+this->UpdateRects     = QZ_DirectUpdate;
+this->LockHWSurface   = QZ_LockHWSurface;
+this->UnlockHWSurface = QZ_UnlockHWSurface;
 /* Setup some mode-dependant info */
 if ( CGSDisplayCanHWFill (display_id) ) {
 this->info.blit_fill = 1;
 this->FillHWRect = QZ_FillHWRect;
 }
 ctx = [ gl_context cglContext ];
 err = CGLSetFullScreen (ctx);
 if (err) {
-sprintf (QZ_Error, "Error setting OpenGL fullscreen: %s", CGLErrorString(err));
+SDL_SetError ("Error setting OpenGL fullscreen: %s", CGLErrorString(err));
-SDL_SetError (QZ_Error);
 goto ERR_NO_GL;
 }
 [ gl_context makeCurrentContext];
 /* Fade the display to original gamma */
 if (! gamma_error )
 QZ_FadeGammaIn (this, &gamma_table);
 /*
 There is a bug in Cocoa where NSScreen doesn't synchronize
 with CGDirectDisplay, so the main screen's frame is wrong.
-As a result, coordinate translation produces wrong results.
+As a result, coordinate translation produces incorrect results.
 We can hack around this bug by setting the screen rect
 ourselves. This hack should be removed if/when the bug is fixed.
 */
 screen_rect = NSMakeRect(0,0,width,height);
 [ [ NSScreen mainScreen ] setFrame:screen_rect ];
 /* Save the flags to ensure correct tear-down */
 }
 static SDL_Surface* QZ_SetVideoWindowed (_THIS, SDL_Surface *current, int width,
 int height, int bpp, Uint32 flags) {
 unsigned int style;
-NSRect rect;
+NSRect contentRect;
-rect = NSMakeRect (0, 0, width, height);
-#if 1 // FIXME - the resize button doesn't show?  Also need resize events...
-flags &= ~SDL_RESIZABLE;
-#endif
-/* Set the window style based on input flags */
-if ( flags & SDL_NOFRAME ) {
-style = NSBorderlessWindowMask;
-} else {
-style = NSTitledWindowMask;
-style |= (NSMiniaturizableWindowMask | NSClosableWindowMask);
-if ( flags & SDL_RESIZABLE )
-style |= NSResizableWindowMask;
-}
-/* Manually create a window, avoids having a nib file resource */
-qz_window = [ [ SDL_QuartzWindow alloc ] initWithContentRect:rect
-styleMask:style backing:NSBackingStoreBuffered defer:NO ];
-if (qz_window == nil) {
-SDL_SetError ("Could not create the Cocoa window");
-return NULL;
-}
 current->flags = 0;
 current->w = width;
 current->h = height;
-[ qz_window setReleasedWhenClosed:YES ];
+contentRect = NSMakeRect (0, 0, width, height);
-QZ_SetCaption(this, this->wm_title, this->wm_icon);
-[ qz_window setAcceptsMouseMovedEvents:YES ];
+/*
-[ qz_window setViewsNeedDisplay:NO ];
+Check if we should completely destroy the previous mode
-[ qz_window center ];
+- If it is fullscreen
-[ qz_window setDelegate:
+- If it has different noframe or resizable attribute
-[ [ [ SDL_QuartzWindowDelegate alloc ] init ] autorelease ] ];
+- If it is OpenGL (since gl attributes could be different)
+- If new mode is OpenGL, but previous mode wasn't
-/* For OpenGL, we set the content view to a NSOpenGLView */
+*/
+if (video_set == SDL_TRUE)
+if ( (mode_flags & SDL_FULLSCREEN) ||
+((mode_flags ^ flags) & (SDL_NOFRAME|SDL_RESIZABLE)) ||
+(mode_flags & SDL_OPENGL) ||
+(flags & SDL_OPENGL) )
+QZ_UnsetVideoMode (this);
+/* Check if we should recreate the window */
+if (qz_window == nil) {
+/* Set the window style based on input flags */
+if ( flags & SDL_NOFRAME ) {
+style = NSBorderlessWindowMask;
+current->flags |= SDL_NOFRAME;
+} else {
+style = NSTitledWindowMask;
+style |= (NSMiniaturizableWindowMask | NSClosableWindowMask);
+if ( flags & SDL_RESIZABLE ) {
+style |= NSResizableWindowMask;
+current->flags |= SDL_RESIZABLE;
+}
+}
+/* Manually create a window, avoids having a nib file resource */
+qz_window = [ [ SDL_QuartzWindow alloc ]
+initWithContentRect:contentRect
+styleMask:style
+backing:NSBackingStoreBuffered
+defer:NO ];
+if (qz_window == nil) {
+SDL_SetError ("Could not create the Cocoa window");
+return NULL;
+}
+[ qz_window setReleasedWhenClosed:YES ];
+QZ_SetCaption(this, this->wm_title, this->wm_icon);
+[ qz_window setAcceptsMouseMovedEvents:YES ];
+[ qz_window setViewsNeedDisplay:NO ];
+[ qz_window center ];
+[ qz_window setDelegate:
+[ [ [ SDL_QuartzWindowDelegate alloc ] init ] autorelease ] ];
+}
+/* We already have a window, just change its size */
+else {
+[ qz_window setContentSize:contentRect.size ];
+current->flags |= (SDL_NOFRAME|SDL_RESIZABLE) & mode_flags;
+}
+/* For OpenGL, we bind the context to a subview */
 if ( flags & SDL_OPENGL ) {
 if ( ! QZ_SetupOpenGL (this, bpp, flags) ) {
 return NULL;
 }
-[ gl_context setView: [ qz_window contentView ] ];
+window_view = [ [ NSView alloc ] initWithFrame:contentRect ];
+[ window_view setAutoresizingMask: NSViewMinYMargin ];
+[ [ qz_window contentView ] addSubview:window_view ];
+[ gl_context setView: window_view ];
+[ window_view release ];
 [ gl_context makeCurrentContext];
 [ qz_window makeKeyAndOrderFront:nil ];
 current->flags |= SDL_OPENGL;
 }
-/* For 2D, we set the content view to a NSQuickDrawView */
+/* For 2D, we set the subview to an NSQuickDrawView */
 else {
-window_view = [ [ SDL_QuartzWindowView alloc ] init ];
+/* Only recreate the view if it doesn't already exist */
-[ qz_window setContentView:window_view ];
+if (window_view == nil) {
-[ qz_window makeKeyAndOrderFront:nil ];
+window_view = [ [ SDL_QuartzWindowView alloc ] initWithFrame:contentRect ];
+[ window_view setAutoresizingMask: NSViewMinYMargin ];
+[ [ qz_window contentView ] addSubview:window_view ];
+[ window_view release ];
+[ qz_window makeKeyAndOrderFront:nil ];
+}
 LockPortBits ( [ window_view qdPort ] );
 current->pixels = GetPixBaseAddr ( GetPortPixMap ( [ window_view qdPort ] ) );
 current->pitch  = GetPixRowBytes ( GetPortPixMap ( [ window_view qdPort ] ) );
 UnlockPortBits ( [ window_view qdPort ] );
 current->flags |= SDL_SWSURFACE;
 current->flags |= SDL_PREALLOC;
 current->flags |= SDL_ASYNCBLIT;
-if ( flags & SDL_NOFRAME )
+/* Offset below the title bar to fill the full content region */
-current->flags |= SDL_NOFRAME;
+current->pixels += ((int)([ qz_window frame ].size.height) - height) * current->pitch;
-if ( flags & SDL_RESIZABLE )
-current->flags |= SDL_RESIZABLE;
-/* Offset 22 pixels down to fill the full content region */
-if ( ! (current->flags & SDL_NOFRAME) ) {
-current->pixels += 22 * current->pitch;
-}
 this->UpdateRects     = QZ_UpdateRects;
 this->LockHWSurface   = QZ_LockWindow;
 this->UnlockHWSurface = QZ_UnlockWindow;
 }
 return current;
 }
 static SDL_Surface* QZ_SetVideoMode (_THIS, SDL_Surface *current, int width,
 int height, int bpp, Uint32 flags) {
-if (video_set == SDL_TRUE)
-QZ_UnsetVideoMode (this);
 current->flags = 0;
 /* Setup full screen video */
 if ( flags & SDL_FULLSCREEN ) {
 static void QZ_DirectUpdate (_THIS, int num_rects, SDL_Rect *rects) {
 #pragma unused(this,num_rects,rects)
 }
-/**
+/*
-*  The obscured code is based on work by Matt Slot fprefect@ambrosiasw.com,
+The obscured code is based on work by Matt Slot fprefect@ambrosiasw.com,
-*  who supplied sample code for Carbon.
+who supplied sample code for Carbon.
-**/
+*/
 static int QZ_IsWindowObscured (NSWindow *window) {
 //#define TEST_OBSCURED 1
 #if TEST_OBSCURED
-/*  In order to determine if a direct copy to the screen is possible,
+/*
+In order to determine if a direct copy to the screen is possible,
 we must figure out if there are any windows covering ours (including shadows).
 This can be done by querying the window server about the on screen
 windows for their screen rectangle and window level.
 The procedure used below is puts accuracy before speed; however, it aims to call
 the window server the fewest number of times possible to keep things reasonable.
 int     obscured = SDL_TRUE;
 if ( [ window isVisible ] ) {
-/*  walk the window list looking for windows over top of
+/*
-(or casting a shadow on) ours */
+walk the window list looking for windows over top of
+(or casting a shadow on) ours
-/* Get a connection to the window server */
+*/
-/* Should probably be moved out into SetVideoMode() or InitVideo() */
+/*
+Get a connection to the window server
+Should probably be moved out into SetVideoMode() or InitVideo()
+*/
 if (cgsConnection == (CGSConnectionID) -1) {
 cgsConnection = (CGSConnectionID) 0;
 cgsConnection = _CGSDefaultConnection ();
 }
 contentRect.size.height -= windowContentOffset;
 firstDockIcon = -1;
 dockIconCacheMiss = SDL_FALSE;
-/* The first window is always an empty window with level kCGSWindowLevelTop
+/*
-so start at index 1 */
+The first window is always an empty window with level kCGSWindowLevelTop
+so start at index 1
+*/
 for (i = 1; i < count; i++) {
 /* If we reach our window in the list, it cannot be obscured */
 if (windows[i] == windowNumber) {
 shadowTop = 4;
 shadowBottom = 12;
 }
 else if (winLevel == kCGSWindowLevelNormal) {
-/* These numbers are for foreground windows,
+/*
-they are too big (but will work) for background windows */
+These numbers are for foreground windows,
+they are too big (but will work) for background windows
+*/
 shadowSide = 20;
 shadowTop = 10;
 shadowBottom = 24;
 }
 else if (winLevel == kCGSWindowLevelDock) {
 shadowTop = 0;
 shadowBottom = 0;
 }
 else {
-/*   kCGSWindowLevelDockLabel,
+/*
-kCGSWindowLevelDock,
+kCGSWindowLevelDockLabel,
-kOther??? */
+kCGSWindowLevelDock,
+kOther???
+*/
 /* no shadow */
 shadowSide = 0;
 shadowTop = 0;
 shadowBottom = 0;
 #else
 return SDL_TRUE;
 #endif
 }
 /* Locking functions for the software window buffer */
 static int QZ_LockWindow (_THIS, SDL_Surface *surface) {
 return LockPortBits ( [ window_view qdPort ] );
 }
 static void QZ_UpdateRects (_THIS, int numRects, SDL_Rect *rects) {
 if (SDL_VideoSurface->flags & SDL_OPENGLBLIT) {
 QZ_GL_SwapBuffers (this);
 }
-else if ( [ qz_window isMiniaturized ] &&
+else if ( [ qz_window isMiniaturized ] ) {
-! (SDL_VideoSurface->flags & SDL_OPENGL)) {
+/* Do nothing if miniaturized */
-/**
+}
-* Set port alpha opaque so deminiaturize looks right
-* This isn't so nice, but there is no
-* initial deminatureize notification (before demini starts)
-**/
-QZ_SetPortAlphaOpaque ([ [ qz_window contentView ] qdPort],
-[ qz_window styleMask ] & NSBorderlessWindowMask);
-}
 else if ( ! QZ_IsWindowObscured (qz_window) ) {
 /* Use direct copy to flush contents to the display */
 CGrafPtr savePort;
 CGrafPtr dstPort, srcPort;
 }
 SetPort (savePort);
 }
 else {
 /* Use QDFlushPortBuffer() to flush content to display */
 int i;
 RgnHandle dirty = NewRgn ();
 RgnHandle temp  = NewRgn ();
 /* Build the region of dirty rectangles */
 for (i = 0; i < numRects; i++) {
 MacSetRectRgn (temp, rects[i].x, rects[i].y,
 rects[i].x + rects[i].w, rects[i].y + rects[i].h);
 MacUnionRgn (dirty, temp, dirty);
 }
+QZ_DrawResizeIcon (this, dirty);
 /* Flush the dirty region */
 QDFlushPortBuffer ( [ window_view qdPort ], dirty );
 DisposeRgn (dirty);
 DisposeRgn (temp);
 }
 DisposeHandle ((Handle)yuv_idh);
 }
 #include "SDL_yuvfuncs.h"
-/**
+/* check for 16 byte alignment, bail otherwise */
-* check for 16 byte alignment, bail otherwise
-**/
 #define CHECK_ALIGN(x) do { if ((Uint32)x & 15) { SDL_SetError("Alignment error"); return NULL; } } while(0)
-/**
+/* align a byte offset, return how much to add to make it a multiple of 16 */
-* align a byte offset, return how much to add to make it
-* a multiple of 16
-**/
 #define ALIGN(x) ((16 - (x & 15)) & 15)
 static SDL_Overlay* QZ_CreateYUVOverlay (_THIS, int width, int height,
 Uint32 format, SDL_Surface *display) {
 return NULL;
 }
 if (SDL_VideoSurface->flags & SDL_FULLSCREEN) {
-/**
+/*
-* Good acceleration requires a window to be present.
+Acceleration requires a window to be present.
-* A CGrafPtr that points to the screen isn't good enough
+A CGrafPtr that points to the screen isn't good enough
-**/
+*/
 NSRect content = NSMakeRect (0, 0, SDL_VideoSurface->w, SDL_VideoSurface->h);
 qz_window = [ [ SDL_QuartzWindow alloc ]
 initWithContentRect:content
 styleMask:NSBorderlessWindowMask
 [ qz_window setLevel:CGShieldingWindowLevel() ];
 [ qz_window makeKeyAndOrderFront:nil ];
 port = [ [ qz_window contentView ] qdPort ];
 SetPort (port);
-// BUG: would like to remove white flash when window kicks in
-//{
+/*
-//    Rect r;
+BUG: would like to remove white flash when window kicks in
-//    SetRect (&r, 0, 0, SDL_VideoSurface->w, SDL_VideoSurface->h);
+{
-//    PaintRect (&r);
+Rect r;
-//    QDFlushPortBuffer (port, nil);
+SetRect (&r, 0, 0, SDL_VideoSurface->w, SDL_VideoSurface->h);
-//}
+PaintRect (&r);
+QDFlushPortBuffer (port, nil);
+}
+*/
 }
 else {
-port = [ [ qz_window contentView ] qdPort ];
+port = [ window_view qdPort ];
 SetPort (port);
 }
 SetIdentityMatrix (yuv_matrix);
 if (yuv_pixmap == NULL) {
 SDL_OutOfMemory ();
 return NULL;
 }
-//CHECK_ALIGN(yuv_pixmap);
+/* CHECK_ALIGN(yuv_pixmap); */
 offset  = sizeof(PlanarPixmapInfoYUV420);
-//offset += ALIGN(offset);
+/* offset += ALIGN(offset); */
-//CHECK_ALIGN(offset);
+/* CHECK_ALIGN(offset); */
 pixels[0] = (Uint8*)yuv_pixmap + offset;
-//CHECK_ALIGN(pixels[0]);
+/* CHECK_ALIGN(pixels[0]); */
 pitches[0] = width;
 yuv_pixmap->componentInfoY.offset = offset;
 yuv_pixmap->componentInfoY.rowBytes = width;
 yuv_width = overlay->w;
 yuv_height = overlay->h;
 return overlay;
 }

Mercurial > sdl-ios-xcode

comparison src/video/quartz/SDL_QuartzVideo.m @ 501:74262d2647ca