Streamlined the API a bit and optimized the software renderer.

--HG--
extra : convert_revision : svn%3Ac70aab31-4412-0410-b14c-859654838e24/trunk%401952

include/SDL_video.h

@@ -176,9 +176,7 @@ typedef enum
     SDL_Renderer_PresentFlip3 = 0x00000008,     /**< Present uses a flip, rotating between two back buffers and a front buffer */
     SDL_Renderer_PresentDiscard = 0x00000010,   /**< Present leaves the contents of the backbuffer undefined */
     SDL_Renderer_PresentVSync = 0x00000020,     /**< Present is synchronized with the refresh rate */
-    SDL_Renderer_RenderTarget = 0x00000040,     /**< The renderer can create texture render targets */
+    SDL_Renderer_Accelerated = 0x00000040,      /**< The renderer uses hardware acceleration */
-    SDL_Renderer_Accelerated = 0x00000080,      /**< The renderer uses hardware acceleration */
-    SDL_Renderer_Minimal = 0x00000100,          /**< The renderer only supports the read/write pixel and present functions */
 } SDL_RendererFlags;
 
 /**
@@ -193,7 +191,7 @@ typedef struct SDL_RendererInfo
     Uint32 blend_modes;         /**< A mask of supported blend modes */
     Uint32 scale_modes;         /**< A mask of supported scale modes */
     Uint32 num_texture_formats; /**< The number of available texture formats */
-    Uint32 texture_formats[32]; /**< The available texture formats */
+    Uint32 texture_formats[16]; /**< The available texture formats */
     int max_texture_width;      /**< The maximimum texture width */
     int max_texture_height;     /**< The maximimum texture height */
 } SDL_RendererInfo;
@@ -205,9 +203,8 @@ typedef struct SDL_RendererInfo
  */
 typedef enum
 {
-    SDL_TextureAccess_Render,   /**< Unlockable video memory, rendering allowed */
-    SDL_TextureAccess_Remote,   /**< Unlockable video memory */
     SDL_TextureAccess_Local,    /**< Lockable system memory */
+    SDL_TextureAccess_Remote,   /**< Unlockable video memory */
 } SDL_TextureAccess;
 
 /**
@@ -836,11 +833,16 @@ extern DECLSPEC void SDLCALL SDL_DestroyWindow(SDL_WindowID windowID);
 extern DECLSPEC int SDLCALL SDL_GetNumRenderers(void);
 
 /**
- * \fn SDL_RendererInfo *SDL_GetRendererInfo(int index)
+ * \fn int SDL_GetRendererInfo(int index, SDL_RendererInfo *info)
  *
  * \brief Get information about a specific render manager on the current
  *        display.
  *
+ * \param index The index to query information about, or -1 to query the currently renderer
+ * \param info A pointer to an SDL_RendererInfo struct to be filled with information on the renderer
+ *
+ * \return 0 on success, -1 if the index was out of range
+ *
  * \sa SDL_CreateRenderer()
  */
 extern DECLSPEC int SDLCALL SDL_GetRendererInfo(int index,

src/SDL_compat.c

@@ -31,6 +31,7 @@
 
 
 static SDL_WindowID SDL_VideoWindow;
+static SDL_RendererInfo SDL_VideoRendererInfo;
 static SDL_TextureID SDL_VideoTexture;
 static SDL_Surface *SDL_VideoSurface;
 static SDL_Surface *SDL_ShadowSurface;
@@ -442,10 +443,12 @@ SDL_SetVideoMode(int width, int height, int bpp, Uint32 flags)
     }
 
     /* Create a renderer for the window */
-    if (SDL_CreateRenderer(SDL_VideoWindow, -1, SDL_Renderer_SingleBuffer) <
+    if (SDL_CreateRenderer
-        0) {
+        (SDL_VideoWindow, -1,
+         SDL_Renderer_SingleBuffer | SDL_Renderer_PresentDiscard) < 0) {
         return NULL;
     }
+    SDL_GetRendererInfo(-1, &SDL_VideoRendererInfo);
 
     /* Create a texture for the screen surface */
     SDL_VideoTexture =
@@ -642,8 +645,19 @@ SDL_UpdateRects(SDL_Surface * screen, int numrects, SDL_Rect * rects)
         screen = SDL_VideoSurface;
     }
     if (screen == SDL_VideoSurface) {
-        for (i = 0; i < numrects; ++i) {
+        if (SDL_VideoRendererInfo.flags & SDL_Renderer_PresentCopy) {
-            SDL_RenderCopy(SDL_VideoTexture, &rects[i], &rects[i],
+            for (i = 0; i < numrects; ++i) {
+                SDL_RenderCopy(SDL_VideoTexture, &rects[i], &rects[i],
+                               SDL_TextureBlendMode_None,
+                               SDL_TextureScaleMode_None);
+            }
+        } else {
+            SDL_Rect rect;
+            rect.x = 0;
+            rect.y = 0;
+            rect.w = screen->w;
+            rect.h = screen->h;
+            SDL_RenderCopy(SDL_VideoTexture, &rect, &rect,
                            SDL_TextureBlendMode_None,
                            SDL_TextureScaleMode_None);
         }

src/video/SDL_renderer_sw.c

@@ -23,6 +23,7 @@
 
 #include "SDL_video.h"
 #include "SDL_sysvideo.h"
+#include "SDL_pixels_c.h"
 #include "SDL_rect_c.h"
 #include "SDL_yuv_sw_c.h"
 
@@ -53,20 +54,12 @@ static void SDL_SW_UnlockTexture(SDL_Renderer * renderer,
 static void SDL_SW_DirtyTexture(SDL_Renderer * renderer,
                                 SDL_Texture * texture, int numrects,
                                 const SDL_Rect * rects);
-static void SDL_SW_SelectRenderTexture(SDL_Renderer * renderer,
-                                       SDL_Texture * texture);
 static int SDL_SW_RenderFill(SDL_Renderer * renderer, const SDL_Rect * rect,
                              Uint32 color);
 static int SDL_SW_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
                              const SDL_Rect * srcrect,
                              const SDL_Rect * dstrect, int blendMode,
                              int scaleMode);
-static int SDL_SW_RenderReadPixels(SDL_Renderer * renderer,
-                                   const SDL_Rect * rect, void *pixels,
-                                   int pitch);
-static int SDL_SW_RenderWritePixels(SDL_Renderer * renderer,
-                                    const SDL_Rect * rect, const void *pixels,
-                                    int pitch);
 static void SDL_SW_RenderPresent(SDL_Renderer * renderer);
 static void SDL_SW_DestroyTexture(SDL_Renderer * renderer,
                                   SDL_Texture * texture);
@@ -79,7 +72,7 @@ SDL_RenderDriver SDL_SW_RenderDriver = {
      "software",
      (SDL_Renderer_SingleBuffer | SDL_Renderer_PresentCopy |
       SDL_Renderer_PresentFlip2 | SDL_Renderer_PresentFlip3 |
-      SDL_Renderer_PresentDiscard | SDL_Renderer_RenderTarget),
+      SDL_Renderer_PresentDiscard | SDL_Renderer_PresentVSync),
      (SDL_TextureBlendMode_None | SDL_TextureBlendMode_Mask |
       SDL_TextureBlendMode_Blend),
      (SDL_TextureScaleMode_None | SDL_TextureScaleMode_Fast),
@@ -102,14 +95,63 @@ SDL_RenderDriver SDL_SW_RenderDriver = {
 
 typedef struct
 {
-    int current_screen;
+    Uint32 format;
-    SDL_Surface *screens[3];
+    int current_texture;
-    SDL_Surface *target;
+    SDL_Texture *texture[3];
+    SDL_Surface surface;
     SDL_Renderer *renderer;
     SDL_DirtyRectList dirty;
-    SDL_bool makedirty;
 } SDL_SW_RenderData;
 
+static SDL_Texture *
+CreateTexture(SDL_Renderer * renderer, Uint32 format, int w, int h)
+{
+    SDL_Texture *texture;
+
+    texture = (SDL_Texture *) SDL_malloc(sizeof(*texture));
+    if (!texture) {
+        SDL_OutOfMemory();
+        return NULL;
+    }
+
+    SDL_zerop(texture);
+    texture->format = format;
+    texture->access = SDL_TextureAccess_Local;
+    texture->w = w;
+    texture->h = h;
+    texture->renderer = renderer;
+
+    if (renderer->CreateTexture(renderer, texture) < 0) {
+        SDL_free(texture);
+        return NULL;
+    }
+    return texture;
+}
+
+static void
+DestroyTexture(SDL_Renderer * renderer, SDL_Texture * texture)
+{
+    renderer->DestroyTexture(renderer, texture);
+    SDL_free(texture);
+}
+
+static int
+DisplayPaletteChanged(void *userdata, SDL_Palette * palette)
+{
+    SDL_SW_RenderData *data = (SDL_SW_RenderData *) userdata;
+    int i;
+
+    for (i = 0; i < SDL_arraysize(data->texture); ++i) {
+        if (data->texture[i] && data->renderer->SetTexturePalette) {
+            data->renderer->SetTexturePalette(data->renderer,
+                                              data->texture[i],
+                                              palette->colors, 0,
+                                              palette->ncolors);
+        }
+    }
+    return 0;
+}
+
 SDL_Renderer *
 SDL_SW_CreateRenderer(SDL_Window * window, Uint32 flags)
 {
@@ -120,6 +162,7 @@ SDL_SW_CreateRenderer(SDL_Window * window, Uint32 flags)
     int i, n;
     int bpp;
     Uint32 Rmask, Gmask, Bmask, Amask;
+    Uint32 renderer_flags;
 
     if (!SDL_PixelFormatEnumToMasks
         (displayMode->format, &bpp, &Rmask, &Gmask, &Bmask, &Amask)) {
@@ -149,11 +192,8 @@ SDL_SW_CreateRenderer(SDL_Window * window, Uint32 flags)
     renderer->LockTexture = SDL_SW_LockTexture;
     renderer->UnlockTexture = SDL_SW_UnlockTexture;
     renderer->DirtyTexture = SDL_SW_DirtyTexture;
-    renderer->SelectRenderTexture = SDL_SW_SelectRenderTexture;
     renderer->RenderFill = SDL_SW_RenderFill;
     renderer->RenderCopy = SDL_SW_RenderCopy;
-    renderer->RenderReadPixels = SDL_SW_RenderReadPixels;
-    renderer->RenderWritePixels = SDL_SW_RenderWritePixels;
     renderer->RenderPresent = SDL_SW_RenderPresent;
     renderer->DestroyTexture = SDL_SW_DestroyTexture;
     renderer->DestroyRenderer = SDL_SW_DestroyRenderer;
@@ -161,7 +201,7 @@ SDL_SW_CreateRenderer(SDL_Window * window, Uint32 flags)
     renderer->window = window->id;
     renderer->driverdata = data;
 
-    renderer->info.flags = SDL_Renderer_RenderTarget;
+    renderer->info.flags = 0;
 
     if (flags & SDL_Renderer_PresentFlip2) {
         renderer->info.flags |= SDL_Renderer_PresentFlip2;
@@ -173,28 +213,18 @@ SDL_SW_CreateRenderer(SDL_Window * window, Uint32 flags)
         renderer->info.flags |= SDL_Renderer_PresentCopy;
         n = 1;
     }
-    for (i = 0; i < n; ++i) {
+    data->format = displayMode->format;
-        data->screens[i] =
-            SDL_CreateRGBSurface(0, window->w, window->h, bpp, Rmask, Gmask,
-                                 Bmask, Amask);
-        if (!data->screens[i]) {
-            SDL_SW_DestroyRenderer(renderer);
-            return NULL;
-        }
-        SDL_SetSurfacePalette(data->screens[i], display->palette);
-    }
-    data->current_screen = 0;
-    data->target = data->screens[0];
-    data->makedirty = SDL_TRUE;
 
     /* Find a render driver that we can use to display data */
+    renderer_flags = (SDL_Renderer_SingleBuffer |
+                      SDL_Renderer_PresentDiscard);
+    if (flags & SDL_Renderer_PresentVSync) {
+        renderer_flags |= SDL_Renderer_PresentVSync;
+    }
     for (i = 0; i < display->num_render_drivers; ++i) {
         SDL_RenderDriver *driver = &display->render_drivers[i];
         if (driver->info.name != SDL_SW_RenderDriver.info.name) {
-            data->renderer =
+            data->renderer = driver->CreateRenderer(window, renderer_flags);
-                driver->CreateRenderer(window,
-                                       (SDL_Renderer_SingleBuffer |
-                                        SDL_Renderer_PresentDiscard));
             if (data->renderer) {
                 break;
             }
@@ -205,6 +235,35 @@ SDL_SW_CreateRenderer(SDL_Window * window, Uint32 flags)
         SDL_SetError("Couldn't find display render driver");
         return NULL;
     }
+    if (data->renderer->info.flags & SDL_Renderer_PresentVSync) {
+        renderer->info.flags |= SDL_Renderer_PresentVSync;
+    }
+
+    /* Create the textures we'll use for display */
+    for (i = 0; i < n; ++i) {
+        data->texture[i] =
+            CreateTexture(data->renderer, data->format, window->w, window->h);
+        if (!data->texture[i]) {
+            SDL_SW_DestroyRenderer(renderer);
+            return NULL;
+        }
+    }
+    data->current_texture = 0;
+
+    /* Create a surface we'll use for rendering */
+    data->surface.flags = SDL_PREALLOC;
+    data->surface.format = SDL_AllocFormat(bpp, Rmask, Gmask, Bmask, Amask);
+    if (!data->surface.format) {
+        SDL_SW_DestroyRenderer(renderer);
+        return NULL;
+    }
+    SDL_SetSurfacePalette(&data->surface, display->palette);
+
+    /* Set up a palette watch on the display palette */
+    if (display->palette) {
+        SDL_AddPaletteWatch(display->palette, DisplayPaletteChanged, data);
+    }
+
     return renderer;
 }
 
@@ -212,10 +271,6 @@ static int
 SDL_SW_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
 {
     if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
-        if (texture->access == SDL_TextureAccess_Render) {
-            SDL_SetError("Rendering to YUV format textures is not supported");
-            return -1;
-        }
         texture->driverdata = SDL_SW_CreateYUVTexture(texture);
     } else {
         int bpp;
@@ -347,29 +402,18 @@ SDL_SW_DirtyTexture(SDL_Renderer * renderer, SDL_Texture * texture,
 {
 }
 
-static void
-SDL_SW_SelectRenderTexture(SDL_Renderer * renderer, SDL_Texture * texture)
-{
-    SDL_SW_RenderData *data = (SDL_SW_RenderData *) renderer->driverdata;
-
-    if (texture) {
-        data->target = (SDL_Surface *) texture->driverdata;
-        data->makedirty = SDL_FALSE;
-    } else {
-        data->target = data->screens[data->current_screen];
-        data->makedirty = SDL_TRUE;
-    }
-}
-
 static int
 SDL_SW_RenderFill(SDL_Renderer * renderer, const SDL_Rect * rect,
                   Uint32 color)
 {
     SDL_SW_RenderData *data = (SDL_SW_RenderData *) renderer->driverdata;
-    SDL_Rect real_rect = *rect;
     Uint8 r, g, b, a;
+    void *pixels;
+    int pitch;
+    SDL_Rect real_rect;
+    int status;
 
-    if (data->makedirty) {
+    if (data->renderer->info.flags & SDL_Renderer_PresentCopy) {
         SDL_AddDirtyRect(&data->dirty, rect);
     }
 
@@ -377,9 +421,25 @@ SDL_SW_RenderFill(SDL_Renderer * renderer, const SDL_Rect * rect,
     r = (Uint8) ((color >> 16) & 0xFF);
     g = (Uint8) ((color >> 8) & 0xFF);
     b = (Uint8) (color & 0xFF);
-    color = SDL_MapRGBA(data->target->format, r, g, b, a);
+    color = SDL_MapRGBA(data->surface.format, r, g, b, a);
 
-    return SDL_FillRect(data->target, &real_rect, color);
+    if (data->renderer->
+        LockTexture(data->renderer, data->texture[data->current_texture],
+                    rect, 1, &data->surface.pixels,
+                    &data->surface.pitch) < 0) {
+        return -1;
+    }
+    data->surface.w = rect->w;
+    data->surface.h = rect->h;
+    data->surface.clip_rect.w = rect->w;
+    data->surface.clip_rect.h = rect->h;
+    real_rect = data->surface.clip_rect;
+
+    status = SDL_FillRect(&data->surface, &real_rect, color);
+
+    data->renderer->UnlockTexture(data->renderer,
+                                  data->texture[data->current_texture]);
+    return status;
 }
 
 static int
@@ -389,25 +449,34 @@ SDL_SW_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
 {
     SDL_SW_RenderData *data = (SDL_SW_RenderData *) renderer->driverdata;
     SDL_Window *window = SDL_GetWindowFromID(renderer->window);
-    SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
+    int status;
 
-    if (data->makedirty) {
+    if (data->renderer->info.flags & SDL_Renderer_PresentCopy) {
         SDL_AddDirtyRect(&data->dirty, dstrect);
     }
 
+    if (data->renderer->
+        LockTexture(data->renderer, data->texture[data->current_texture],
+                    dstrect, 1, &data->surface.pixels,
+                    &data->surface.pitch) < 0) {
+        return -1;
+    }
+
     if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
-        SDL_Surface *target = data->target;
+        status =
-        void *pixels =
+            SDL_SW_CopyYUVToRGB((SDL_SW_YUVTexture *) texture->driverdata,
-            (Uint8 *) target->pixels + dstrect->y * target->pitch +
+                                srcrect, data->format, dstrect->w, dstrect->h,
-            dstrect->x * target->format->BytesPerPixel;
+                                data->surface.pixels, data->surface.pitch);
-        return SDL_SW_CopyYUVToRGB((SDL_SW_YUVTexture *) texture->driverdata,
-                                   srcrect, display->current_mode.format,
-                                   dstrect->w, dstrect->h, pixels,
-                                   target->pitch);
     } else {
         SDL_Surface *surface = (SDL_Surface *) texture->driverdata;
         SDL_Rect real_srcrect = *srcrect;
-        SDL_Rect real_dstrect = *dstrect;
+        SDL_Rect real_dstrect;
+
+        data->surface.w = dstrect->w;
+        data->surface.h = dstrect->h;
+        data->surface.clip_rect.w = dstrect->w;
+        data->surface.clip_rect.h = dstrect->h;
+        real_dstrect = data->surface.clip_rect;
 
         if (blendMode &
             (SDL_TextureBlendMode_Mask | SDL_TextureBlendMode_Blend)) {
@@ -417,91 +486,53 @@ SDL_SW_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
         }
         if (scaleMode != SDL_TextureScaleMode_None &&
             (srcrect->w != dstrect->w || srcrect->h != dstrect->h)) {
-            return SDL_SoftStretch(surface, &real_srcrect, data->target,
+            status =
-                                   &real_dstrect);
+                SDL_SoftStretch(surface, &real_srcrect, &data->surface,
+                                &real_dstrect);
         } else {
-            return SDL_LowerBlit(surface, &real_srcrect, data->target,
+            status =
-                                 &real_dstrect);
+                SDL_LowerBlit(surface, &real_srcrect, &data->surface,
+                              &real_dstrect);
         }
     }
-}
+    data->renderer->UnlockTexture(data->renderer,
-
+                                  data->texture[data->current_texture]);
-static int
+    return status;
-SDL_SW_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
-                        void *pixels, int pitch)
-{
-    SDL_SW_RenderData *data = (SDL_SW_RenderData *) renderer->driverdata;
-    SDL_Surface *surface = data->target;
-    Uint8 *src, *dst;
-    int row;
-    size_t length;
-
-    src =
-        (Uint8 *) surface->pixels + rect->y * surface->pitch +
-        rect->x * surface->format->BytesPerPixel;
-    dst = (Uint8 *) pixels;
-    length = rect->w * surface->format->BytesPerPixel;
-    for (row = 0; row < rect->h; ++row) {
-        SDL_memcpy(dst, src, length);
-        src += surface->pitch;
-        dst += pitch;
-    }
-    return 0;
-}
-
-static int
-SDL_SW_RenderWritePixels(SDL_Renderer * renderer, const SDL_Rect * rect,
-                         const void *pixels, int pitch)
-{
-    SDL_SW_RenderData *data = (SDL_SW_RenderData *) renderer->driverdata;
-    SDL_Surface *surface = data->target;
-    Uint8 *src, *dst;
-    int row;
-    size_t length;
-
-    if (data->makedirty) {
-        SDL_AddDirtyRect(&data->dirty, rect);
-    }
-
-    src = (Uint8 *) pixels;
-    dst =
-        (Uint8 *) surface->pixels + rect->y * surface->pitch +
-        rect->x * surface->format->BytesPerPixel;
-    length = rect->w * surface->format->BytesPerPixel;
-    for (row = 0; row < rect->h; ++row) {
-        SDL_memcpy(dst, src, length);
-        src += pitch;
-        dst += surface->pitch;
-    }
-    return 0;
 }
 
 static void
 SDL_SW_RenderPresent(SDL_Renderer * renderer)
 {
     SDL_SW_RenderData *data = (SDL_SW_RenderData *) renderer->driverdata;
-    SDL_Surface *surface = data->screens[data->current_screen];
+    SDL_Texture *texture = data->texture[data->current_texture];
-    SDL_DirtyRect *dirty;
 
     /* Send the data to the display */
-    for (dirty = data->dirty.list; dirty; dirty = dirty->next) {
+    if (data->renderer->info.flags & SDL_Renderer_PresentCopy) {
-        void *pixels =
+        SDL_DirtyRect *dirty;
-            (void *) ((Uint8 *) surface->pixels +
+        for (dirty = data->dirty.list; dirty; dirty = dirty->next) {
-                      dirty->rect.y * surface->pitch +
+            data->renderer->RenderCopy(data->renderer, texture, &dirty->rect,
-                      dirty->rect.x * surface->format->BytesPerPixel);
+                                       &dirty->rect,
-        data->renderer->RenderWritePixels(data->renderer, &dirty->rect,
+                                       SDL_TextureBlendMode_None,
-                                          pixels, surface->pitch);
+                                       SDL_TextureScaleMode_None);
+        }
+        SDL_ClearDirtyRects(&data->dirty);
+    } else {
+        SDL_Rect rect;
+        rect.x = 0;
+        rect.y = 0;
+        rect.w = texture->w;
+        rect.h = texture->h;
+        data->renderer->RenderCopy(data->renderer, texture, &rect, &rect,
+                                   SDL_TextureBlendMode_None,
+                                   SDL_TextureScaleMode_None);
     }
-    SDL_ClearDirtyRects(&data->dirty);
     data->renderer->RenderPresent(data->renderer);
 
     /* Update the flipping chain, if any */
     if (renderer->info.flags & SDL_Renderer_PresentFlip2) {
-        data->current_screen = (data->current_screen + 1) % 2;
+        data->current_texture = (data->current_texture + 1) % 2;
-        data->target = data->screens[data->current_screen];
     } else if (renderer->info.flags & SDL_Renderer_PresentFlip3) {
-        data->current_screen = (data->current_screen + 1) % 3;
+        data->current_texture = (data->current_texture + 1) % 3;
-        data->target = data->screens[data->current_screen];
     }
 }
 
@@ -521,14 +552,27 @@ static void
 SDL_SW_DestroyRenderer(SDL_Renderer * renderer)
 {
     SDL_SW_RenderData *data = (SDL_SW_RenderData *) renderer->driverdata;
+    SDL_Window *window = SDL_GetWindowFromID(renderer->window);
+    SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
     int i;
 
     if (data) {
-        for (i = 0; i < SDL_arraysize(data->screens); ++i) {
+        for (i = 0; i < SDL_arraysize(data->texture); ++i) {
-            if (data->screens[i]) {
+            if (data->texture[i]) {
-                SDL_FreeSurface(data->screens[i]);
+                DestroyTexture(data->renderer, data->texture[i]);
             }
         }
+        if (data->surface.format) {
+            SDL_SetSurfacePalette(&data->surface, NULL);
+            SDL_FreeFormat(data->surface.format);
+        }
+        if (display->palette) {
+            SDL_DelPaletteWatch(display->palette, DisplayPaletteChanged,
+                                data);
+        }
+        if (data->renderer) {
+            data->renderer->DestroyRenderer(data->renderer);
+        }
         SDL_FreeDirtyRects(&data->dirty);
         SDL_free(data);
     }

src/video/SDL_sysvideo.h

@@ -73,17 +73,11 @@ struct SDL_Renderer
     void (*UnlockTexture) (SDL_Renderer * renderer, SDL_Texture * texture);
     void (*DirtyTexture) (SDL_Renderer * renderer, SDL_Texture * texture,
                           int numrects, const SDL_Rect * rects);
-    void (*SelectRenderTexture) (SDL_Renderer * renderer,
-                                 SDL_Texture * texture);
     int (*RenderFill) (SDL_Renderer * renderer, const SDL_Rect * rect,
                        Uint32 color);
     int (*RenderCopy) (SDL_Renderer * renderer, SDL_Texture * texture,
                        const SDL_Rect * srcrect, const SDL_Rect * dstrect,
                        int blendMode, int scaleMode);
-    int (*RenderReadPixels) (SDL_Renderer * renderer, const SDL_Rect * rect,
-                             void *pixels, int pitch);
-    int (*RenderWritePixels) (SDL_Renderer * renderer, const SDL_Rect * rect,
-                              const void *pixels, int pitch);
     void (*RenderPresent) (SDL_Renderer * renderer);
     void (*DestroyTexture) (SDL_Renderer * renderer, SDL_Texture * texture);
 

src/video/SDL_video.c

@@ -1277,12 +1277,24 @@ SDL_GetNumRenderers(void)
 int
 SDL_GetRendererInfo(int index, SDL_RendererInfo * info)
 {
-    if (index < 0 || index >= SDL_GetNumRenderers()) {
+    if (!_this) {
+        return -1;
+    }
+
+    if (index >= SDL_GetNumRenderers()) {
         SDL_SetError("index must be in the range of 0 - %d",
                      SDL_GetNumRenderers() - 1);
         return -1;
     }
-    *info = SDL_CurrentDisplay.render_drivers[index].info;
+    if (index < 0) {
+        if (!SDL_CurrentDisplay.current_renderer) {
+            SDL_SetError("There is no current renderer");
+            return -1;
+        }
+        *info = SDL_CurrentDisplay.current_renderer->info;
+    } else {
+        *info = SDL_CurrentDisplay.render_drivers[index].info;
+    }
     return 0;
 }
 
@@ -1307,11 +1319,6 @@ SDL_CreateRenderer(SDL_WindowID windowID, int index, Uint32 flags)
                     break;
                 }
             } else {
-                /* Skip minimal drivers in automatic scans */
-                if (!(flags & SDL_Renderer_Minimal)
-                    && (driver->info.flags & SDL_Renderer_Minimal)) {
-                    continue;
-                }
                 if ((driver->info.flags & flags) == flags) {
                     break;
                 }
@@ -1734,22 +1741,6 @@ SDL_DirtyTexture(SDL_TextureID textureID, int numrects,
     renderer->DirtyTexture(renderer, texture, numrects, rects);
 }
 
-void
-SDL_SelectRenderTexture(SDL_TextureID textureID)
-{
-    SDL_Texture *texture = SDL_GetTextureFromID(textureID);
-    SDL_Renderer *renderer;
-
-    if (!texture || texture->access != SDL_TextureAccess_Render) {
-        return;
-    }
-    renderer = texture->renderer;
-    if (!renderer->SelectRenderTexture) {
-        return;
-    }
-    renderer->SelectRenderTexture(renderer, texture);
-}
-
 int
 SDL_RenderFill(const SDL_Rect * rect, Uint32 color)
 {
@@ -1821,60 +1812,6 @@ SDL_RenderCopy(SDL_TextureID textureID, const SDL_Rect * srcrect,
                                 &real_dstrect, blendMode, scaleMode);
 }
 
-int
-SDL_RenderReadPixels(const SDL_Rect * rect, void *pixels, int pitch)
-{
-    SDL_Renderer *renderer;
-    SDL_Rect full_rect;
-
-    if (!_this) {
-        return -1;
-    }
-
-    renderer = SDL_CurrentDisplay.current_renderer;
-    if (!renderer || !renderer->RenderReadPixels) {
-        return -1;
-    }
-
-    if (!rect) {
-        SDL_Window *window = SDL_GetWindowFromID(renderer->window);
-        full_rect.x = 0;
-        full_rect.y = 0;
-        full_rect.w = window->w;
-        full_rect.h = window->h;
-        rect = &full_rect;
-    }
-
-    return renderer->RenderReadPixels(renderer, rect, pixels, pitch);
-}
-
-int
-SDL_RenderWritePixels(const SDL_Rect * rect, const void *pixels, int pitch)
-{
-    SDL_Renderer *renderer;
-    SDL_Rect full_rect;
-
-    if (!_this) {
-        return -1;
-    }
-
-    renderer = SDL_CurrentDisplay.current_renderer;
-    if (!renderer || !renderer->RenderWritePixels) {
-        return -1;
-    }
-
-    if (!rect) {
-        SDL_Window *window = SDL_GetWindowFromID(renderer->window);
-        full_rect.x = 0;
-        full_rect.y = 0;
-        full_rect.w = window->w;
-        full_rect.h = window->h;
-        rect = &full_rect;
-    }
-
-    return renderer->RenderWritePixels(renderer, rect, pixels, pitch);
-}
-
 void
 SDL_RenderPresent(void)
 {
@@ -1888,10 +1825,6 @@ SDL_RenderPresent(void)
     if (!renderer || !renderer->RenderPresent) {
         return;
     }
-
-    if (renderer->SelectRenderTexture) {
-        renderer->SelectRenderTexture(renderer, NULL);
-    }
     renderer->RenderPresent(renderer);
 }
 

src/video/dummy/SDL_nullrender.c

@@ -31,12 +31,6 @@ static SDL_Renderer *SDL_DUMMY_CreateRenderer(SDL_Window * window,
                                               Uint32 flags);
 static int SDL_DUMMY_CreateTexture(SDL_Renderer * renderer,
                                    SDL_Texture * texture);
-static int SDL_DUMMY_RenderReadPixels(SDL_Renderer * renderer,
-                                      const SDL_Rect * rect, void *pixels,
-                                      int pitch);
-static int SDL_DUMMY_RenderWritePixels(SDL_Renderer * renderer,
-                                       const SDL_Rect * rect,
-                                       const void *pixels, int pitch);
 static void SDL_DUMMY_RenderPresent(SDL_Renderer * renderer);
 static void SDL_DUMMY_DestroyRenderer(SDL_Renderer * renderer);
 
@@ -45,8 +39,7 @@ SDL_RenderDriver SDL_DUMMY_RenderDriver = {
     SDL_DUMMY_CreateRenderer,
     {
      "dummy",
-     (SDL_Renderer_Minimal | SDL_Renderer_PresentDiscard |
+     (SDL_Renderer_PresentDiscard | SDL_Renderer_PresentCopy),
-      SDL_Renderer_PresentCopy),
      SDL_TextureBlendMode_None,
      SDL_TextureScaleMode_None,
      0,
@@ -91,8 +84,6 @@ SDL_DUMMY_CreateRenderer(SDL_Window * window, Uint32 flags)
     }
     SDL_zerop(data);
 
-    renderer->RenderReadPixels = SDL_DUMMY_RenderReadPixels;
-    renderer->RenderWritePixels = SDL_DUMMY_RenderWritePixels;
     renderer->RenderPresent = SDL_DUMMY_RenderPresent;
     renderer->DestroyRenderer = SDL_DUMMY_DestroyRenderer;
     renderer->info = SDL_DUMMY_RenderDriver.info;
@@ -111,54 +102,6 @@ SDL_DUMMY_CreateRenderer(SDL_Window * window, Uint32 flags)
     return renderer;
 }
 
-int
-SDL_DUMMY_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
-                           void *pixels, int pitch)
-{
-    SDL_DUMMY_RenderData *data =
-        (SDL_DUMMY_RenderData *) renderer->driverdata;
-    SDL_Surface *surface = data->surface;
-    Uint8 *src, *dst;
-    int row;
-    size_t length;
-
-    src =
-        (Uint8 *) surface->pixels + rect->y * surface->pitch +
-        rect->x * surface->format->BytesPerPixel;
-    dst = (Uint8 *) pixels;
-    length = rect->w * surface->format->BytesPerPixel;
-    for (row = 0; row < rect->h; ++row) {
-        SDL_memcpy(dst, src, length);
-        src += surface->pitch;
-        dst += pitch;
-    }
-    return 0;
-}
-
-int
-SDL_DUMMY_RenderWritePixels(SDL_Renderer * renderer, const SDL_Rect * rect,
-                            const void *pixels, int pitch)
-{
-    SDL_DUMMY_RenderData *data =
-        (SDL_DUMMY_RenderData *) renderer->driverdata;
-    SDL_Surface *surface = data->surface;
-    Uint8 *src, *dst;
-    int row;
-    size_t length;
-
-    src = (Uint8 *) pixels;
-    dst =
-        (Uint8 *) surface->pixels + rect->y * surface->pitch +
-        rect->x * surface->format->BytesPerPixel;
-    length = rect->w * surface->format->BytesPerPixel;
-    for (row = 0; row < rect->h; ++row) {
-        SDL_memcpy(dst, src, length);
-        src += pitch;
-        dst += surface->pitch;
-    }
-    return 0;
-}
-
 void
 SDL_DUMMY_RenderPresent(SDL_Renderer * renderer)
 {

src/video/win32/SDL_d3drender.c

@@ -50,20 +50,12 @@ static void SDL_D3D_UnlockTexture(SDL_Renderer * renderer,
 static void SDL_D3D_DirtyTexture(SDL_Renderer * renderer,
                                  SDL_Texture * texture, int numrects,
                                  const SDL_Rect * rects);
-static void SDL_D3D_SelectRenderTexture(SDL_Renderer * renderer,
-                                        SDL_Texture * texture);
 static int SDL_D3D_RenderFill(SDL_Renderer * renderer, const SDL_Rect * rect,
                               Uint32 color);
 static int SDL_D3D_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
                               const SDL_Rect * srcrect,
                               const SDL_Rect * dstrect, int blendMode,
                               int scaleMode);
-static int SDL_D3D_RenderReadPixels(SDL_Renderer * renderer,
-                                    const SDL_Rect * rect, void *pixels,
-                                    int pitch);
-static int SDL_D3D_RenderWritePixels(SDL_Renderer * renderer,
-                                     const SDL_Rect * rect,
-                                     const void *pixels, int pitch);
 static void SDL_D3D_RenderPresent(SDL_Renderer * renderer);
 static void SDL_D3D_DestroyTexture(SDL_Renderer * renderer,
                                    SDL_Texture * texture);
@@ -76,10 +68,9 @@ SDL_RenderDriver SDL_D3D_RenderDriver = {
      "d3d",
      (SDL_Renderer_SingleBuffer | SDL_Renderer_PresentCopy |
       SDL_Renderer_PresentFlip2 | SDL_Renderer_PresentFlip3 |
-      SDL_Renderer_PresentDiscard | SDL_Renderer_RenderTarget),
+      SDL_Renderer_PresentDiscard | SDL_Renderer_PresentVSync),
-     (SDL_TextureBlendMode_None |
+     (SDL_TextureBlendMode_None | SDL_TextureBlendMode_Mask | SDL_TextureBlendMode_Blend),      /* FIXME */
-      SDL_TextureBlendMode_Mask | SDL_TextureBlendMode_Blend),
+     (SDL_TextureScaleMode_None | SDL_TextureScaleMode_Fast),   /* FIXME */
-     (SDL_TextureScaleMode_None | SDL_TextureScaleMode_Fast),
      12,
      {
       SDL_PixelFormat_Index8,
@@ -101,8 +92,6 @@ SDL_RenderDriver SDL_D3D_RenderDriver = {
 typedef struct
 {
     IDirect3DDevice9 *device;
-    IDirect3DSurface9 *surface;
-    IDirect3DSurface9 *offscreen;
     SDL_bool beginScene;
 } SDL_D3D_RenderData;
 
@@ -250,6 +239,7 @@ SDL_D3D_CreateRenderer(SDL_Window * window, Uint32 flags)
     SDL_D3D_RenderData *data;
     HRESULT result;
     D3DPRESENT_PARAMETERS pparams;
+    IDirect3DSwapChain9 *chain;
 
     renderer = (SDL_Renderer *) SDL_malloc(sizeof(*renderer));
     if (!renderer) {
@@ -273,11 +263,8 @@ SDL_D3D_CreateRenderer(SDL_Window * window, Uint32 flags)
     renderer->LockTexture = SDL_D3D_LockTexture;
     renderer->UnlockTexture = SDL_D3D_UnlockTexture;
     renderer->DirtyTexture = SDL_D3D_DirtyTexture;
-    renderer->SelectRenderTexture = SDL_D3D_SelectRenderTexture;
     renderer->RenderFill = SDL_D3D_RenderFill;
     renderer->RenderCopy = SDL_D3D_RenderCopy;
-    renderer->RenderReadPixels = SDL_D3D_RenderReadPixels;
-    renderer->RenderWritePixels = SDL_D3D_RenderWritePixels;
     renderer->RenderPresent = SDL_D3D_RenderPresent;
     renderer->DestroyTexture = SDL_D3D_DestroyTexture;
     renderer->DestroyRenderer = SDL_D3D_DestroyRenderer;
@@ -285,7 +272,7 @@ SDL_D3D_CreateRenderer(SDL_Window * window, Uint32 flags)
     renderer->window = window->id;
     renderer->driverdata = data;
 
-    renderer->info.flags = SDL_Renderer_RenderTarget;
+    renderer->info.flags = SDL_Renderer_Accelerated;
 
     SDL_zero(pparams);
     pparams.BackBufferWidth = window->w;
@@ -317,7 +304,11 @@ SDL_D3D_CreateRenderer(SDL_Window * window, Uint32 flags)
         pparams.Windowed = TRUE;
         pparams.FullScreen_RefreshRateInHz = 0;
     }
-    pparams.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
+    if (flags & SDL_Renderer_PresentVSync) {
+        pparams.PresentationInterval = D3DPRESENT_INTERVAL_ONE;
+    } else {
+        pparams.PresentationInterval = D3DPRESENT_INTERVAL_IMMEDIATE;
+    }
 
     result = IDirect3D9_CreateDevice(videodata->d3d, D3DADAPTER_DEFAULT,        /* FIXME */
                                      D3DDEVTYPE_HAL,
@@ -331,6 +322,43 @@ SDL_D3D_CreateRenderer(SDL_Window * window, Uint32 flags)
     }
     data->beginScene = SDL_TRUE;
 
+    /* Get presentation parameters to fill info */
+    result = IDirect3DDevice9_GetSwapChain(data->device, 0, &chain);
+    if (FAILED(result)) {
+        SDL_D3D_DestroyRenderer(renderer);
+        D3D_SetError("GetSwapChain()", result);
+        return NULL;
+    }
+    result = IDirect3DSwapChain9_GetPresentParameters(chain, &pparams);
+    if (FAILED(result)) {
+        IDirect3DSwapChain9_Release(chain);
+        SDL_D3D_DestroyRenderer(renderer);
+        D3D_SetError("GetPresentParameters()", result);
+        return NULL;
+    }
+    IDirect3DSwapChain9_Release(chain);
+    switch (pparams.SwapEffect) {
+    case D3DSWAPEFFECT_COPY:
+        renderer->info.flags |= SDL_Renderer_PresentCopy;
+        break;
+    case D3DSWAPEFFECT_FLIP:
+        switch (pparams.BackBufferCount) {
+        case 2:
+            renderer->info.flags |= SDL_Renderer_PresentFlip2;
+            break;
+        case 3:
+            renderer->info.flags |= SDL_Renderer_PresentFlip3;
+            break;
+        }
+        break;
+    case D3DSWAPEFFECT_DISCARD:
+        renderer->info.flags |= SDL_Renderer_PresentDiscard;
+        break;
+    }
+    if (pparams.PresentationInterval == D3DPRESENT_INTERVAL_ONE) {
+        renderer->info.flags |= SDL_Renderer_PresentVSync;
+    }
+
     /* Set up parameters for rendering */
     IDirect3DDevice9_SetVertexShader(data->device, NULL);
     IDirect3DDevice9_SetFVF(data->device, D3DFVF_XYZRHW | D3DFVF_TEX1);
@@ -527,14 +555,6 @@ SDL_D3D_DirtyTexture(SDL_Renderer * renderer, SDL_Texture * texture,
     }
 }
 
-static void
-SDL_D3D_SelectRenderTexture(SDL_Renderer * renderer, SDL_Texture * texture)
-{
-    SDL_D3D_RenderData *data = (SDL_D3D_RenderData *) renderer->driverdata;
-
-    /* FIXME */
-}
-
 static int
 SDL_D3D_RenderFill(SDL_Renderer * renderer, const SDL_Rect * rect,
                    Uint32 color)
@@ -637,93 +657,6 @@ SDL_D3D_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
     return 0;
 }
 
-static int
-SDL_D3D_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
-                         void *pixels, int pitch)
-{
-    SDL_D3D_RenderData *data = (SDL_D3D_RenderData *) renderer->driverdata;
-
-    /* FIXME */
-    return 0;
-}
-
-static int
-SDL_D3D_RenderWritePixels(SDL_Renderer * renderer, const SDL_Rect * rect,
-                          const void *pixels, int pitch)
-{
-    SDL_Window *window = SDL_GetWindowFromID(renderer->window);
-    SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);
-    SDL_D3D_RenderData *data = (SDL_D3D_RenderData *) renderer->driverdata;
-    RECT d3drect;
-    POINT point;
-    D3DLOCKED_RECT locked;
-    const Uint8 *src;
-    Uint8 *dst;
-    int row, length;
-    HRESULT result;
-
-    if (!data->surface) {
-        result =
-            IDirect3DDevice9_GetBackBuffer(data->device, 0, 0,
-                                           D3DBACKBUFFER_TYPE_MONO,
-                                           &data->surface);
-        if (FAILED(result)) {
-            D3D_SetError("GetBackBuffer()", result);
-            return -1;
-        }
-    }
-    if (!data->offscreen) {
-        result =
-            IDirect3DDevice9_CreateOffscreenPlainSurface(data->device,
-                                                         window->w, window->h,
-                                                         PixelFormatToD3DFMT
-                                                         (display->
-                                                          current_mode.
-                                                          format),
-                                                         D3DPOOL_SYSTEMMEM,
-                                                         &data->offscreen,
-                                                         NULL);
-        if (FAILED(result)) {
-            D3D_SetError("CreateOffscreenPlainSurface()", result);
-            return -1;
-        }
-    }
-
-    d3drect.left = rect->x;
-    d3drect.right = rect->x + rect->w;
-    d3drect.top = rect->y;
-    d3drect.bottom = rect->y + rect->h;
-
-    result =
-        IDirect3DSurface9_LockRect(data->offscreen, &locked, &d3drect, 0);
-    if (FAILED(result)) {
-        D3D_SetError("LockRect()", result);
-        return -1;
-    }
-
-    src = pixels;
-    dst = locked.pBits;
-    length = rect->w * SDL_BYTESPERPIXEL(display->current_mode.format);
-    for (row = 0; row < rect->h; ++row) {
-        SDL_memcpy(dst, src, length);
-        src += pitch;
-        dst += locked.Pitch;
-    }
-    IDirect3DSurface9_UnlockRect(data->offscreen);
-
-    point.x = rect->x;
-    point.y = rect->y;
-    result =
-        IDirect3DDevice9_UpdateSurface(data->device, data->offscreen,
-                                       &d3drect, data->surface, &point);
-    if (FAILED(result)) {
-        D3D_SetError("UpdateSurface()", result);
-        return -1;
-    }
-
-    return 0;
-}
-
 static void
 SDL_D3D_RenderPresent(SDL_Renderer * renderer)
 {
@@ -765,12 +698,6 @@ SDL_D3D_DestroyRenderer(SDL_Renderer * renderer)
         if (data->device) {
             IDirect3DDevice9_Release(data->device);
         }
-        if (data->surface) {
-            IDirect3DSurface9_Release(data->surface);
-        }
-        if (data->offscreen) {
-            IDirect3DSurface9_Release(data->offscreen);
-        }
         SDL_free(data);
     }
     SDL_free(renderer);

src/video/win32/SDL_gdirender.c

@@ -55,20 +55,12 @@ static void SDL_GDI_UnlockTexture(SDL_Renderer * renderer,
 static void SDL_GDI_DirtyTexture(SDL_Renderer * renderer,
                                  SDL_Texture * texture, int numrects,
                                  const SDL_Rect * rects);
-static void SDL_GDI_SelectRenderTexture(SDL_Renderer * renderer,
-                                        SDL_Texture * texture);
 static int SDL_GDI_RenderFill(SDL_Renderer * renderer, const SDL_Rect * rect,
                               Uint32 color);
 static int SDL_GDI_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
                               const SDL_Rect * srcrect,
                               const SDL_Rect * dstrect, int blendMode,
                               int scaleMode);
-static int SDL_GDI_RenderReadPixels(SDL_Renderer * renderer,
-                                    const SDL_Rect * rect, void *pixels,
-                                    int pitch);
-static int SDL_GDI_RenderWritePixels(SDL_Renderer * renderer,
-                                     const SDL_Rect * rect,
-                                     const void *pixels, int pitch);
 static void SDL_GDI_RenderPresent(SDL_Renderer * renderer);
 static void SDL_GDI_DestroyTexture(SDL_Renderer * renderer,
                                    SDL_Texture * texture);
@@ -81,7 +73,7 @@ SDL_RenderDriver SDL_GDI_RenderDriver = {
      "gdi",
      (SDL_Renderer_SingleBuffer | SDL_Renderer_PresentCopy |
       SDL_Renderer_PresentFlip2 | SDL_Renderer_PresentFlip3 |
-      SDL_Renderer_PresentDiscard | SDL_Renderer_RenderTarget),
+      SDL_Renderer_PresentDiscard),
      (SDL_TextureBlendMode_None | SDL_TextureBlendMode_Mask |
       SDL_TextureBlendMode_Blend),
      (SDL_TextureScaleMode_None | SDL_TextureScaleMode_Fast),
@@ -114,9 +106,6 @@ typedef struct
     int current_hbm;
     SDL_DirtyRectList dirty;
     SDL_bool makedirty;
-    HBITMAP window_dib;
-    void *window_pixels;
-    int window_pitch;
 } SDL_GDI_RenderData;
 
 typedef struct
@@ -182,11 +171,8 @@ SDL_GDI_CreateRenderer(SDL_Window * window, Uint32 flags)
     renderer->LockTexture = SDL_GDI_LockTexture;
     renderer->UnlockTexture = SDL_GDI_UnlockTexture;
     renderer->DirtyTexture = SDL_GDI_DirtyTexture;
-    renderer->SelectRenderTexture = SDL_GDI_SelectRenderTexture;
     renderer->RenderFill = SDL_GDI_RenderFill;
     renderer->RenderCopy = SDL_GDI_RenderCopy;
-    renderer->RenderReadPixels = SDL_GDI_RenderReadPixels;
-    renderer->RenderWritePixels = SDL_GDI_RenderWritePixels;
     renderer->RenderPresent = SDL_GDI_RenderPresent;
     renderer->DestroyTexture = SDL_GDI_DestroyTexture;
     renderer->DestroyRenderer = SDL_GDI_DestroyRenderer;
@@ -194,7 +180,7 @@ SDL_GDI_CreateRenderer(SDL_Window * window, Uint32 flags)
     renderer->window = window->id;
     renderer->driverdata = data;
 
-    renderer->info.flags = SDL_Renderer_RenderTarget;
+    renderer->info.flags = SDL_Renderer_Accelerated;
 
     data->hwnd = windowdata->hwnd;
     data->window_hdc = GetDC(data->hwnd);
@@ -218,7 +204,8 @@ SDL_GDI_CreateRenderer(SDL_Window * window, Uint32 flags)
     DeleteObject(hbm);
 
     if (flags & SDL_Renderer_SingleBuffer) {
-        renderer->info.flags |= SDL_Renderer_SingleBuffer;
+        renderer->info.flags |=
+            (SDL_Renderer_SingleBuffer | SDL_Renderer_PresentCopy);
         n = 0;
     } else if (flags & SDL_Renderer_PresentFlip2) {
         renderer->info.flags |= SDL_Renderer_PresentFlip2;
@@ -271,10 +258,6 @@ SDL_GDI_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture)
     texture->driverdata = data;
 
     if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
-        if (texture->access == SDL_TextureAccess_Render) {
-            SDL_SetError("Rendering to YUV format textures is not supported");
-            return -1;
-        }
         data->yuv = SDL_SW_CreateYUVTexture(texture);
         if (!data->yuv) {
             SDL_GDI_DestroyTexture(renderer, texture);
@@ -521,31 +504,6 @@ SDL_GDI_DirtyTexture(SDL_Renderer * renderer, SDL_Texture * texture,
 {
 }
 
-static void
-SDL_GDI_SelectRenderTexture(SDL_Renderer * renderer, SDL_Texture * texture)
-{
-    SDL_GDI_RenderData *data = (SDL_GDI_RenderData *) renderer->driverdata;
-
-    if (texture) {
-        SDL_GDI_TextureData *texturedata =
-            (SDL_GDI_TextureData *) texture->driverdata;
-        SelectObject(data->render_hdc, texturedata->hbm);
-        if (texturedata->hpal) {
-            SelectPalette(data->render_hdc, texturedata->hpal, TRUE);
-            RealizePalette(data->render_hdc);
-        }
-        data->current_hdc = data->render_hdc;
-        data->makedirty = SDL_FALSE;
-    } else if (renderer->info.flags & SDL_Renderer_SingleBuffer) {
-        data->current_hdc = data->window_hdc;
-        data->makedirty = SDL_FALSE;
-    } else {
-        SelectObject(data->render_hdc, data->hbm[data->current_hbm]);
-        data->current_hdc = data->render_hdc;
-        data->makedirty = SDL_TRUE;
-    }
-}
-
 static int
 SDL_GDI_RenderFill(SDL_Renderer * renderer, const SDL_Rect * rect,
                    Uint32 color)
@@ -637,98 +595,6 @@ SDL_GDI_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
     return 0;
 }
 
-static int
-CreateWindowDIB(SDL_GDI_RenderData * data, SDL_Window * window)
-{
-    data->window_pitch = window->w * (data->bmi->bmiHeader.biBitCount / 8);
-    data->bmi->bmiHeader.biWidth = window->w;
-    data->bmi->bmiHeader.biHeight = -window->h;
-    data->bmi->bmiHeader.biSizeImage =
-        window->h * (data->bmi->bmiHeader.biBitCount / 8);
-    data->window_dib =
-        CreateDIBSection(data->window_hdc, data->bmi, DIB_RGB_COLORS,
-                         &data->window_pixels, NULL, 0);
-    if (!data->window_dib) {
-        WIN_SetError("CreateDIBSection()");
-        return -1;
-    }
-    return 0;
-}
-
-static int
-SDL_GDI_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
-                         void *pixels, int pitch)
-{
-    SDL_Window *window = SDL_GetWindowFromID(renderer->window);
-    SDL_GDI_RenderData *data = (SDL_GDI_RenderData *) renderer->driverdata;
-
-    if (!data->window_dib) {
-        if (CreateWindowDIB(data, window) < 0) {
-            return -1;
-        }
-    }
-
-    SelectObject(data->memory_hdc, data->window_dib);
-    BitBlt(data->memory_hdc, rect->x, rect->y, rect->w, rect->h,
-           data->current_hdc, rect->x, rect->y, SRCCOPY);
-
-    {
-        int bpp = data->bmi->bmiHeader.biBitCount / 8;
-        Uint8 *src =
-            (Uint8 *) data->window_pixels + rect->y * data->window_pitch +
-            rect->x * bpp;
-        Uint8 *dst = (Uint8 *) pixels;
-        int row;
-
-        for (row = 0; row < rect->h; ++row) {
-            SDL_memcpy(dst, src, rect->w * bpp);
-            src += data->window_pitch;
-            dst += pitch;
-        }
-    }
-
-    return 0;
-}
-
-static int
-SDL_GDI_RenderWritePixels(SDL_Renderer * renderer, const SDL_Rect * rect,
-                          const void *pixels, int pitch)
-{
-    SDL_Window *window = SDL_GetWindowFromID(renderer->window);
-    SDL_GDI_RenderData *data = (SDL_GDI_RenderData *) renderer->driverdata;
-
-    if (data->makedirty) {
-        SDL_AddDirtyRect(&data->dirty, rect);
-    }
-
-    if (!data->window_dib) {
-        if (CreateWindowDIB(data, window) < 0) {
-            return -1;
-        }
-    }
-
-    {
-        int bpp = data->bmi->bmiHeader.biBitCount / 8;
-        Uint8 *src = (Uint8 *) pixels;
-        Uint8 *dst =
-            (Uint8 *) data->window_pixels + rect->y * data->window_pitch +
-            rect->x * bpp;
-        int row;
-
-        for (row = 0; row < rect->h; ++row) {
-            SDL_memcpy(dst, src, rect->w * bpp);
-            src += pitch;
-            dst += data->window_pitch;
-        }
-    }
-
-    SelectObject(data->memory_hdc, data->window_dib);
-    BitBlt(data->current_hdc, rect->x, rect->y, rect->w, rect->h,
-           data->memory_hdc, rect->x, rect->y, SRCCOPY);
-
-    return 0;
-}
-
 static void
 SDL_GDI_RenderPresent(SDL_Renderer * renderer)
 {
@@ -795,9 +661,6 @@ SDL_GDI_DestroyRenderer(SDL_Renderer * renderer)
             }
         }
         SDL_FreeDirtyRects(&data->dirty);
-        if (data->window_dib) {
-            DeleteObject(data->window_dib);
-        }
         SDL_free(data);
     }
     SDL_free(renderer);

test/testsprite.c

@@ -1,6 +1,7 @@
 /* Simple program:  Move N sprites around on the screen as fast as possible */
 
 #include <stdlib.h>
+#include <stdio.h>
 #include <time.h>
 
 #include "SDL.h"

test/testsprite2.c

@@ -1,6 +1,7 @@
 /* Simple program:  Move N sprites around on the screen as fast as possible */
 
 #include <stdlib.h>
+#include <stdio.h>
 #include <time.h>
 
 #include "SDL.h"
@@ -126,6 +127,7 @@ main(int argc, char *argv[])
 {
     int window_w, window_h;
     Uint32 window_flags = SDL_WINDOW_SHOWN;
+    Uint32 render_flags = 0;
     SDL_DisplayMode *mode, fullscreen_mode;
     int i, done;
     SDL_Event event;
@@ -152,11 +154,13 @@ main(int argc, char *argv[])
         } else if (strcmp(argv[i], "-fullscreen") == 0) {
             num_windows = 1;
             window_flags |= SDL_WINDOW_FULLSCREEN;
+        } else if (strcmp(argv[i], "-sync") == 0) {
+            render_flags |= SDL_Renderer_PresentVSync;
         } else if (isdigit(argv[i][0])) {
             num_sprites = atoi(argv[i]);
         } else {
             fprintf(stderr,
-                    "Usage: %s [-width N] [-height N] [-windows N] [-fullscreen] [numsprites]\n",
+                    "Usage: %s [-width N] [-height N] [-windows N] [-fullscreen] [-sync] [numsprites]\n",
                     argv[0]);
             quit(1);
         }
@@ -189,7 +193,7 @@ main(int argc, char *argv[])
             quit(2);
         }
 
-        if (SDL_CreateRenderer(windows[i], -1, 0) < 0) {
+        if (SDL_CreateRenderer(windows[i], -1, render_flags) < 0) {
             fprintf(stderr, "Couldn't create renderer: %s\n", SDL_GetError());
             quit(2);
         }