/*

SDL - Simple DirectMedia Layer

This library is free software; you can redistribute it and/or

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

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

/* 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_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 */

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 );

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 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 */

if ( overlay == NULL ) {

SDL_OutOfMemory();

return(NULL);

}

/* 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 */

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];

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);