--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/video/quartz/SDL_QuartzYUV.m	Sun Jan 04 14:55:35 2004 +0000
@@ -0,0 +1,327 @@
+/*
+    SDL - Simple DirectMedia Layer
+    Copyright (C) 1997-2003  Sam Lantinga
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Sam Lantinga
+    slouken@libsdl.org
+*/
+
+#include "SDL_QuartzVideo.h"
+#include "SDL_QuartzWindow.h"
+#include "SDL_yuvfuncs.h"
+
+
+#define yuv_idh (this->hidden->yuv_idh)
+#define yuv_matrix (this->hidden->yuv_matrix)
+#define yuv_codec (this->hidden->yuv_codec)
+#define yuv_seq (this->hidden->yuv_seq)
+#define yuv_pixmap (this->hidden->yuv_pixmap)
+#define yuv_data (this->hidden->yuv_data)
+#define yuv_width (this->hidden->yuv_width)
+#define yuv_height (this->hidden->yuv_height)
+#define yuv_port (this->hidden->yuv_port)
+
+
+static int QZ_LockYUV (_THIS, SDL_Overlay *overlay) {
+
+    return 0;
+}
+
+static void QZ_UnlockYUV (_THIS, SDL_Overlay *overlay) {
+
+    ;
+}
+
+static int QZ_DisplayYUV (_THIS, SDL_Overlay *overlay, SDL_Rect *dstrect) {
+
+    OSErr err;
+    CodecFlags flags;
+
+    if (dstrect->x != 0 || dstrect->y != 0) {
+
+        SDL_SetError ("Need a dstrect at (0,0)");
+        return -1;
+    }
+
+    if (dstrect->w != yuv_width || dstrect->h != yuv_height) {
+
+        Fixed scale_x, scale_y;
+
+        scale_x = FixDiv ( Long2Fix (dstrect->w), Long2Fix (overlay->w) );
+        scale_y = FixDiv ( Long2Fix (dstrect->h), Long2Fix (overlay->h) );
+
+        SetIdentityMatrix (yuv_matrix);
+        ScaleMatrix (yuv_matrix, scale_x, scale_y, Long2Fix (0), Long2Fix (0));
+
+        SetDSequenceMatrix (yuv_seq, yuv_matrix);
+
+        yuv_width = dstrect->w;
+        yuv_height = dstrect->h;
+    }
+
+    if( ( err = DecompressSequenceFrameS(
+                                         yuv_seq,
+                                         (void*)yuv_pixmap,
+                                         sizeof (PlanarPixmapInfoYUV420),
+                                         codecFlagUseImageBuffer, &flags, nil ) != noErr ) )
+    {
+        SDL_SetError ("DecompressSequenceFrameS failed");
+    }
+
+    return err == noErr;
+}
+
+static void QZ_FreeHWYUV (_THIS, SDL_Overlay *overlay) {
+
+    CDSequenceEnd (yuv_seq);
+    ExitMovies();
+
+    free (overlay->hwfuncs);
+    free (overlay->pitches);
+    free (overlay->pixels);
+
+    if (SDL_VideoSurface->flags & SDL_FULLSCREEN) {
+        [ qz_window close ];
+        qz_window = nil;
+    }
+
+    free (yuv_matrix);
+    DisposeHandle ((Handle)yuv_idh);
+}
+
+/* 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 */
+#define ALIGN(x) ((16 - (x & 15)) & 15)
+
+SDL_Overlay* QZ_CreateYUVOverlay (_THIS, int width, int height,
+                                         Uint32 format, SDL_Surface *display) {
+
+    Uint32 codec;
+    OSStatus err;
+    CGrafPtr port;
+    SDL_Overlay *overlay;
+
+    if (format == SDL_YV12_OVERLAY ||
+        format == SDL_IYUV_OVERLAY) {
+
+        codec = kYUV420CodecType;
+    }
+    else {
+        SDL_SetError ("Hardware: unsupported video format");
+        return NULL;
+    }
+
+    yuv_idh = (ImageDescriptionHandle) NewHandleClear (sizeof(ImageDescription));
+    if (yuv_idh == NULL) {
+        SDL_OutOfMemory();
+        return NULL;
+    }
+
+    yuv_matrix = (MatrixRecordPtr) malloc (sizeof(MatrixRecord));
+    if (yuv_matrix == NULL) {
+        SDL_OutOfMemory();
+        return NULL;
+    }
+
+    if ( EnterMovies() != noErr ) {
+        SDL_SetError ("Could not init QuickTime for YUV playback");
+        return NULL;
+    }
+
+    err = FindCodec (codec, bestSpeedCodec, nil, &yuv_codec);
+    if (err != noErr) {
+        SDL_SetError ("Could not find QuickTime codec for format");
+        return NULL;
+    }
+
+    if (SDL_VideoSurface->flags & SDL_FULLSCREEN) {
+
+        /*
+          Acceleration requires a window to be present.
+          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
+                            backing:NSBackingStoreBuffered defer:NO ];
+
+        if (qz_window == nil) {
+            SDL_SetError ("Could not create the Cocoa window");
+            return NULL;
+        }
+
+        [ qz_window setContentView:[ [ NSQuickDrawView alloc ] init ] ];
+        [ qz_window setReleasedWhenClosed:YES ];
+        [ qz_window center ];
+        [ qz_window setAcceptsMouseMovedEvents:YES ];
+        [ 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;
+                SetRect (&r, 0, 0, SDL_VideoSurface->w, SDL_VideoSurface->h);
+                PaintRect (&r);
+                QDFlushPortBuffer (port, nil);
+            }
+        */
+    }
+    else {
+        port = [ window_view qdPort ];
+        SetPort (port);
+    }
+    
+    SetIdentityMatrix (yuv_matrix);
+    
+    HLock ((Handle)yuv_idh);
+    
+    (**yuv_idh).idSize = sizeof(ImageDescription);
+    (**yuv_idh).cType  = codec;
+    (**yuv_idh).version = 1;
+    (**yuv_idh).revisionLevel = 0;
+    (**yuv_idh).width = width;
+    (**yuv_idh).height = height;
+    (**yuv_idh).hRes = Long2Fix(72);
+    (**yuv_idh).vRes = Long2Fix(72);
+    (**yuv_idh).spatialQuality = codecLosslessQuality;
+    (**yuv_idh).frameCount = 1;
+    (**yuv_idh).clutID = -1;
+    (**yuv_idh).dataSize = 0;
+    (**yuv_idh).depth = 24;
+    
+    HUnlock ((Handle)yuv_idh);
+    
+    err = DecompressSequenceBeginS (
+                                    &yuv_seq,
+                                    yuv_idh,
+                                    NULL,
+                                    0,
+                                    port,
+                                    NULL,
+                                    NULL,
+                                    yuv_matrix,
+                                    0,
+                                    NULL,
+                                    codecFlagUseImageBuffer,
+                                    codecLosslessQuality,
+                                    yuv_codec);
+    
+    if (err != noErr) {
+        SDL_SetError ("Error trying to start YUV codec.");
+        return NULL;
+    }
+    
+    overlay = (SDL_Overlay*) malloc (sizeof(*overlay));
+    if (overlay == NULL) {
+        SDL_OutOfMemory();
+        return NULL;
+    }
+    
+    overlay->format      = format;
+    overlay->w           = width;
+    overlay->h           = height;
+    overlay->planes      = 3;
+    overlay->hw_overlay  = 1;
+    {
+        int      offset;
+        Uint8  **pixels;
+        Uint16  *pitches;
+        int      plane2, plane3;
+
+        if (format == SDL_IYUV_OVERLAY) {
+
+            plane2 = 1; /* Native codec format */
+            plane3 = 2;
+        }
+        else if (format == SDL_YV12_OVERLAY) {
+
+            /* switch the U and V planes */
+            plane2 = 2; /* U plane maps to plane 3 */
+            plane3 = 1; /* V plane maps to plane 2 */
+        }
+        else {
+            SDL_SetError("Unsupported YUV format");
+            return NULL;
+        }
+
+        pixels = (Uint8**) malloc (sizeof(*pixels) * 3);
+        pitches = (Uint16*) malloc (sizeof(*pitches) * 3);
+        if (pixels == NULL || pitches == NULL) {
+            SDL_OutOfMemory();
+            return NULL;
+        }
+
+        yuv_pixmap = (PlanarPixmapInfoYUV420*)
+            malloc (sizeof(PlanarPixmapInfoYUV420) +
+                    (width * height * 2));
+        if (yuv_pixmap == NULL) {
+            SDL_OutOfMemory ();
+            return NULL;
+        }
+
+        /* CHECK_ALIGN(yuv_pixmap); */
+        offset  = sizeof(PlanarPixmapInfoYUV420);
+        /* offset += ALIGN(offset); */
+        /* CHECK_ALIGN(offset); */
+
+        pixels[0] = (Uint8*)yuv_pixmap + offset;
+        /* CHECK_ALIGN(pixels[0]); */
+
+        pitches[0] = width;
+        yuv_pixmap->componentInfoY.offset = offset;
+        yuv_pixmap->componentInfoY.rowBytes = width;
+
+        offset += width * height;
+        pixels[plane2] = (Uint8*)yuv_pixmap + offset;
+        pitches[plane2] = width / 2;
+        yuv_pixmap->componentInfoCb.offset = offset;
+        yuv_pixmap->componentInfoCb.rowBytes = width / 2;
+
+        offset += (width * height / 4);
+        pixels[plane3] = (Uint8*)yuv_pixmap + offset;
+        pitches[plane3] = width / 2;
+        yuv_pixmap->componentInfoCr.offset = offset;
+        yuv_pixmap->componentInfoCr.rowBytes = width / 2;
+
+        overlay->pixels = pixels;
+        overlay->pitches = pitches;
+    }
+
+    overlay->hwfuncs = malloc (sizeof(*overlay->hwfuncs));
+    if (overlay->hwfuncs == NULL) {
+        SDL_OutOfMemory();
+        return NULL;
+    }
+    
+    overlay->hwfuncs->Lock    = QZ_LockYUV;
+    overlay->hwfuncs->Unlock  = QZ_UnlockYUV;
+    overlay->hwfuncs->Display = QZ_DisplayYUV;
+    overlay->hwfuncs->FreeHW  = QZ_FreeHWYUV;
+
+    yuv_width = overlay->w;
+    yuv_height = overlay->h;
+    
+    return overlay;
+}