1300 lines
40 KiB
C
1300 lines
40 KiB
C
/*
|
|
SDL - Simple DirectMedia Layer
|
|
Copyright (C) 1997-2012 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);
|
|
overlay->hwdata = NULL;
|
|
}
|
|
}
|