pandory500/SDL-mirror
2
0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Emphasized the separation between SDL_Surface and SDL_Texture

Browse source 
- SDL_Surface is a system memory representation of pixel data
 - SDL_Texture is a video memory representation of pixel data

The concept of SDL_Surface with SDL_HWSURFACE is no longer used.

Separated SDL_Texture types by usage rather than memory type
 - SDL_TEXTUREACCESS_STATIC is for rarely changed pixel data,
   can be placed in video memory.
 - SDL_TEXTUREACCESS_STREAMING is for frequently changing pixel
   data, usually placed in system memory or AGP memory.

Optimized the SDL_compat usage of the OpenGL renderer by only
using one copy of the framebuffer instead of two.

--HG--
extra : convert_revision : svn%3Ac70aab31-4412-0410-b14c-859654838e24/trunk%402584
This commit is contained in:
Sam Lantinga 2007-08-11 20:54:31 +00:00
parent c1a200fa1d
commit 6b348f07c7
11 changed files with 203 additions and 291 deletions
Download patch file Download diff file Expand all files Collapse all files

3
include/SDL_compat.h
View file

@ -36,7 +36,7 @@ extern "C" {
/* *INDENT-ON* */
#endif
#define SDL_SWSURFACE 0x00000000
#define SDL_SWSURFACE 0x00000000 /* Not used */
#define SDL_ANYFORMAT 0x00100000
#define SDL_HWPALETTE 0x00200000
#define SDL_DOUBLEBUF 0x00400000
@ -44,6 +44,7 @@ extern "C" {
#define SDL_RESIZABLE 0x01000000
#define SDL_NOFRAME 0x02000000
#define SDL_OPENGL 0x04000000
#define SDL_HWSURFACE 0x08000001 /* Not used */
#define SDL_ASYNCBLIT 0x08000000 /* Not used */
#define SDL_HWACCEL 0x08000000 /* Not used */

30
include/SDL_video.h
View file

@ -204,8 +204,8 @@ typedef struct SDL_RendererInfo
*/
typedef enum
{
SDL_TEXTUREACCESS_LOCAL, /**< Lockable system memory */
SDL_TEXTUREACCESS_REMOTE /**< Unlockable video memory */
SDL_TEXTUREACCESS_STATIC, /**< Changes rarely, not lockable */
SDL_TEXTUREACCESS_STREAMING /**< Changes frequently, lockable */
} SDL_TextureAccess;
/**
@ -264,15 +264,14 @@ typedef void *SDL_GLContext;
/* These are the currently supported flags for the SDL_surface */
/* Used internally (read-only) */
#define SDL_HWSURFACE 0x00000001 /* Surface represents a texture */
#define SDL_PREALLOC 0x00000002 /* Surface uses preallocated memory */
#define SDL_PREALLOC 0x00000001 /* Surface uses preallocated memory */
#define SDL_SRCALPHA 0x00000004 /* Blit uses source alpha blending */
#define SDL_SRCCOLORKEY 0x00000008 /* Blit uses a source color key */
#define SDL_RLEACCELOK 0x00000010 /* Private flag */
#define SDL_RLEACCEL 0x00000020 /* Surface is RLE encoded */
/* Evaluates to true if the surface needs to be locked before access */
#define SDL_MUSTLOCK(S) (((S)->flags & (SDL_HWSURFACE|SDL_RLEACCEL)) != 0)
#define SDL_MUSTLOCK(S) (((S)->flags & SDL_RLEACCEL) != 0)
/* This structure should be treated as read-only, except for 'pixels',
which, if not NULL, contains the raw pixel data for the surface.
@ -288,9 +287,6 @@ typedef struct SDL_Surface
/* Application data associated with the surfade */
void *userdata; /* Read-write */
/* texture associated with the surface, if any */
SDL_TextureID textureID; /* Read-only */
/* information needed for surfaces requiring locks */
int locked; /* Read-only */
void *lock_data; /* Read-only */
@ -927,12 +923,11 @@ extern DECLSPEC SDL_TextureID SDLCALL SDL_CreateTexture(Uint32 format,
int h);
/**
* \fn SDL_TextureID SDL_CreateTextureFromSurface(Uint32 format, int access, SDL_Surface *surface)
* \fn SDL_TextureID SDL_CreateTextureFromSurface(Uint32 format, SDL_Surface *surface)
*
* \brief Create a texture from an existing surface.
*
* \param format The format of the texture, or 0 to pick an appropriate format
* \param access One of the enumerated values in SDL_TextureAccess
* \param surface The surface containing pixel data used to fill the texture
*
* \return The created texture is returned, or 0 if no rendering context was active, the format was unsupported, or the surface width or height were out of range.
@ -944,7 +939,6 @@ extern DECLSPEC SDL_TextureID SDLCALL SDL_CreateTexture(Uint32 format,
*/
extern DECLSPEC SDL_TextureID SDLCALL SDL_CreateTextureFromSurface(Uint32
format,
int access,
SDL_Surface
* surface);
@ -970,7 +964,7 @@ extern DECLSPEC int SDLCALL SDL_QueryTexture(SDL_TextureID textureID,
*
* \brief Query the pixels of a texture, if the texture does not need to be locked for pixel access.
*
* \param texture A texture to be queried, which was created with SDL_TEXTUREACCESS_LOCAL
* \param texture A texture to be queried, which was created with SDL_TEXTUREACCESS_STREAMING
* \param pixels A pointer filled with a pointer to the pixels for the texture
* \param pitch A pointer filled in with the pitch of the pixel data
*
@ -1155,7 +1149,7 @@ extern DECLSPEC int SDLCALL SDL_GetTextureScaleMode(SDL_TextureID textureID,
*
* \return 0 on success, or -1 if the texture is not valid
*
* \note This is a very slow function for textures not created with SDL_TEXTUREACCESS_LOCAL.
* \note This is a fairly slow function.
*/
extern DECLSPEC int SDLCALL SDL_UpdateTexture(SDL_TextureID textureID,
const SDL_Rect * rect,
@ -1166,13 +1160,13 @@ extern DECLSPEC int SDLCALL SDL_UpdateTexture(SDL_TextureID textureID,
*
* \brief Lock a portion of the texture for pixel access.
*
* \param texture The texture to lock for access, which must have been created with SDL_TEXTUREACCESS_LOCAL.
* \param textureID The texture to lock for access, which was created with SDL_TEXTUREACCESS_STREAMING.
* \param rect A pointer to the rectangle to lock for access. If the rect is NULL, the entire texture will be locked.
* \param markDirty If this is nonzero, the locked area will be marked dirty when the texture is unlocked.
* \param pixels This is filled in with a pointer to the locked pixels, appropriately offset by the locked area.
* \param pitch This is filled in with the pitch of the locked pixels.
*
* \return 0 on success, or -1 if the texture is not valid or was created with SDL_TEXTUREACCESS_REMOTe
* \return 0 on success, or -1 if the texture is not valid or was created with SDL_TEXTUREACCESS_STATIC
*
* \sa SDL_DirtyTexture()
* \sa SDL_UnlockTexture()
@ -1197,7 +1191,9 @@ extern DECLSPEC void SDLCALL SDL_UnlockTexture(SDL_TextureID textureID);
*
* \brief Mark the specified rectangles of the texture as dirty.
*
* \note The texture must have been created with SDL_TEXTUREACCESS_LOCAL.
* \param textureID The texture to mark dirty, which was created with SDL_TEXTUREACCESS_STREAMING.
* \param numrects The number of rectangles pointed to by rects.
* \param rects The pointer to an array of dirty rectangles.
*
* \sa SDL_LockTexture()
* \sa SDL_UnlockTexture()
@ -1347,8 +1343,6 @@ extern DECLSPEC SDL_Surface *SDLCALL SDL_CreateRGBSurfaceFrom(void *pixels,
Uint32 Gmask,
Uint32 Bmask,
Uint32 Amask);
extern DECLSPEC SDL_Surface *SDLCALL
SDL_CreateRGBSurfaceFromTexture(SDL_TextureID textureID);
extern DECLSPEC void SDLCALL SDL_FreeSurface(SDL_Surface * surface);
/**

86
src/SDL_compat.c
View file

@ -328,6 +328,38 @@ GetEnvironmentWindowPosition(int w, int h, int *x, int *y)
}
}
static SDL_Surface *
CreateVideoSurface(SDL_TextureID textureID)
{
SDL_Surface *surface;
Uint32 format;
int w, h;
int bpp;
Uint32 Rmask, Gmask, Bmask, Amask;
void *pixels;
int pitch;
if (SDL_QueryTexture(textureID, &format, NULL, &w, &h) < 0) {
return NULL;
}
if (!SDL_PixelFormatEnumToMasks
(format, &bpp, &Rmask, &Gmask, &Bmask, &Amask)) {
SDL_SetError("Unknown texture format");
return NULL;
}
if (SDL_QueryTexturePixels(textureID, &pixels, &pitch) == 0) {
surface =
SDL_CreateRGBSurfaceFrom(pixels, w, h, bpp, pitch, Rmask, Gmask,
Bmask, Amask);
} else {
surface =
SDL_CreateRGBSurface(0, w, h, bpp, Rmask, Gmask, Bmask, Amask);
}
return surface;
}
SDL_Surface *
SDL_SetVideoMode(int width, int height, int bpp, Uint32 flags)
{
@ -483,23 +515,23 @@ SDL_SetVideoMode(int width, int height, int bpp, Uint32 flags)
SDL_RENDERER_SINGLEBUFFER | SDL_RENDERER_PRESENTDISCARD) < 0) {
return NULL;
}
SDL_GetRenderDriverInfo(-1, &SDL_VideoRendererInfo);
SDL_GetRendererInfo(&SDL_VideoRendererInfo);
/* Create a texture for the screen surface */
SDL_VideoTexture =
SDL_CreateTexture(desired_format, SDL_TEXTUREACCESS_LOCAL, width,
SDL_CreateTexture(desired_format, SDL_TEXTUREACCESS_STREAMING, width,
height);
if (!SDL_VideoTexture) {
SDL_VideoTexture =
SDL_CreateTexture(SDL_PIXELFORMAT_RGB888, SDL_TEXTUREACCESS_LOCAL,
width, height);
SDL_CreateTexture(SDL_PIXELFORMAT_RGB888,
SDL_TEXTUREACCESS_STREAMING, width, height);
}
if (!SDL_VideoTexture) {
return NULL;
}
/* Create the screen surface */
SDL_VideoSurface = SDL_CreateRGBSurfaceFromTexture(SDL_VideoTexture);
SDL_VideoSurface = CreateVideoSurface(SDL_VideoTexture);
if (!SDL_VideoSurface) {
return NULL;
}
@ -518,23 +550,10 @@ SDL_SetVideoMode(int width, int height, int bpp, Uint32 flags)
}
/* Create a shadow surface if necessary */
if (((bpp != SDL_VideoSurface->format->BitsPerPixel)
&& !(flags & SDL_ANYFORMAT))
|| ((SDL_VideoSurface->flags & SDL_HWSURFACE)
&& !(flags & SDL_HWSURFACE))) {
if ((bpp == SDL_VideoSurface->format->BitsPerPixel)
|| (flags & SDL_ANYFORMAT)) {
SDL_ShadowSurface =
SDL_CreateRGBSurface(0, width, height,
SDL_VideoSurface->format->BitsPerPixel,
SDL_VideoSurface->format->Rmask,
SDL_VideoSurface->format->Gmask,
SDL_VideoSurface->format->Bmask,
SDL_VideoSurface->format->Amask);
} else {
if ((bpp != SDL_VideoSurface->format->BitsPerPixel)
&& !(flags & SDL_ANYFORMAT)) {
SDL_ShadowSurface =
SDL_CreateRGBSurface(0, width, height, bpp, 0, 0, 0, 0);
}
if (!SDL_ShadowSurface) {
return NULL;
}
@ -638,8 +657,7 @@ SDL_DisplayFormatAlpha(SDL_Surface * surface)
break;
}
format = SDL_AllocFormat(32, rmask, gmask, bmask, amask);
flags = SDL_PublicSurface->flags & SDL_HWSURFACE;
flags |= surface->flags & (SDL_SRCALPHA | SDL_RLEACCELOK);
flags = surface->flags & (SDL_SRCALPHA | SDL_RLEACCELOK);
converted = SDL_ConvertSurface(surface, format, flags);
SDL_FreeFormat(format);
return converted;
@ -681,6 +699,22 @@ SDL_UpdateRects(SDL_Surface * screen, int numrects, SDL_Rect * rects)
screen = SDL_VideoSurface;
}
if (screen == SDL_VideoSurface) {
if (screen->flags & SDL_PREALLOC) {
/* The surface memory is maintained by the renderer */
SDL_DirtyTexture(SDL_VideoTexture, numrects, rects);
} else {
/* The surface memory needs to be copied to texture */
void *pixels;
int pitch = screen->pitch;
int psize = screen->format->BytesPerPixel;
for (i = 0; i < numrects; ++i) {
const SDL_Rect *rect = &rects[i];
void *pixels =
(Uint8 *) screen->pixels + rect->y * pitch +
rect->x * psize;
SDL_UpdateTexture(SDL_VideoTexture, rect, pixels, pitch);
}
}
if (SDL_VideoRendererInfo.flags & SDL_RENDERER_PRESENTCOPY) {
for (i = 0; i < numrects; ++i) {
SDL_RenderCopy(SDL_VideoTexture, &rects[i], &rects[i]);
@ -1174,8 +1208,7 @@ SDL_DrawCursor(SDL_Surface * screen)
if (SDL_MUSTLOCK(screen)) {
SDL_UnlockSurface(screen);
}
if ((screen->flags & SDL_SCREEN_SURFACE) &&
!(screen->flags & SDL_HWSURFACE)) {
if (screen->flags & SDL_SCREEN_SURFACE) {
SDL_VideoDevice *_this = SDL_GetVideoDevice();
SDL_Window *window;
SDL_Rect area;
@ -1263,8 +1296,7 @@ SDL_EraseCursor(SDL_Surface * screen)
if (SDL_MUSTLOCK(screen)) {
SDL_UnlockSurface(screen);
}
if ((screen->flags & SDL_SCREEN_SURFACE) &&
!(screen->flags & SDL_HWSURFACE)) {
if (screen->flags & SDL_SCREEN_SURFACE) {
SDL_VideoDevice *_this = SDL_GetVideoDevice();
SDL_Window *window;
SDL_Rect area;
@ -1385,7 +1417,7 @@ SDL_CreateYUVOverlay(int w, int h, Uint32 format, SDL_Surface * display)
}
overlay->hwdata->textureID =
SDL_CreateTexture(texture_format, SDL_TEXTUREACCESS_LOCAL, w, h);
SDL_CreateTexture(texture_format, SDL_TEXTUREACCESS_STREAMING, w, h);
if (!overlay->hwdata->textureID) {
SDL_FreeYUVOverlay(overlay);
return NULL;

7
src/video/SDL_RLEaccel.c
View file

@ -1618,7 +1618,7 @@ RLEAlphaSurface(SDL_Surface * surface)
#undef ADD_TRANSL_COUNTS
/* Now that we have it encoded, release the original pixels */
if (!(surface->flags & SDL_PREALLOC) && !(surface->flags & SDL_HWSURFACE)) {
if (!(surface->flags & SDL_PREALLOC)) {
SDL_free(surface->pixels);
surface->pixels = NULL;
}
@ -1783,7 +1783,7 @@ RLEColorkeySurface(SDL_Surface * surface)
#undef ADD_COUNTS
/* Now that we have it encoded, release the original pixels */
if (!(surface->flags & SDL_PREALLOC) && !(surface->flags & SDL_HWSURFACE)) {
if (!(surface->flags & SDL_PREALLOC)) {
SDL_free(surface->pixels);
surface->pixels = NULL;
}
@ -1934,8 +1934,7 @@ SDL_UnRLESurface(SDL_Surface * surface, int recode)
if ((surface->flags & SDL_RLEACCEL) == SDL_RLEACCEL) {
surface->flags &= ~SDL_RLEACCEL;
if (recode && !(surface->flags & SDL_PREALLOC)
&& !(surface->flags & SDL_HWSURFACE)) {
if (recode && !(surface->flags & SDL_PREALLOC)) {
if ((surface->flags & SDL_SRCCOLORKEY) == SDL_SRCCOLORKEY) {
SDL_Rect full;
unsigned alpha_flag;

34
src/video/SDL_renderer_gl.c
View file

@ -38,6 +38,9 @@ static SDL_Renderer *GL_CreateRenderer(SDL_Window * window, Uint32 flags);
static int GL_ActivateRenderer(SDL_Renderer * renderer);
static int GL_DisplayModeChanged(SDL_Renderer * renderer);
static int GL_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture);
static int GL_QueryTexturePixels(SDL_Renderer * renderer,
SDL_Texture * texture, void **pixels,
int *pitch);
static int GL_SetTexturePalette(SDL_Renderer * renderer,
SDL_Texture * texture,
const SDL_Color * colors, int firstcolor,
@ -245,6 +248,7 @@ GL_CreateRenderer(SDL_Window * window, Uint32 flags)
renderer->ActivateRenderer = GL_ActivateRenderer;
renderer->DisplayModeChanged = GL_DisplayModeChanged;
renderer->CreateTexture = GL_CreateTexture;
renderer->QueryTexturePixels = GL_QueryTexturePixels;
renderer->SetTexturePalette = GL_SetTexturePalette;
renderer->GetTexturePalette = GL_GetTexturePalette;
renderer->SetTextureColorMod = GL_SetTextureColorMod;
@ -492,6 +496,16 @@ GL_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
SDL_memset(data->palette, 0xFF, 3 * 256 * sizeof(Uint8));
}
if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
data->pitch = texture->w * SDL_BYTESPERPIXEL(texture->format);
data->pixels = SDL_malloc(texture->h * data->pitch);
if (!data->pixels) {
SDL_OutOfMemory();
SDL_free(data);
return -1;
}
}
texture->driverdata = data;
renderdata->glGetError();
@ -522,6 +536,17 @@ GL_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
return 0;
}
static int
GL_QueryTexturePixels(SDL_Renderer * renderer, SDL_Texture * texture,
void **pixels, int *pitch)
{
GL_TextureData *data = (GL_TextureData *) texture->driverdata;
*pixels = data->pixels;
*pitch = data->pitch;
return 0;
}
static int
GL_SetTexturePalette(SDL_Renderer * renderer, SDL_Texture * texture,
const SDL_Color * colors, int firstcolor, int ncolors)
@ -661,15 +686,6 @@ GL_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
{
GL_TextureData *data = (GL_TextureData *) texture->driverdata;
if (!data->pixels) {
data->pitch = texture->w * SDL_BYTESPERPIXEL(texture->format);
data->pixels = SDL_malloc(texture->h * data->pitch);
if (!data->pixels) {
SDL_OutOfMemory();
return -1;
}
}
if (markDirty) {
SDL_AddDirtyRect(&data->dirty, rect);
}

2
src/video/SDL_renderer_sw.c
View file

@ -125,7 +125,7 @@ CreateTexture(SDL_Renderer * renderer, Uint32 format, int w, int h)
}
texture->format = format;
texture->access = SDL_TEXTUREACCESS_LOCAL;
texture->access = SDL_TEXTUREACCESS_STREAMING;
texture->w = w;
texture->h = h;
texture->renderer = renderer;

133
src/video/SDL_surface.c
View file

@ -170,62 +170,11 @@ SDL_CreateRGBSurfaceFrom(void *pixels,
return surface;
}
SDL_Surface *
SDL_CreateRGBSurfaceFromTexture(SDL_TextureID textureID)
{
SDL_Surface *surface;
Uint32 format;
int w, h;
int bpp;
Uint32 Rmask, Gmask, Bmask, Amask;
void *pixels;
int pitch;
if (SDL_QueryTexture(textureID, &format, NULL, &w, &h) < 0) {
return NULL;
}
if (!SDL_PixelFormatEnumToMasks
(format, &bpp, &Rmask, &Gmask, &Bmask, &Amask)) {
SDL_SetError("Unknown texture format");
return NULL;
}
if (SDL_QueryTexturePixels(textureID, &pixels, &pitch) == 0) {
surface =
SDL_CreateRGBSurfaceFrom(pixels, w, h, bpp, pitch, Rmask, Gmask,
Bmask, Amask);
} else {
surface =
SDL_CreateRGBSurface(0, 0, 0, bpp, Rmask, Gmask, Bmask, Amask);
if (surface) {
surface->flags |= SDL_HWSURFACE;
surface->w = w;
surface->h = h;
surface->pitch = SDL_CalculatePitch(surface);
SDL_SetClipRect(surface, NULL);
}
}
if (surface) {
surface->textureID = textureID;
}
return surface;
}
static int
SDL_SurfacePaletteChanged(void *userdata, SDL_Palette * palette)
{
SDL_Surface *surface = (SDL_Surface *) userdata;
if (surface->textureID) {
if (SDL_SetTexturePalette
(surface->textureID, palette->colors, 0, palette->ncolors) < 0) {
SDL_GetTexturePalette(surface->textureID, palette->colors, 0,
palette->ncolors);
return -1;
}
}
SDL_FormatChanged(surface);
return 0;
@ -627,76 +576,11 @@ SDL_FillRect(SDL_Surface * dst, SDL_Rect * dstrect, Uint32 color)
row += dst->pitch;
}
} else {
#ifdef __powerpc__
/*
* SDL_memset() on PPC (both glibc and codewarrior) uses
* the dcbz (Data Cache Block Zero) instruction, which
* causes an alignment exception if the destination is
* uncachable, so only use it on software surfaces
*/
if (dst->flags & SDL_HWSURFACE) {
if (dstrect->w >= 8) {
/*
* 64-bit stores are probably most
* efficient to uncached video memory
*/
double fill;
SDL_memset(&fill, color, (sizeof fill));
for (y = dstrect->h; y; y--) {
Uint8 *d = row;
unsigned n = x;
unsigned nn;
Uint8 c = color;
double f = fill;
while ((unsigned long) d & (sizeof(double) - 1)) {
*d++ = c;
n--;
}
nn = n / (sizeof(double) * 4);
while (nn) {
((double *) d)[0] = f;
((double *) d)[1] = f;
((double *) d)[2] = f;
((double *) d)[3] = f;
d += 4 * sizeof(double);
nn--;
}
n &= ~(sizeof(double) * 4 - 1);
nn = n / sizeof(double);
while (nn) {
*(double *) d = f;
d += sizeof(double);
nn--;
}
n &= ~(sizeof(double) - 1);
while (n) {
*d++ = c;
n--;
}
row += dst->pitch;
}
} else {
/* narrow boxes */
for (y = dstrect->h; y; y--) {
Uint8 *d = row;
Uint8 c = color;
int n = x;
while (n) {
*d++ = c;
n--;
}
row += dst->pitch;
}
}
} else
#endif /* __powerpc__ */
{
for (y = dstrect->h; y; y--) {
SDL_memset(row, color, x);
row += dst->pitch;
}
}
}
} else {
switch (dst->format->BytesPerPixel) {
case 2:
@ -753,13 +637,6 @@ SDL_LockSurface(SDL_Surface * surface)
{
if (!surface->locked) {
/* Perform the lock */
if (surface->flags & SDL_HWSURFACE) {
if (SDL_LockTexture
(surface->textureID, NULL, 1, &surface->pixels,
&surface->pitch) < 0) {
return (-1);
}
}
if (surface->flags & SDL_RLEACCEL) {
SDL_UnRLESurface(surface, 1);
surface->flags |= SDL_RLEACCEL; /* save accel'd state */
@ -784,11 +661,6 @@ SDL_UnlockSurface(SDL_Surface * surface)
return;
}
/* Unlock hardware or accelerated surfaces */
if (surface->flags & SDL_HWSURFACE) {
SDL_UnlockTexture(surface->textureID);
}
/* Update RLE encoded surface with new data */
if ((surface->flags & SDL_RLEACCEL) == SDL_RLEACCEL) {
surface->flags &= ~SDL_RLEACCEL; /* stop lying */
@ -928,11 +800,6 @@ SDL_FreeSurface(SDL_Surface * surface)
SDL_FreeBlitMap(surface->map);
surface->map = NULL;
}
/* Should we destroy the texture too?
if (surface->textureID) {
SDL_DestroyTexture(surface->textureID);
}
*/
if (surface->pixels && ((surface->flags & SDL_PREALLOC) != SDL_PREALLOC)) {
SDL_free(surface->pixels);
}

47
src/video/SDL_video.c
View file

@ -1532,14 +1532,11 @@ SDL_CreateTexture(Uint32 format, int access, int w, int h)
}
SDL_TextureID
SDL_CreateTextureFromSurface(Uint32 format, int access, SDL_Surface * surface)
SDL_CreateTextureFromSurface(Uint32 format, SDL_Surface * surface)
{
SDL_TextureID textureID;
Uint32 surface_flags = surface->flags;
SDL_PixelFormat *fmt = surface->format;
Uint8 alpha;
SDL_Rect bounds;
SDL_Surface dst;
int bpp;
Uint32 Rmask, Gmask, Bmask, Amask;
@ -1576,11 +1573,32 @@ SDL_CreateTextureFromSurface(Uint32 format, int access, SDL_Surface * surface)
}
}
textureID = SDL_CreateTexture(format, access, surface->w, surface->h);
textureID =
SDL_CreateTexture(format, SDL_TEXTUREACCESS_STATIC, surface->w,
surface->h);
if (!textureID) {
return 0;
}
if (bpp == fmt->BitsPerPixel && Rmask == fmt->Rmask && Gmask == fmt->Gmask
&& Bmask == fmt->Bmask && Amask == fmt->Amask) {
if (SDL_MUSTLOCK(surface)) {
if (SDL_LockSurface(surface) < 0) {
SDL_DestroyTexture(textureID);
return 0;
}
SDL_UpdateTexture(textureID, NULL, surface->pixels,
surface->pitch);
SDL_UnlockSurface(surface);
} else {
SDL_UpdateTexture(textureID, NULL, surface->pixels,
surface->pitch);
}
} else {
Uint8 alpha;
SDL_Rect bounds;
SDL_Surface dst;
/* Set up a destination surface for the texture update */
SDL_zero(dst);
dst.format = SDL_AllocFormat(bpp, Rmask, Gmask, Bmask, Amask);
@ -1590,9 +1608,6 @@ SDL_CreateTextureFromSurface(Uint32 format, int access, SDL_Surface * surface)
}
dst.w = surface->w;
dst.h = surface->h;
if (SDL_LockTexture(textureID, NULL, 1, &dst.pixels, &dst.pitch) == 0) {
dst.flags |= SDL_PREALLOC;
} else {
dst.pitch = SDL_CalculatePitch(&dst);
dst.pixels = SDL_malloc(dst.h * dst.pitch);
if (!dst.pixels) {
@ -1601,7 +1616,6 @@ SDL_CreateTextureFromSurface(Uint32 format, int access, SDL_Surface * surface)
SDL_OutOfMemory();
return 0;
}
}
/* Copy the palette if any */
if (SDL_ISPIXELFORMAT_INDEXED(format)) {
@ -1664,13 +1678,10 @@ SDL_CreateTextureFromSurface(Uint32 format, int access, SDL_Surface * surface)
}
/* Update the texture */
if (dst.flags & SDL_PREALLOC) {
SDL_UnlockTexture(textureID);
} else {
SDL_UpdateTexture(textureID, NULL, dst.pixels, dst.pitch);
SDL_free(dst.pixels);
}
SDL_FreeFormat(dst.format);
}
return textureID;
}
@ -1967,6 +1978,10 @@ SDL_LockTexture(SDL_TextureID textureID, const SDL_Rect * rect, int markDirty,
if (!texture) {
return -1;
}
if (texture->access != SDL_TEXTUREACCESS_STREAMING) {
SDL_SetError("SDL_LockTexture(): texture must be streaming");
return -1;
}
renderer = texture->renderer;
if (!renderer->LockTexture) {
@ -1994,6 +2009,9 @@ SDL_UnlockTexture(SDL_TextureID textureID)
if (!texture) {
return;
}
if (texture->access != SDL_TEXTUREACCESS_STREAMING) {
return;
}
renderer = texture->renderer;
if (!renderer->UnlockTexture) {
@ -2012,6 +2030,9 @@ SDL_DirtyTexture(SDL_TextureID textureID, int numrects,
if (!texture) {
return;
}
if (texture->access != SDL_TEXTUREACCESS_STREAMING) {
return;
}
renderer = texture->renderer;
if (!renderer->DirtyTexture) {

19
src/video/win32/SDL_d3drender.c
View file

@ -459,7 +459,6 @@ D3D_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
SDL_Window *window = SDL_GetWindowFromID(renderer->window);
SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
D3D_TextureData *data;
D3DPOOL pool;
HRESULT result;
data = (D3D_TextureData *) SDL_calloc(1, sizeof(*data));
@ -470,22 +469,11 @@ D3D_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
texture->driverdata = data;
#if 1
/* FIXME: Do we want non-managed textures?
They need to be freed on device reset and then reloaded by the app...
*/
texture->access = SDL_TEXTUREACCESS_LOCAL;
#endif
if (texture->access == SDL_TEXTUREACCESS_LOCAL) {
pool = D3DPOOL_MANAGED;
} else {
pool = D3DPOOL_DEFAULT;
}
result =
IDirect3DDevice9_CreateTexture(renderdata->device, texture->w,
texture->h, 1, 0,
PixelFormatToD3DFMT(texture->format),
pool, &data->texture, NULL);
D3DPOOL_MANAGED, &data->texture, NULL);
if (FAILED(result)) {
D3D_SetError("CreateTexture()", result);
return -1;
@ -628,11 +616,6 @@ D3D_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,
D3DLOCKED_RECT locked;
HRESULT result;
if (texture->access != SDL_TEXTUREACCESS_LOCAL) {
SDL_SetError("Can't lock remote video memory");
return -1;
}
d3drect.left = rect->x;
d3drect.right = rect->x + rect->w;
d3drect.top = rect->y;

2
src/video/win32/SDL_gdirender.c
View file

@ -304,7 +304,7 @@ GDI_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
}
data->pitch = (texture->w * SDL_BYTESPERPIXEL(data->format));
if (data->yuv || texture->access == SDL_TEXTUREACCESS_LOCAL
if (data->yuv || texture->access == SDL_TEXTUREACCESS_STREAMING
|| texture->format != display->current_mode.format) {
int bmi_size;
LPBITMAPINFO bmi;

3
test/testsprite2.c
View file

@ -63,8 +63,7 @@ LoadSprite(char *file)
/* Create textures from the image */
for (i = 0; i < state->num_windows; ++i) {
SDL_SelectRenderer(state->windows[i]);
sprites[i] =
SDL_CreateTextureFromSurface(0, SDL_TEXTUREACCESS_REMOTE, temp);
sprites[i] = SDL_CreateTextureFromSurface(0, temp);
if (!sprites[i]) {
fprintf(stderr, "Couldn't create texture: %s\n", SDL_GetError());
SDL_FreeSurface(temp);