void InfiLHighestCommonPixelFormat() {
for ( uint32 i=0;i<disp_list.size();++i ) {
uint32 format = SDL_PIXELLAYOUT(disp_list[i].format);
switch( format ) {
case SDL_PACKEDLAYOUT_332:
SET_GL_ATTRIB( 3, 3, 2 );
break;
case SDL_PACKEDLAYOUT_4444:
SET_GL_ATTRIB( 4, 4, 4 );
break;
case SDL_PACKEDLAYOUT_1555:
SET_GL_ATTRIB( 5, 5, 5 );
break;
case SDL_PACKEDLAYOUT_5551:
SET_GL_ATTRIB( 5, 5, 5 );
break;
case SDL_PACKEDLAYOUT_565:
SET_GL_ATTRIB( 5, 6, 5 );
break;
case SDL_PACKEDLAYOUT_8888:
SET_GL_ATTRIB( 8, 8, 8 );
break;
case SDL_PACKEDLAYOUT_2101010:
case SDL_PACKEDLAYOUT_1010102:
SET_GL_ATTRIB( 10, 10, 10 );
break;
}
}
}
static int
SW_RenderCopyEx(SDL_Renderer * renderer, SDL_Texture * texture,
const SDL_Rect * srcrect, const SDL_FRect * dstrect,
const double angle, const SDL_FPoint * center, const SDL_RendererFlip flip)
{
SDL_Surface *surface = SW_ActivateRenderer(renderer);
SDL_Surface *src = (SDL_Surface *) texture->driverdata;
SDL_Rect final_rect, tmp_rect;
SDL_Surface *src_clone, *src_rotated, *src_scaled;
SDL_Surface *mask = NULL, *mask_rotated = NULL;
int retval = 0, dstwidth, dstheight, abscenterx, abscentery;
double cangle, sangle, px, py, p1x, p1y, p2x, p2y, p3x, p3y, p4x, p4y;
SDL_BlendMode blendmode;
Uint8 alphaMod, rMod, gMod, bMod;
int applyModulation = SDL_FALSE;
int blitRequired = SDL_FALSE;
int isOpaque = SDL_FALSE;
if (!surface) {
return -1;
}
if (renderer->viewport.x || renderer->viewport.y) {
final_rect.x = (int)(renderer->viewport.x + dstrect->x);
final_rect.y = (int)(renderer->viewport.y + dstrect->y);
} else {
final_rect.x = (int)dstrect->x;
final_rect.y = (int)dstrect->y;
}
final_rect.w = (int)dstrect->w;
final_rect.h = (int)dstrect->h;
tmp_rect = final_rect;
tmp_rect.x = 0;
tmp_rect.y = 0;
/* It is possible to encounter an RLE encoded surface here and locking it is
* necessary because this code is going to access the pixel buffer directly.
*/
if (SDL_MUSTLOCK(src)) {
SDL_LockSurface(src);
}
/* Clone the source surface but use its pixel buffer directly.
* The original source surface must be treated as read-only.
*/
src_clone = SDL_CreateRGBSurfaceFrom(src->pixels, src->w, src->h, src->format->BitsPerPixel, src->pitch,
src->format->Rmask, src->format->Gmask,
src->format->Bmask, src->format->Amask);
if (src_clone == NULL) {
if (SDL_MUSTLOCK(src)) {
SDL_UnlockSurface(src);
}
return -1;
}
SDL_GetSurfaceBlendMode(src, &blendmode);
SDL_GetSurfaceAlphaMod(src, &alphaMod);
SDL_GetSurfaceColorMod(src, &rMod, &gMod, &bMod);
/* SDLgfx_rotateSurface only accepts 32-bit surfaces with a 8888 layout. Everything else has to be converted. */
if (src->format->BitsPerPixel != 32 || SDL_PIXELLAYOUT(src->format->format) != SDL_PACKEDLAYOUT_8888 || !src->format->Amask) {
blitRequired = SDL_TRUE;
}
/* If scaling and cropping is necessary, it has to be taken care of before the rotation. */
if (!(srcrect->w == final_rect.w && srcrect->h == final_rect.h && srcrect->x == 0 && srcrect->y == 0)) {
blitRequired = SDL_TRUE;
}
/* The color and alpha modulation has to be applied before the rotation when using the NONE and MOD blend modes. */
if ((blendmode == SDL_BLENDMODE_NONE || blendmode == SDL_BLENDMODE_MOD) && (alphaMod & rMod & gMod & bMod) != 255) {
applyModulation = SDL_TRUE;
SDL_SetSurfaceAlphaMod(src_clone, alphaMod);
SDL_SetSurfaceColorMod(src_clone, rMod, gMod, bMod);
}
/* Opaque surfaces are much easier to handle with the NONE blend mode. */
if (blendmode == SDL_BLENDMODE_NONE && !src->format->Amask && alphaMod == 255) {
isOpaque = SDL_TRUE;
}
/* The NONE blend mode requires a mask for non-opaque surfaces. This mask will be used
* to clear the pixels in the destination surface. The other steps are explained below.
*/
if (blendmode == SDL_BLENDMODE_NONE && !isOpaque) {
mask = SDL_CreateRGBSurface(0, final_rect.w, final_rect.h, 32,
0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000);
if (mask == NULL) {
retval = -1;
} else {
SDL_SetSurfaceBlendMode(mask, SDL_BLENDMODE_MOD);
}
}
/* Create a new surface should there be a format mismatch or if scaling, cropping,
* or modulation is required. It's possible to use the source surface directly otherwise.
*/
if (!retval && (blitRequired || applyModulation)) {
SDL_Rect scale_rect = tmp_rect;
src_scaled = SDL_CreateRGBSurface(0, final_rect.w, final_rect.h, 32,
0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000);
if (src_scaled == NULL) {
retval = -1;
} else {
SDL_SetSurfaceBlendMode(src_clone, SDL_BLENDMODE_NONE);
retval = SDL_BlitScaled(src_clone, srcrect, src_scaled, &scale_rect);
SDL_FreeSurface(src_clone);
src_clone = src_scaled;
src_scaled = NULL;
}
}
/* SDLgfx_rotateSurface is going to make decisions depending on the blend mode. */
SDL_SetSurfaceBlendMode(src_clone, blendmode);
if (!retval) {
SDLgfx_rotozoomSurfaceSizeTrig(tmp_rect.w, tmp_rect.h, angle, &dstwidth, &dstheight, &cangle, &sangle);
src_rotated = SDLgfx_rotateSurface(src_clone, angle, dstwidth/2, dstheight/2, GetScaleQuality(), flip & SDL_FLIP_HORIZONTAL, flip & SDL_FLIP_VERTICAL, dstwidth, dstheight, cangle, sangle);
if (src_rotated == NULL) {
retval = -1;
}
if (!retval && mask != NULL) {
/* The mask needed for the NONE blend mode gets rotated with the same parameters. */
mask_rotated = SDLgfx_rotateSurface(mask, angle, dstwidth/2, dstheight/2, SDL_FALSE, 0, 0, dstwidth, dstheight, cangle, sangle);
if (mask_rotated == NULL) {
retval = -1;
}
}
if (!retval) {
/* Find out where the new origin is by rotating the four final_rect points around the center and then taking the extremes */
abscenterx = final_rect.x + (int)center->x;
abscentery = final_rect.y + (int)center->y;
/* Compensate the angle inversion to match the behaviour of the other backends */
sangle = -sangle;
/* Top Left */
px = final_rect.x - abscenterx;
py = final_rect.y - abscentery;
p1x = px * cangle - py * sangle + abscenterx;
p1y = px * sangle + py * cangle + abscentery;
/* Top Right */
px = final_rect.x + final_rect.w - abscenterx;
py = final_rect.y - abscentery;
p2x = px * cangle - py * sangle + abscenterx;
p2y = px * sangle + py * cangle + abscentery;
/* Bottom Left */
px = final_rect.x - abscenterx;
py = final_rect.y + final_rect.h - abscentery;
p3x = px * cangle - py * sangle + abscenterx;
p3y = px * sangle + py * cangle + abscentery;
/* Bottom Right */
px = final_rect.x + final_rect.w - abscenterx;
py = final_rect.y + final_rect.h - abscentery;
p4x = px * cangle - py * sangle + abscenterx;
p4y = px * sangle + py * cangle + abscentery;
tmp_rect.x = (int)MIN(MIN(p1x, p2x), MIN(p3x, p4x));
tmp_rect.y = (int)MIN(MIN(p1y, p2y), MIN(p3y, p4y));
tmp_rect.w = dstwidth;
tmp_rect.h = dstheight;
/* The NONE blend mode needs some special care with non-opaque surfaces.
* Other blend modes or opaque surfaces can be blitted directly.
*/
if (blendmode != SDL_BLENDMODE_NONE || isOpaque) {
if (applyModulation == SDL_FALSE) {
/* If the modulation wasn't already applied, make it happen now. */
SDL_SetSurfaceAlphaMod(src_rotated, alphaMod);
SDL_SetSurfaceColorMod(src_rotated, rMod, gMod, bMod);
}
retval = SDL_BlitSurface(src_rotated, NULL, surface, &tmp_rect);
} else {
/* The NONE blend mode requires three steps to get the pixels onto the destination surface.
* First, the area where the rotated pixels will be blitted to get set to zero.
* This is accomplished by simply blitting a mask with the NONE blend mode.
* The colorkey set by the rotate function will discard the correct pixels.
*/
SDL_Rect mask_rect = tmp_rect;
SDL_SetSurfaceBlendMode(mask_rotated, SDL_BLENDMODE_NONE);
retval = SDL_BlitSurface(mask_rotated, NULL, surface, &mask_rect);
if (!retval) {
/* The next step copies the alpha value. This is done with the BLEND blend mode and
* by modulating the source colors with 0. Since the destination is all zeros, this
* will effectively set the destination alpha to the source alpha.
*/
SDL_SetSurfaceColorMod(src_rotated, 0, 0, 0);
mask_rect = tmp_rect;
retval = SDL_BlitSurface(src_rotated, NULL, surface, &mask_rect);
if (!retval) {
/* The last step gets the color values in place. The ADD blend mode simply adds them to
* the destination (where the color values are all zero). However, because the ADD blend
* mode modulates the colors with the alpha channel, a surface without an alpha mask needs
* to be created. This makes all source pixels opaque and the colors get copied correctly.
*/
SDL_Surface *src_rotated_rgb;
src_rotated_rgb = SDL_CreateRGBSurfaceFrom(src_rotated->pixels, src_rotated->w, src_rotated->h,
src_rotated->format->BitsPerPixel, src_rotated->pitch,
src_rotated->format->Rmask, src_rotated->format->Gmask,
src_rotated->format->Bmask, 0);
if (src_rotated_rgb == NULL) {
retval = -1;
} else {
SDL_SetSurfaceBlendMode(src_rotated_rgb, SDL_BLENDMODE_ADD);
retval = SDL_BlitSurface(src_rotated_rgb, NULL, surface, &tmp_rect);
SDL_FreeSurface(src_rotated_rgb);
}
}
}
SDL_FreeSurface(mask_rotated);
}
if (src_rotated != NULL) {
SDL_FreeSurface(src_rotated);
}
}
}
if (SDL_MUSTLOCK(src)) {
SDL_UnlockSurface(src);
}
if (mask != NULL) {
SDL_FreeSurface(mask);
}
if (src_clone != NULL) {
SDL_FreeSurface(src_clone);
}
return retval;
}
SDL_bool
SDL_PixelFormatEnumToMasks(Uint32 format, int *bpp, Uint32 * Rmask,
Uint32 * Gmask, Uint32 * Bmask, Uint32 * Amask)
{
Uint32 masks[4];
/* Initialize the values here */
if (SDL_BYTESPERPIXEL(format) <= 2) {
*bpp = SDL_BITSPERPIXEL(format);
} else {
*bpp = SDL_BYTESPERPIXEL(format) * 8;
}
*Rmask = *Gmask = *Bmask = *Amask = 0;
if (format == SDL_PIXELFORMAT_RGB24) {
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
*Rmask = 0x00FF0000;
*Gmask = 0x0000FF00;
*Bmask = 0x000000FF;
#else
*Rmask = 0x000000FF;
*Gmask = 0x0000FF00;
*Bmask = 0x00FF0000;
#endif
return SDL_TRUE;
}
if (format == SDL_PIXELFORMAT_BGR24) {
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
*Rmask = 0x000000FF;
*Gmask = 0x0000FF00;
*Bmask = 0x00FF0000;
#else
*Rmask = 0x00FF0000;
*Gmask = 0x0000FF00;
*Bmask = 0x000000FF;
#endif
return SDL_TRUE;
}
if (SDL_PIXELTYPE(format) != SDL_PIXELTYPE_PACKED8 &&
SDL_PIXELTYPE(format) != SDL_PIXELTYPE_PACKED16 &&
SDL_PIXELTYPE(format) != SDL_PIXELTYPE_PACKED32) {
/* Not a format that uses masks */
return SDL_TRUE;
}
switch (SDL_PIXELLAYOUT(format)) {
case SDL_PACKEDLAYOUT_332:
masks[0] = 0x00000000;
masks[1] = 0x000000E0;
masks[2] = 0x0000001C;
masks[3] = 0x00000003;
break;
case SDL_PACKEDLAYOUT_4444:
masks[0] = 0x0000F000;
masks[1] = 0x00000F00;
masks[2] = 0x000000F0;
masks[3] = 0x0000000F;
break;
case SDL_PACKEDLAYOUT_1555:
masks[0] = 0x00008000;
masks[1] = 0x00007C00;
masks[2] = 0x000003E0;
masks[3] = 0x0000001F;
break;
case SDL_PACKEDLAYOUT_5551:
masks[0] = 0x0000F800;
masks[1] = 0x000007C0;
masks[2] = 0x0000003E;
masks[3] = 0x00000001;
break;
case SDL_PACKEDLAYOUT_565:
masks[0] = 0x00000000;
masks[1] = 0x0000F800;
masks[2] = 0x000007E0;
masks[3] = 0x0000001F;
break;
case SDL_PACKEDLAYOUT_8888:
masks[0] = 0xFF000000;
masks[1] = 0x00FF0000;
masks[2] = 0x0000FF00;
masks[3] = 0x000000FF;
break;
case SDL_PACKEDLAYOUT_2101010:
masks[0] = 0xC0000000;
masks[1] = 0x3FF00000;
masks[2] = 0x000FFC00;
masks[3] = 0x000003FF;
break;
case SDL_PACKEDLAYOUT_1010102:
masks[0] = 0xFFC00000;
masks[1] = 0x003FF000;
masks[2] = 0x00000FFC;
masks[3] = 0x00000003;
break;
default:
SDL_SetError("Unknown pixel format");
return SDL_FALSE;
}
switch (SDL_PIXELORDER(format)) {
case SDL_PACKEDORDER_XRGB:
*Rmask = masks[1];
*Gmask = masks[2];
*Bmask = masks[3];
break;
case SDL_PACKEDORDER_RGBX:
*Rmask = masks[0];
*Gmask = masks[1];
*Bmask = masks[2];
break;
case SDL_PACKEDORDER_ARGB:
*Amask = masks[0];
*Rmask = masks[1];
*Gmask = masks[2];
*Bmask = masks[3];
break;
case SDL_PACKEDORDER_RGBA:
*Rmask = masks[0];
*Gmask = masks[1];
*Bmask = masks[2];
*Amask = masks[3];
break;
case SDL_PACKEDORDER_XBGR:
*Bmask = masks[1];
*Gmask = masks[2];
*Rmask = masks[3];
break;
case SDL_PACKEDORDER_BGRX:
*Bmask = masks[0];
*Gmask = masks[1];
*Rmask = masks[2];
break;
case SDL_PACKEDORDER_BGRA:
*Bmask = masks[0];
*Gmask = masks[1];
*Rmask = masks[2];
*Amask = masks[3];
break;
case SDL_PACKEDORDER_ABGR:
*Amask = masks[0];
*Bmask = masks[1];
*Gmask = masks[2];
*Rmask = masks[3];
break;
default:
SDL_SetError("Unknown pixel format");
return SDL_FALSE;
}
return SDL_TRUE;
}