Mercurial > sdl-ios-xcode
view src/video/SDL_yuv_sw.c @ 4157:baf615f9f2a0 SDL-1.2
Date: Thu, 16 Oct 2008 20:27:34 +0400
From: "Ilya Kasnacheev" <ilya.kasnacheev@gmail.com>
To: sdl@lists.libsdl.org
Subject: [SDL] SDL for Windows CE: a few GAPI patches
Hi *!
I've just ported a POWDER roguelike ( http://www.zincland.com/powder/ ) to
Windows CE (PDAs, Windows Mobile/Pocket PC). To do that, I had to get libsdl
working. Thanks for the awesome project files, it built without a hitch.
Nevertheless, I've found quite a few bugs in Windows CE (GAPI) SDL
implementation, which I've solved and now present as a serie of patches.
I'll try carefully annotate them. Please annotate them so I can work
toward accepting
them into the main source tree since without them SDL isn't really working on
Windows CE (I wonder why nobody fixed them before, btw: why isn't SDL popular as
a way to develop Windows CE games? Where are no ports?)
These changes can't be considered flawless, but they can be considered working
because I've yet to hear complains about things I fixed and POWDER build for
Windows CE is now considered stable.
Note: my comments start with !!, delete them before applying.
diff -bru SDL-1.2.13/src/video/gapi/SDL_gapivideo.c
SDL-1.2.13-new/src/video/gapi/SDL_gapivideo.c
--- SDL-1.2.13/src/video/gapi/SDL_gapivideo.c 2007-12-31
07:48:00.000000000 +0300
+++ SDL-1.2.13-new/src/video/gapi/SDL_gapivideo.c 2008-10-16
20:02:11.000000000 +0400
@@ -643,6 +643,7 @@
}
gapi->userOrientation = SDL_ORIENTATION_UP;
+ gapi->systemOrientation = SDL_ORIENTATION_UP;
video->flags = SDL_FULLSCREEN; /* Clear flags, GAPI supports
fullscreen only */
/* GAPI or VGA? */
@@ -661,18 +662,21 @@
}
/* detect user landscape mode */
- if( (width > height) && (GetSystemMetrics(SM_CXSCREEN) <
GetSystemMetrics(SM_CYSCREEN)))
+ if( (width > height) && (gapi->gxProperties.cxWidth <
gapi->gxProperties.cyHeight))
gapi->userOrientation = SDL_ORIENTATION_RIGHT;
+ if(GetSystemMetrics(SM_CYSCREEN) < GetSystemMetrics(SM_CXSCREEN))
+ gapi->systemOrientation = SDL_ORIENTATION_RIGHT;
+
/* shall we apply hires fix? for example when we do not use
hires resource */
gapi->hiresFix = 0;
- if( gapi->userOrientation == SDL_ORIENTATION_RIGHT )
+ if( gapi->systemOrientation == gapi->userOrientation )
{
- if( (width > GetSystemMetrics(SM_CYSCREEN)) || (height
> GetSystemMetrics(SM_CXSCREEN)))
+ if( (width > GetSystemMetrics(SM_CXSCREEN)) || (height
> GetSystemMetrics(SM_CYSCREEN)))
gapi->hiresFix = 1;
} else
- if( (width > GetSystemMetrics(SM_CXSCREEN)) || (height
> GetSystemMetrics(SM_CYSCREEN)))
- if( !((width == GetSystemMetrics(SM_CYSCREEN))
&& (height == GetSystemMetrics(SM_CXSCREEN)))) // user portrait,
device landscape
+ if( (width > GetSystemMetrics(SM_CYSCREEN)) || (height
> GetSystemMetrics(SM_CXSCREEN)))
+// if( !((width == gapi->gxProperties.cyHeight)
&& (height == gapi->gxProperties.cxWidth))) // user portrait, device
landscape
gapi->hiresFix = 1;
switch( gapi->userOrientation )
!! It used to query system metrics which return dimensions according to screen
!! orientation, which can really be portrait, left landscape or right landscape.
!! This is presumably incorrect because we couldn't care less about user mode
!! dimensions - all we want are the GAPI framebuffer dimensions, which
only match
!! user dimensions in one of possible orientations.
!! There's a fair dose of cargo cult programming involved in this fix, but it
!! used to work only in one orientation (portrait for PDAs, where frame-buffer
!! have same orientation as user screen), and now it works on all orientations.
@@ -742,21 +746,30 @@
WIN_FlushMessageQueue();
/* Open GAPI display */
- if( !gapi->useVga && this->hidden->useGXOpenDisplay )
+ if( !gapi->useVga && this->hidden->useGXOpenDisplay &&
!this->hidden->alreadyGXOpened )
+ {
+ this->hidden->alreadyGXOpened = 1;
if( !gapi->gxFunc.GXOpenDisplay(SDL_Window, GX_FULLSCREEN) )
{
SDL_SetError("Couldn't initialize GAPI");
return(NULL);
}
+ }
#if REPORT_VIDEO_INFO
printf("Video properties:\n");
printf("display bpp: %d\n", gapi->gxProperties.cBPP);
printf("display width: %d\n", gapi->gxProperties.cxWidth);
printf("display height: %d\n", gapi->gxProperties.cyHeight);
+ printf("system display width: %d\n", GetSystemMetrics(SM_CXSCREEN));
+ printf("system display height: %d\n", GetSystemMetrics(SM_CYSCREEN));
printf("x pitch: %d\n", gapi->gxProperties.cbxPitch);
printf("y pitch: %d\n", gapi->gxProperties.cbyPitch);
printf("gapi flags: 0x%x\n", gapi->gxProperties.ffFormat);
+ printf("user orientation: %d\n", gapi->userOrientation);
+ printf("system orientation: %d\n", gapi->userOrientation);
+ printf("gapi orientation: %d\n", gapi->gapiOrientation);
+
if( !gapi->useVga && this->hidden->useGXOpenDisplay && gapi->needUpdate)
{
!! Previous version used to call gapi->gxFunc.GXOpenDisplay each time the video
!! mode would be changed. You shouldn't, because this call has a
meaning "Lock the
!! GAPI framebuffer, designate it as busy", so the second call will fail (it is
!! already locked/busy).
!! Testing might not find that because most programs set up the video mode only
!! once, but POWDER does this once in a while, so it crashed when in
320x240 mode
!! (640x480 mode doesn't use that code, it worked fine).
diff -bru SDL-1.2.13/src/video/gapi/SDL_gapivideo.h
SDL-1.2.13-new/src/video/gapi/SDL_gapivideo.h
--- SDL-1.2.13/src/video/gapi/SDL_gapivideo.h 2007-12-31
07:48:00.000000000 +0300
+++ SDL-1.2.13-new/src/video/gapi/SDL_gapivideo.h 2008-10-16
20:02:11.000000000 +0400
@@ -132,12 +132,17 @@
#define NUM_MODELISTS 4 /* 8, 16, 24, and 32 bits-per-pixel */
int SDL_nummodes[NUM_MODELISTS];
SDL_Rect **SDL_modelist[NUM_MODELISTS];
+ // The orientation of the video mode user wants to get
+ // Probably restricted to UP and RIGHT
enum SDL_ScreenOrientation userOrientation;
int invert;
char hiresFix; // using hires mode without defining hires resource
// --------------
int useGXOpenDisplay; /* use GXOpenDispplay */
+ int alreadyGXOpened;
int w, h;
+ // The orientation of GAPI framebuffer.
+ // Never changes on the same device.
enum SDL_ScreenOrientation gapiOrientation;
void *buffer; // may be 8, 16, 24, 32 bpp
@@ -153,6 +158,10 @@
int startOffset; // in bytes
int useVga;
int suspended; // do not pu anything into video memory
+ // The orientation of the system, as defined by SM_CXSCREEN
and SM_CYSCREEN
+ // User can change it by using 'screen layout' in system options
+ // Restricted to UP or RIGHT
+ enum SDL_ScreenOrientation systemOrientation;
};
!! This is a flag variable, see the previous comment
!! And yet another orientation: now we have to keep three of them in mind.
diff -bru SDL-1.2.13/src/video/wincommon/SDL_sysevents.c
SDL-1.2.13-new/src/video/wincommon/SDL_sysevents.c
--- SDL-1.2.13/src/video/wincommon/SDL_sysevents.c 2007-12-31
07:48:02.000000000 +0300
+++ SDL-1.2.13-new/src/video/wincommon/SDL_sysevents.c 2008-10-16
20:02:12.000000000 +0400
@@ -160,10 +160,22 @@
#endif */
}
break;
+ // FIXME: Older version used just SDL_VideoSurface->(w, h)
+ // w and h are "clipped" while x and y are "raw", which caused
+ // x in former and y in latter case to be clipped in a
wrong direction,
+ // thus offsetting the coordinate on 2 x clip pixels
+ // (like, 128 for 640 -> 512 clipping).
+ // We will now try to extract and use raw values.
+ // The way to do that RIGHT is do
(orientation-dependent) clipping before
+ // doing this transform, but it's hardly possible.
+
+ // SEE SDL_mouse.c /ClipOffset to understand these calculations.
case SDL_ORIENTATION_RIGHT:
if (!SDL_VideoSurface)
break;
- rotatedX = SDL_VideoSurface->w - *y;
+ rotatedX = (2 *
((SDL_VideoSurface->offset%SDL_VideoSurface->pitch)/
+ SDL_VideoSurface->format->BytesPerPixel))
+ + SDL_VideoSurface->w - *y;
rotatedY = *x;
*x = rotatedX;
*y = rotatedY;
@@ -172,7 +184,8 @@
if (!SDL_VideoSurface)
break;
rotatedX = *y;
- rotatedY = SDL_VideoSurface->h - *x;
+ rotatedY = (2 *
(SDL_VideoSurface->offset/SDL_VideoSurface->pitch))
+ + SDL_VideoSurface->h - *x;
*x = rotatedX;
*y = rotatedY;
break;
!! That's the trickest part, hence the long comment.
!! GAPI would really support only 320x240 or 640x480 mode, if application
!! requested the different screen size (as POWDER did, wishing
256x192), then SDL
!! is going to grab the first mode that fits the requested, and pad the screen
!! with black bars (as they do with wide-screen films).
!! It would also get, say, 240x320 mode, and to turn it into 256x192 it would
!! need to rotate mouse clicks.
!! It worked, but one bug slipped through: it would receive mouse clicks
!! unpadded, then rotate them, and then pad the black bars. The
problem is: rotate
!! is done by GAPI driver while padding is done by SDL core. SDL core
doesn't know
!! anything about rotating, so it would pad one of dimensions incorrectly.
I understand that some of my claims (or code) might seem unbacked, but you can
always grab the POWDER binary, compile your own libsdl with one or more of
those fixes turned off, and see how weird it would misbehave. I can even supply
you with those custom builds of libsdl if you don't want to set up the build
environment for windows ce, you'll just need a PDA or a smartphone with it.
I plan to take care of SDL on Windows CE as long as I maintain the POWDER port.
POWDER is good for that because it:
Employs both padded (with centered image, black bars) and unpadded
(image occupies full screen) graphics; initializes video more than
once; uses both 320x240 and 640x480 video; uses both stylus and
buttons.
There's still a list of unresolved issues which I'm planning to fix:
1) Arrow buttons on PDA return weird scancodes compared to PC, this
caused the game to misbehave before I've fixed that. You can see it on
those diagrams:
http://wrar.name/upload/powder-htc.png
http://wrar.name/upload/powder-pda.png
2) SDL (or underlying windows) doesn't care to rotate arrow presses
when we're in a low-res GAPI mode, but it will rotate them in VGA mode
(because of different screen orientations, the same arrow buttons can
suddently mean different directions). Solution: we should stick to
GAPI user orientation (the orientation the program supposedly wants)
and rotate the keys on our own.
_______________________________________________
SDL mailing list
SDL@lists.libsdl.org
http://lists.libsdl.org/listinfo.cgi/sdl-libsdl.org
| author | Sam Lantinga <slouken@libsdl.org> |
|---|---|
| date | Fri, 07 Nov 2008 04:15:36 +0000 |
| parents | 940fddb81bea |
| children | 96ce26f24b01 |
line wrap: on
line source
/* SDL - Simple DirectMedia Layer Copyright (C) 1997-2006 Sam Lantinga This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 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 Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Sam Lantinga slouken@libsdl.org */ #include "SDL_config.h" /* This is the software implementation of the YUV video overlay support */ /* This code was derived from code carrying the following copyright notices: * Copyright (c) 1995 The Regents of the University of California. * All rights reserved. * * Permission to use, copy, modify, and distribute this software and its * documentation for any purpose, without fee, and without written agreement is * hereby granted, provided that the above copyright notice and the following * two paragraphs appear in all copies of this software. * * IN NO EVENT SHALL THE UNIVERSITY OF CALIFORNIA BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF * CALIFORNIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * THE UNIVERSITY OF CALIFORNIA SPECIFICALLY DISCLAIMS ANY WARRANTIES, * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY * AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS * ON AN "AS IS" BASIS, AND THE UNIVERSITY OF CALIFORNIA HAS NO OBLIGATION TO * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. * Copyright (c) 1995 Erik Corry * All rights reserved. * * Permission to use, copy, modify, and distribute this software and its * documentation for any purpose, without fee, and without written agreement is * hereby granted, provided that the above copyright notice and the following * two paragraphs appear in all copies of this software. * * IN NO EVENT SHALL ERIK CORRY BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, * SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF * THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF ERIK CORRY HAS BEEN ADVISED * OF THE POSSIBILITY OF SUCH DAMAGE. * * ERIK CORRY SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A * PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" * BASIS, AND ERIK CORRY HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, * UPDATES, ENHANCEMENTS, OR MODIFICATIONS. * Portions of this software Copyright (c) 1995 Brown University. * All rights reserved. * * Permission to use, copy, modify, and distribute this software and its * documentation for any purpose, without fee, and without written agreement * is hereby granted, provided that the above copyright notice and the * following two paragraphs appear in all copies of this software. * * IN NO EVENT SHALL BROWN UNIVERSITY BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF BROWN * UNIVERSITY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * BROWN UNIVERSITY SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A * PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" * BASIS, AND BROWN UNIVERSITY HAS NO OBLIGATION TO PROVIDE MAINTENANCE, * SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. */ #include "SDL_video.h" #include "SDL_cpuinfo.h" #include "SDL_stretch_c.h" #include "SDL_yuvfuncs.h" #include "SDL_yuv_sw_c.h" /* The functions used to manipulate software video overlays */ static struct private_yuvhwfuncs sw_yuvfuncs = { SDL_LockYUV_SW, SDL_UnlockYUV_SW, SDL_DisplayYUV_SW, SDL_FreeYUV_SW }; /* RGB conversion lookup tables */ struct private_yuvhwdata { SDL_Surface *stretch; SDL_Surface *display; Uint8 *pixels; int *colortab; Uint32 *rgb_2_pix; void (*Display1X)(int *colortab, Uint32 *rgb_2_pix, unsigned char *lum, unsigned char *cr, unsigned char *cb, unsigned char *out, int rows, int cols, int mod ); void (*Display2X)(int *colortab, Uint32 *rgb_2_pix, unsigned char *lum, unsigned char *cr, unsigned char *cb, unsigned char *out, int rows, int cols, int mod ); /* These are just so we don't have to allocate them separately */ Uint16 pitches[3]; Uint8 *planes[3]; }; /* The colorspace conversion functions */ #if (__GNUC__ > 2) && defined(__i386__) && __OPTIMIZE__ && SDL_ASSEMBLY_ROUTINES extern void Color565DitherYV12MMX1X( int *colortab, Uint32 *rgb_2_pix, unsigned char *lum, unsigned char *cr, unsigned char *cb, unsigned char *out, int rows, int cols, int mod ); extern void ColorRGBDitherYV12MMX1X( int *colortab, Uint32 *rgb_2_pix, unsigned char *lum, unsigned char *cr, unsigned char *cb, unsigned char *out, int rows, int cols, int mod ); #endif static void Color16DitherYV12Mod1X( int *colortab, Uint32 *rgb_2_pix, unsigned char *lum, unsigned char *cr, unsigned char *cb, unsigned char *out, int rows, int cols, int mod ) { unsigned short* row1; unsigned short* row2; unsigned char* lum2; int x, y; int cr_r; int crb_g; int cb_b; int cols_2 = cols / 2; row1 = (unsigned short*) out; row2 = row1 + cols + mod; lum2 = lum + cols; mod += cols + mod; y = rows / 2; while( y-- ) { x = cols_2; while( x-- ) { register int L; cr_r = 0*768+256 + colortab[ *cr + 0*256 ]; crb_g = 1*768+256 + colortab[ *cr + 1*256 ] + colortab[ *cb + 2*256 ]; cb_b = 2*768+256 + colortab[ *cb + 3*256 ]; ++cr; ++cb; L = *lum++; *row1++ = (unsigned short)(rgb_2_pix[ L + cr_r ] | rgb_2_pix[ L + crb_g ] | rgb_2_pix[ L + cb_b ]); L = *lum++; *row1++ = (unsigned short)(rgb_2_pix[ L + cr_r ] | rgb_2_pix[ L + crb_g ] | rgb_2_pix[ L + cb_b ]); /* Now, do second row. */ L = *lum2++; *row2++ = (unsigned short)(rgb_2_pix[ L + cr_r ] | rgb_2_pix[ L + crb_g ] | rgb_2_pix[ L + cb_b ]); L = *lum2++; *row2++ = (unsigned short)(rgb_2_pix[ L + cr_r ] | rgb_2_pix[ L + crb_g ] | rgb_2_pix[ L + cb_b ]); } /* * These values are at the start of the next line, (due * to the ++'s above),but they need to be at the start * of the line after that. */ lum += cols; lum2 += cols; row1 += mod; row2 += mod; } } static void Color24DitherYV12Mod1X( int *colortab, Uint32 *rgb_2_pix, unsigned char *lum, unsigned char *cr, unsigned char *cb, unsigned char *out, int rows, int cols, int mod ) { unsigned int value; unsigned char* row1; unsigned char* row2; unsigned char* lum2; int x, y; int cr_r; int crb_g; int cb_b; int cols_2 = cols / 2; row1 = out; row2 = row1 + cols*3 + mod*3; lum2 = lum + cols; mod += cols + mod; mod *= 3; y = rows / 2; while( y-- ) { x = cols_2; while( x-- ) { register int L; cr_r = 0*768+256 + colortab[ *cr + 0*256 ]; crb_g = 1*768+256 + colortab[ *cr + 1*256 ] + colortab[ *cb + 2*256 ]; cb_b = 2*768+256 + colortab[ *cb + 3*256 ]; ++cr; ++cb; L = *lum++; value = (rgb_2_pix[ L + cr_r ] | rgb_2_pix[ L + crb_g ] | rgb_2_pix[ L + cb_b ]); *row1++ = (value ) & 0xFF; *row1++ = (value >> 8) & 0xFF; *row1++ = (value >> 16) & 0xFF; L = *lum++; value = (rgb_2_pix[ L + cr_r ] | rgb_2_pix[ L + crb_g ] | rgb_2_pix[ L + cb_b ]); *row1++ = (value ) & 0xFF; *row1++ = (value >> 8) & 0xFF; *row1++ = (value >> 16) & 0xFF; /* Now, do second row. */ L = *lum2++; value = (rgb_2_pix[ L + cr_r ] | rgb_2_pix[ L + crb_g ] | rgb_2_pix[ L + cb_b ]); *row2++ = (value ) & 0xFF; *row2++ = (value >> 8) & 0xFF; *row2++ = (value >> 16) & 0xFF; L = *lum2++; value = (rgb_2_pix[ L + cr_r ] | rgb_2_pix[ L + crb_g ] | rgb_2_pix[ L + cb_b ]); *row2++ = (value ) & 0xFF; *row2++ = (value >> 8) & 0xFF; *row2++ = (value >> 16) & 0xFF; } /* * These values are at the start of the next line, (due * to the ++'s above),but they need to be at the start * of the line after that. */ lum += cols; lum2 += cols; row1 += mod; row2 += mod; } } static void Color32DitherYV12Mod1X( int *colortab, Uint32 *rgb_2_pix, unsigned char *lum, unsigned char *cr, unsigned char *cb, unsigned char *out, int rows, int cols, int mod ) { unsigned int* row1; unsigned int* row2; unsigned char* lum2; int x, y; int cr_r; int crb_g; int cb_b; int cols_2 = cols / 2; row1 = (unsigned int*) out; row2 = row1 + cols + mod; lum2 = lum + cols; mod += cols + mod; y = rows / 2; while( y-- ) { x = cols_2; while( x-- ) { register int L; cr_r = 0*768+256 + colortab[ *cr + 0*256 ]; crb_g = 1*768+256 + colortab[ *cr + 1*256 ] + colortab[ *cb + 2*256 ]; cb_b = 2*768+256 + colortab[ *cb + 3*256 ]; ++cr; ++cb; L = *lum++; *row1++ = (rgb_2_pix[ L + cr_r ] | rgb_2_pix[ L + crb_g ] | rgb_2_pix[ L + cb_b ]); L = *lum++; *row1++ = (rgb_2_pix[ L + cr_r ] | rgb_2_pix[ L + crb_g ] | rgb_2_pix[ L + cb_b ]); /* Now, do second row. */ L = *lum2++; *row2++ = (rgb_2_pix[ L + cr_r ] | rgb_2_pix[ L + crb_g ] | rgb_2_pix[ L + cb_b ]); L = *lum2++; *row2++ = (rgb_2_pix[ L + cr_r ] | rgb_2_pix[ L + crb_g ] | rgb_2_pix[ L + cb_b ]); } /* * These values are at the start of the next line, (due * to the ++'s above),but they need to be at the start * of the line after that. */ lum += cols; lum2 += cols; row1 += mod; row2 += mod; } } /* * In this function I make use of a nasty trick. The tables have the lower * 16 bits replicated in the upper 16. This means I can write ints and get * the horisontal doubling for free (almost). */ static void Color16DitherYV12Mod2X( int *colortab, Uint32 *rgb_2_pix, unsigned char *lum, unsigned char *cr, unsigned char *cb, unsigned char *out, int rows, int cols, int mod ) { unsigned int* row1 = (unsigned int*) out; const int next_row = cols+(mod/2); unsigned int* row2 = row1 + 2*next_row; unsigned char* lum2; int x, y; int cr_r; int crb_g; int cb_b; int cols_2 = cols / 2; lum2 = lum + cols; mod = (next_row * 3) + (mod/2); y = rows / 2; while( y-- ) { x = cols_2; while( x-- ) { register int L; cr_r = 0*768+256 + colortab[ *cr + 0*256 ]; crb_g = 1*768+256 + colortab[ *cr + 1*256 ] + colortab[ *cb + 2*256 ]; cb_b = 2*768+256 + colortab[ *cb + 3*256 ]; ++cr; ++cb; L = *lum++; row1[0] = row1[next_row] = (rgb_2_pix[ L + cr_r ] | rgb_2_pix[ L + crb_g ] | rgb_2_pix[ L + cb_b ]); row1++; L = *lum++; row1[0] = row1[next_row] = (rgb_2_pix[ L + cr_r ] | rgb_2_pix[ L + crb_g ] | rgb_2_pix[ L + cb_b ]); row1++; /* Now, do second row. */ L = *lum2++; row2[0] = row2[next_row] = (rgb_2_pix[ L + cr_r ] | rgb_2_pix[ L + crb_g ] | rgb_2_pix[ L + cb_b ]); row2++; L = *lum2++; row2[0] = row2[next_row] = (rgb_2_pix[ L + cr_r ] | rgb_2_pix[ L + crb_g ] | rgb_2_pix[ L + cb_b ]); row2++; } /* * These values are at the start of the next line, (due * to the ++'s above),but they need to be at the start * of the line after that. */ lum += cols; lum2 += cols; row1 += mod; row2 += mod; } } static void Color24DitherYV12Mod2X( int *colortab, Uint32 *rgb_2_pix, unsigned char *lum, unsigned char *cr, unsigned char *cb, unsigned char *out, int rows, int cols, int mod ) { unsigned int value; unsigned char* row1 = out; const int next_row = (cols*2 + mod) * 3; unsigned char* row2 = row1 + 2*next_row; unsigned char* lum2; int x, y; int cr_r; int crb_g; int cb_b; int cols_2 = cols / 2; lum2 = lum + cols; mod = next_row*3 + mod*3; y = rows / 2; while( y-- ) { x = cols_2; while( x-- ) { register int L; cr_r = 0*768+256 + colortab[ *cr + 0*256 ]; crb_g = 1*768+256 + colortab[ *cr + 1*256 ] + colortab[ *cb + 2*256 ]; cb_b = 2*768+256 + colortab[ *cb + 3*256 ]; ++cr; ++cb; L = *lum++; value = (rgb_2_pix[ L + cr_r ] | rgb_2_pix[ L + crb_g ] | rgb_2_pix[ L + cb_b ]); row1[0+0] = row1[3+0] = row1[next_row+0] = row1[next_row+3+0] = (value ) & 0xFF; row1[0+1] = row1[3+1] = row1[next_row+1] = row1[next_row+3+1] = (value >> 8) & 0xFF; row1[0+2] = row1[3+2] = row1[next_row+2] = row1[next_row+3+2] = (value >> 16) & 0xFF; row1 += 2*3; L = *lum++; value = (rgb_2_pix[ L + cr_r ] | rgb_2_pix[ L + crb_g ] | rgb_2_pix[ L + cb_b ]); row1[0+0] = row1[3+0] = row1[next_row+0] = row1[next_row+3+0] = (value ) & 0xFF; row1[0+1] = row1[3+1] = row1[next_row+1] = row1[next_row+3+1] = (value >> 8) & 0xFF; row1[0+2] = row1[3+2] = row1[next_row+2] = row1[next_row+3+2] = (value >> 16) & 0xFF; row1 += 2*3; /* Now, do second row. */ L = *lum2++; value = (rgb_2_pix[ L + cr_r ] | rgb_2_pix[ L + crb_g ] | rgb_2_pix[ L + cb_b ]); row2[0+0] = row2[3+0] = row2[next_row+0] = row2[next_row+3+0] = (value ) & 0xFF; row2[0+1] = row2[3+1] = row2[next_row+1] = row2[next_row+3+1] = (value >> 8) & 0xFF; row2[0+2] = row2[3+2] = row2[next_row+2] = row2[next_row+3+2] = (value >> 16) & 0xFF; row2 += 2*3; L = *lum2++; value = (rgb_2_pix[ L + cr_r ] | rgb_2_pix[ L + crb_g ] | rgb_2_pix[ L + cb_b ]); row2[0+0] = row2[3+0] = row2[next_row+0] = row2[next_row+3+0] = (value ) & 0xFF; row2[0+1] = row2[3+1] = row2[next_row+1] = row2[next_row+3+1] = (value >> 8) & 0xFF; row2[0+2] = row2[3+2] = row2[next_row+2] = row2[next_row+3+2] = (value >> 16) & 0xFF; row2 += 2*3; } /* * These values are at the start of the next line, (due * to the ++'s above),but they need to be at the start * of the line after that. */ lum += cols; lum2 += cols; row1 += mod; row2 += mod; } } static void Color32DitherYV12Mod2X( int *colortab, Uint32 *rgb_2_pix, unsigned char *lum, unsigned char *cr, unsigned char *cb, unsigned char *out, int rows, int cols, int mod ) { unsigned int* row1 = (unsigned int*) out; const int next_row = cols*2+mod; unsigned int* row2 = row1 + 2*next_row; unsigned char* lum2; int x, y; int cr_r; int crb_g; int cb_b; int cols_2 = cols / 2; lum2 = lum + cols; mod = (next_row * 3) + mod; y = rows / 2; while( y-- ) { x = cols_2; while( x-- ) { register int L; cr_r = 0*768+256 + colortab[ *cr + 0*256 ]; crb_g = 1*768+256 + colortab[ *cr + 1*256 ] + colortab[ *cb + 2*256 ]; cb_b = 2*768+256 + colortab[ *cb + 3*256 ]; ++cr; ++cb; L = *lum++; row1[0] = row1[1] = row1[next_row] = row1[next_row+1] = (rgb_2_pix[ L + cr_r ] | rgb_2_pix[ L + crb_g ] | rgb_2_pix[ L + cb_b ]); row1 += 2; L = *lum++; row1[0] = row1[1] = row1[next_row] = row1[next_row+1] = (rgb_2_pix[ L + cr_r ] | rgb_2_pix[ L + crb_g ] | rgb_2_pix[ L + cb_b ]); row1 += 2; /* Now, do second row. */ L = *lum2++; row2[0] = row2[1] = row2[next_row] = row2[next_row+1] = (rgb_2_pix[ L + cr_r ] | rgb_2_pix[ L + crb_g ] | rgb_2_pix[ L + cb_b ]); row2 += 2; L = *lum2++; row2[0] = row2[1] = row2[next_row] = row2[next_row+1] = (rgb_2_pix[ L + cr_r ] | rgb_2_pix[ L + crb_g ] | rgb_2_pix[ L + cb_b ]); row2 += 2; } /* * These values are at the start of the next line, (due * to the ++'s above),but they need to be at the start * of the line after that. */ lum += cols; lum2 += cols; row1 += mod; row2 += mod; } } static void Color16DitherYUY2Mod1X( int *colortab, Uint32 *rgb_2_pix, unsigned char *lum, unsigned char *cr, unsigned char *cb, unsigned char *out, int rows, int cols, int mod ) { unsigned short* row; int x, y; int cr_r; int crb_g; int cb_b; int cols_2 = cols / 2; row = (unsigned short*) out; y = rows; while( y-- ) { x = cols_2; while( x-- ) { register int L; cr_r = 0*768+256 + colortab[ *cr + 0*256 ]; crb_g = 1*768+256 + colortab[ *cr + 1*256 ] + colortab[ *cb + 2*256 ]; cb_b = 2*768+256 + colortab[ *cb + 3*256 ]; cr += 4; cb += 4; L = *lum; lum += 2; *row++ = (unsigned short)(rgb_2_pix[ L + cr_r ] | rgb_2_pix[ L + crb_g ] | rgb_2_pix[ L + cb_b ]); L = *lum; lum += 2; *row++ = (unsigned short)(rgb_2_pix[ L + cr_r ] | rgb_2_pix[ L + crb_g ] | rgb_2_pix[ L + cb_b ]); } row += mod; } } static void Color24DitherYUY2Mod1X( int *colortab, Uint32 *rgb_2_pix, unsigned char *lum, unsigned char *cr, unsigned char *cb, unsigned char *out, int rows, int cols, int mod ) { unsigned int value; unsigned char* row; int x, y; int cr_r; int crb_g; int cb_b; int cols_2 = cols / 2; row = (unsigned char*) out; mod *= 3; y = rows; while( y-- ) { x = cols_2; while( x-- ) { register int L; cr_r = 0*768+256 + colortab[ *cr + 0*256 ]; crb_g = 1*768+256 + colortab[ *cr + 1*256 ] + colortab[ *cb + 2*256 ]; cb_b = 2*768+256 + colortab[ *cb + 3*256 ]; cr += 4; cb += 4; L = *lum; lum += 2; value = (rgb_2_pix[ L + cr_r ] | rgb_2_pix[ L + crb_g ] | rgb_2_pix[ L + cb_b ]); *row++ = (value ) & 0xFF; *row++ = (value >> 8) & 0xFF; *row++ = (value >> 16) & 0xFF; L = *lum; lum += 2; value = (rgb_2_pix[ L + cr_r ] | rgb_2_pix[ L + crb_g ] | rgb_2_pix[ L + cb_b ]); *row++ = (value ) & 0xFF; *row++ = (value >> 8) & 0xFF; *row++ = (value >> 16) & 0xFF; } row += mod; } } static void Color32DitherYUY2Mod1X( int *colortab, Uint32 *rgb_2_pix, unsigned char *lum, unsigned char *cr, unsigned char *cb, unsigned char *out, int rows, int cols, int mod ) { unsigned int* row; int x, y; int cr_r; int crb_g; int cb_b; int cols_2 = cols / 2; row = (unsigned int*) out; y = rows; while( y-- ) { x = cols_2; while( x-- ) { register int L; cr_r = 0*768+256 + colortab[ *cr + 0*256 ]; crb_g = 1*768+256 + colortab[ *cr + 1*256 ] + colortab[ *cb + 2*256 ]; cb_b = 2*768+256 + colortab[ *cb + 3*256 ]; cr += 4; cb += 4; L = *lum; lum += 2; *row++ = (rgb_2_pix[ L + cr_r ] | rgb_2_pix[ L + crb_g ] | rgb_2_pix[ L + cb_b ]); L = *lum; lum += 2; *row++ = (rgb_2_pix[ L + cr_r ] | rgb_2_pix[ L + crb_g ] | rgb_2_pix[ L + cb_b ]); } row += mod; } } /* * In this function I make use of a nasty trick. The tables have the lower * 16 bits replicated in the upper 16. This means I can write ints and get * the horisontal doubling for free (almost). */ static void Color16DitherYUY2Mod2X( int *colortab, Uint32 *rgb_2_pix, unsigned char *lum, unsigned char *cr, unsigned char *cb, unsigned char *out, int rows, int cols, int mod ) { unsigned int* row = (unsigned int*) out; const int next_row = cols+(mod/2); int x, y; int cr_r; int crb_g; int cb_b; int cols_2 = cols / 2; y = rows; while( y-- ) { x = cols_2; while( x-- ) { register int L; cr_r = 0*768+256 + colortab[ *cr + 0*256 ]; crb_g = 1*768+256 + colortab[ *cr + 1*256 ] + colortab[ *cb + 2*256 ]; cb_b = 2*768+256 + colortab[ *cb + 3*256 ]; cr += 4; cb += 4; L = *lum; lum += 2; row[0] = row[next_row] = (rgb_2_pix[ L + cr_r ] | rgb_2_pix[ L + crb_g ] | rgb_2_pix[ L + cb_b ]); row++; L = *lum; lum += 2; row[0] = row[next_row] = (rgb_2_pix[ L + cr_r ] | rgb_2_pix[ L + crb_g ] | rgb_2_pix[ L + cb_b ]); row++; } row += next_row; } } static void Color24DitherYUY2Mod2X( int *colortab, Uint32 *rgb_2_pix, unsigned char *lum, unsigned char *cr, unsigned char *cb, unsigned char *out, int rows, int cols, int mod ) { unsigned int value; unsigned char* row = out; const int next_row = (cols*2 + mod) * 3; int x, y; int cr_r; int crb_g; int cb_b; int cols_2 = cols / 2; y = rows; while( y-- ) { x = cols_2; while( x-- ) { register int L; cr_r = 0*768+256 + colortab[ *cr + 0*256 ]; crb_g = 1*768+256 + colortab[ *cr + 1*256 ] + colortab[ *cb + 2*256 ]; cb_b = 2*768+256 + colortab[ *cb + 3*256 ]; cr += 4; cb += 4; L = *lum; lum += 2; value = (rgb_2_pix[ L + cr_r ] | rgb_2_pix[ L + crb_g ] | rgb_2_pix[ L + cb_b ]); row[0+0] = row[3+0] = row[next_row+0] = row[next_row+3+0] = (value ) & 0xFF; row[0+1] = row[3+1] = row[next_row+1] = row[next_row+3+1] = (value >> 8) & 0xFF; row[0+2] = row[3+2] = row[next_row+2] = row[next_row+3+2] = (value >> 16) & 0xFF; row += 2*3; L = *lum; lum += 2; value = (rgb_2_pix[ L + cr_r ] | rgb_2_pix[ L + crb_g ] | rgb_2_pix[ L + cb_b ]); row[0+0] = row[3+0] = row[next_row+0] = row[next_row+3+0] = (value ) & 0xFF; row[0+1] = row[3+1] = row[next_row+1] = row[next_row+3+1] = (value >> 8) & 0xFF; row[0+2] = row[3+2] = row[next_row+2] = row[next_row+3+2] = (value >> 16) & 0xFF; row += 2*3; } row += next_row; } } static void Color32DitherYUY2Mod2X( int *colortab, Uint32 *rgb_2_pix, unsigned char *lum, unsigned char *cr, unsigned char *cb, unsigned char *out, int rows, int cols, int mod ) { unsigned int* row = (unsigned int*) out; const int next_row = cols*2+mod; int x, y; int cr_r; int crb_g; int cb_b; int cols_2 = cols / 2; mod+=mod; y = rows; while( y-- ) { x = cols_2; while( x-- ) { register int L; cr_r = 0*768+256 + colortab[ *cr + 0*256 ]; crb_g = 1*768+256 + colortab[ *cr + 1*256 ] + colortab[ *cb + 2*256 ]; cb_b = 2*768+256 + colortab[ *cb + 3*256 ]; cr += 4; cb += 4; L = *lum; lum += 2; row[0] = row[1] = row[next_row] = row[next_row+1] = (rgb_2_pix[ L + cr_r ] | rgb_2_pix[ L + crb_g ] | rgb_2_pix[ L + cb_b ]); row += 2; L = *lum; lum += 2; row[0] = row[1] = row[next_row] = row[next_row+1] = (rgb_2_pix[ L + cr_r ] | rgb_2_pix[ L + crb_g ] | rgb_2_pix[ L + cb_b ]); row += 2; } row += next_row; } } /* * How many 1 bits are there in the Uint32. * Low performance, do not call often. */ static int number_of_bits_set( Uint32 a ) { if(!a) return 0; if(a & 1) return 1 + number_of_bits_set(a >> 1); return(number_of_bits_set(a >> 1)); } /* * How many 0 bits are there at least significant end of Uint32. * Low performance, do not call often. */ static int free_bits_at_bottom( Uint32 a ) { /* assume char is 8 bits */ if(!a) return sizeof(Uint32) * 8; if(((Sint32)a) & 1l) return 0; return 1 + free_bits_at_bottom ( a >> 1); } SDL_Overlay *SDL_CreateYUV_SW(_THIS, int width, int height, Uint32 format, SDL_Surface *display) { SDL_Overlay *overlay; struct private_yuvhwdata *swdata; int *Cr_r_tab; int *Cr_g_tab; int *Cb_g_tab; int *Cb_b_tab; Uint32 *r_2_pix_alloc; Uint32 *g_2_pix_alloc; Uint32 *b_2_pix_alloc; int i; int CR, CB; Uint32 Rmask, Gmask, Bmask; /* Only RGB packed pixel conversion supported */ if ( (display->format->BytesPerPixel != 2) && (display->format->BytesPerPixel != 3) && (display->format->BytesPerPixel != 4) ) { SDL_SetError("Can't use YUV data on non 16/24/32 bit surfaces"); return(NULL); } /* Verify that we support the format */ switch (format) { case SDL_YV12_OVERLAY: case SDL_IYUV_OVERLAY: case SDL_YUY2_OVERLAY: case SDL_UYVY_OVERLAY: case SDL_YVYU_OVERLAY: break; default: SDL_SetError("Unsupported YUV format"); return(NULL); } /* Create the overlay structure */ overlay = (SDL_Overlay *)SDL_malloc(sizeof *overlay); if ( overlay == NULL ) { SDL_OutOfMemory(); return(NULL); } SDL_memset(overlay, 0, (sizeof *overlay)); /* Fill in the basic members */ overlay->format = format; overlay->w = width; overlay->h = height; /* Set up the YUV surface function structure */ overlay->hwfuncs = &sw_yuvfuncs; /* Create the pixel data and lookup tables */ swdata = (struct private_yuvhwdata *)SDL_malloc(sizeof *swdata); overlay->hwdata = swdata; if ( swdata == NULL ) { SDL_OutOfMemory(); SDL_FreeYUVOverlay(overlay); return(NULL); } swdata->stretch = NULL; swdata->display = display; swdata->pixels = (Uint8 *) SDL_malloc(width*height*2); swdata->colortab = (int *)SDL_malloc(4*256*sizeof(int)); Cr_r_tab = &swdata->colortab[0*256]; Cr_g_tab = &swdata->colortab[1*256]; Cb_g_tab = &swdata->colortab[2*256]; Cb_b_tab = &swdata->colortab[3*256]; swdata->rgb_2_pix = (Uint32 *)SDL_malloc(3*768*sizeof(Uint32)); r_2_pix_alloc = &swdata->rgb_2_pix[0*768]; g_2_pix_alloc = &swdata->rgb_2_pix[1*768]; b_2_pix_alloc = &swdata->rgb_2_pix[2*768]; if ( ! swdata->pixels || ! swdata->colortab || ! swdata->rgb_2_pix ) { SDL_OutOfMemory(); SDL_FreeYUVOverlay(overlay); return(NULL); } /* Generate the tables for the display surface */ for (i=0; i<256; i++) { /* Gamma correction (luminescence table) and chroma correction would be done here. See the Berkeley mpeg_play sources. */ CB = CR = (i-128); Cr_r_tab[i] = (int) ( (0.419/0.299) * CR); Cr_g_tab[i] = (int) (-(0.299/0.419) * CR); Cb_g_tab[i] = (int) (-(0.114/0.331) * CB); Cb_b_tab[i] = (int) ( (0.587/0.331) * CB); } /* * Set up entries 0-255 in rgb-to-pixel value tables. */ Rmask = display->format->Rmask; Gmask = display->format->Gmask; Bmask = display->format->Bmask; for ( i=0; i<256; ++i ) { r_2_pix_alloc[i+256] = i >> (8 - number_of_bits_set(Rmask)); r_2_pix_alloc[i+256] <<= free_bits_at_bottom(Rmask); g_2_pix_alloc[i+256] = i >> (8 - number_of_bits_set(Gmask)); g_2_pix_alloc[i+256] <<= free_bits_at_bottom(Gmask); b_2_pix_alloc[i+256] = i >> (8 - number_of_bits_set(Bmask)); b_2_pix_alloc[i+256] <<= free_bits_at_bottom(Bmask); } /* * If we have 16-bit output depth, then we double the value * in the top word. This means that we can write out both * pixels in the pixel doubling mode with one op. It is * harmless in the normal case as storing a 32-bit value * through a short pointer will lose the top bits anyway. */ if( display->format->BytesPerPixel == 2 ) { for ( i=0; i<256; ++i ) { r_2_pix_alloc[i+256] |= (r_2_pix_alloc[i+256]) << 16; g_2_pix_alloc[i+256] |= (g_2_pix_alloc[i+256]) << 16; b_2_pix_alloc[i+256] |= (b_2_pix_alloc[i+256]) << 16; } } /* * Spread out the values we have to the rest of the array so that * we do not need to check for overflow. */ for ( i=0; i<256; ++i ) { r_2_pix_alloc[i] = r_2_pix_alloc[256]; r_2_pix_alloc[i+512] = r_2_pix_alloc[511]; g_2_pix_alloc[i] = g_2_pix_alloc[256]; g_2_pix_alloc[i+512] = g_2_pix_alloc[511]; b_2_pix_alloc[i] = b_2_pix_alloc[256]; b_2_pix_alloc[i+512] = b_2_pix_alloc[511]; } /* You have chosen wisely... */ switch (format) { case SDL_YV12_OVERLAY: case SDL_IYUV_OVERLAY: if ( display->format->BytesPerPixel == 2 ) { #if (__GNUC__ > 2) && defined(__i386__) && __OPTIMIZE__ && SDL_ASSEMBLY_ROUTINES /* inline assembly functions */ if ( SDL_HasMMX() && (Rmask == 0xF800) && (Gmask == 0x07E0) && (Bmask == 0x001F) && (width & 15) == 0) { /*printf("Using MMX 16-bit 565 dither\n");*/ swdata->Display1X = Color565DitherYV12MMX1X; } else { /*printf("Using C 16-bit dither\n");*/ swdata->Display1X = Color16DitherYV12Mod1X; } #else swdata->Display1X = Color16DitherYV12Mod1X; #endif swdata->Display2X = Color16DitherYV12Mod2X; } if ( display->format->BytesPerPixel == 3 ) { swdata->Display1X = Color24DitherYV12Mod1X; swdata->Display2X = Color24DitherYV12Mod2X; } if ( display->format->BytesPerPixel == 4 ) { #if (__GNUC__ > 2) && defined(__i386__) && __OPTIMIZE__ && SDL_ASSEMBLY_ROUTINES /* inline assembly functions */ if ( SDL_HasMMX() && (Rmask == 0x00FF0000) && (Gmask == 0x0000FF00) && (Bmask == 0x000000FF) && (width & 15) == 0) { /*printf("Using MMX 32-bit dither\n");*/ swdata->Display1X = ColorRGBDitherYV12MMX1X; } else { /*printf("Using C 32-bit dither\n");*/ swdata->Display1X = Color32DitherYV12Mod1X; } #else swdata->Display1X = Color32DitherYV12Mod1X; #endif swdata->Display2X = Color32DitherYV12Mod2X; } break; case SDL_YUY2_OVERLAY: case SDL_UYVY_OVERLAY: case SDL_YVYU_OVERLAY: if ( display->format->BytesPerPixel == 2 ) { swdata->Display1X = Color16DitherYUY2Mod1X; swdata->Display2X = Color16DitherYUY2Mod2X; } if ( display->format->BytesPerPixel == 3 ) { swdata->Display1X = Color24DitherYUY2Mod1X; swdata->Display2X = Color24DitherYUY2Mod2X; } if ( display->format->BytesPerPixel == 4 ) { swdata->Display1X = Color32DitherYUY2Mod1X; swdata->Display2X = Color32DitherYUY2Mod2X; } break; default: /* We should never get here (caught above) */ break; } /* Find the pitch and offset values for the overlay */ overlay->pitches = swdata->pitches; overlay->pixels = swdata->planes; switch (format) { case SDL_YV12_OVERLAY: case SDL_IYUV_OVERLAY: overlay->pitches[0] = overlay->w; overlay->pitches[1] = overlay->pitches[0] / 2; overlay->pitches[2] = overlay->pitches[0] / 2; overlay->pixels[0] = swdata->pixels; overlay->pixels[1] = overlay->pixels[0] + overlay->pitches[0] * overlay->h; overlay->pixels[2] = overlay->pixels[1] + overlay->pitches[1] * overlay->h / 2; overlay->planes = 3; break; case SDL_YUY2_OVERLAY: case SDL_UYVY_OVERLAY: case SDL_YVYU_OVERLAY: overlay->pitches[0] = overlay->w*2; overlay->pixels[0] = swdata->pixels; overlay->planes = 1; break; default: /* We should never get here (caught above) */ break; } /* We're all done.. */ return(overlay); } int SDL_LockYUV_SW(_THIS, SDL_Overlay *overlay) { return(0); } void SDL_UnlockYUV_SW(_THIS, SDL_Overlay *overlay) { return; } int SDL_DisplayYUV_SW(_THIS, SDL_Overlay *overlay, SDL_Rect *src, SDL_Rect *dst) { struct private_yuvhwdata *swdata; int stretch; int scale_2x; SDL_Surface *display; Uint8 *lum, *Cr, *Cb; Uint8 *dstp; int mod; swdata = overlay->hwdata; stretch = 0; scale_2x = 0; if ( src->x || src->y || src->w < overlay->w || src->h < overlay->h ) { /* The source rectangle has been clipped. Using a scratch surface is easier than adding clipped source support to all the blitters, plus that would slow them down in the general unclipped case. */ stretch = 1; } else if ( (src->w != dst->w) || (src->h != dst->h) ) { if ( (dst->w == 2*src->w) && (dst->h == 2*src->h) ) { scale_2x = 1; } else { stretch = 1; } } if ( stretch ) { if ( ! swdata->stretch ) { display = swdata->display; swdata->stretch = SDL_CreateRGBSurface( SDL_SWSURFACE, overlay->w, overlay->h, display->format->BitsPerPixel, display->format->Rmask, display->format->Gmask, display->format->Bmask, 0); if ( ! swdata->stretch ) { return(-1); } } display = swdata->stretch; } else { display = swdata->display; } switch (overlay->format) { case SDL_YV12_OVERLAY: lum = overlay->pixels[0]; Cr = overlay->pixels[1]; Cb = overlay->pixels[2]; break; case SDL_IYUV_OVERLAY: lum = overlay->pixels[0]; Cr = overlay->pixels[2]; Cb = overlay->pixels[1]; break; case SDL_YUY2_OVERLAY: lum = overlay->pixels[0]; Cr = lum + 3; Cb = lum + 1; break; case SDL_UYVY_OVERLAY: lum = overlay->pixels[0]+1; Cr = lum + 1; Cb = lum - 1; break; case SDL_YVYU_OVERLAY: lum = overlay->pixels[0]; Cr = lum + 1; Cb = lum + 3; break; default: SDL_SetError("Unsupported YUV format in blit"); return(-1); } if ( SDL_MUSTLOCK(display) ) { if ( SDL_LockSurface(display) < 0 ) { return(-1); } } if ( stretch ) { dstp = (Uint8 *)swdata->stretch->pixels; } else { dstp = (Uint8 *)display->pixels + dst->x * display->format->BytesPerPixel + dst->y * display->pitch; } mod = (display->pitch / display->format->BytesPerPixel); if ( scale_2x ) { mod -= (overlay->w * 2); swdata->Display2X(swdata->colortab, swdata->rgb_2_pix, lum, Cr, Cb, dstp, overlay->h, overlay->w, mod); } else { mod -= overlay->w; swdata->Display1X(swdata->colortab, swdata->rgb_2_pix, lum, Cr, Cb, dstp, overlay->h, overlay->w, mod); } if ( SDL_MUSTLOCK(display) ) { SDL_UnlockSurface(display); } if ( stretch ) { display = swdata->display; SDL_SoftStretch(swdata->stretch, src, display, dst); } SDL_UpdateRects(display, 1, dst); return(0); } void SDL_FreeYUV_SW(_THIS, SDL_Overlay *overlay) { struct private_yuvhwdata *swdata; swdata = overlay->hwdata; if ( swdata ) { if ( swdata->stretch ) { SDL_FreeSurface(swdata->stretch); } if ( swdata->pixels ) { SDL_free(swdata->pixels); } if ( swdata->colortab ) { SDL_free(swdata->colortab); } if ( swdata->rgb_2_pix ) { SDL_free(swdata->rgb_2_pix); } SDL_free(swdata); } }