kc3-lang/SDL/src/render/SDL_render.c

• Show log

  Commit

• Hash : 8e2634eb
  Author :
  Date : 2016-10-14T00:51:57
  

  Fixed divide by zero if setting integer scale without setting logical width and height

Download

• src/render/SDL_render.c

• /*
    Simple DirectMedia Layer
    Copyright (C) 1997-2016 Sam Lantinga <slouken@libsdl.org>
  
    This software is provided 'as-is', without any express or implied
    warranty.  In no event will the authors be held liable for any damages
    arising from the use of this software.
  
    Permission is granted to anyone to use this software for any purpose,
    including commercial applications, and to alter it and redistribute it
    freely, subject to the following restrictions:
  
    1. The origin of this software must not be misrepresented; you must not
       claim that you wrote the original software. If you use this software
       in a product, an acknowledgment in the product documentation would be
       appreciated but is not required.
    2. Altered source versions must be plainly marked as such, and must not be
       misrepresented as being the original software.
    3. This notice may not be removed or altered from any source distribution.
  */
  #include "../SDL_internal.h"
  
  /* The SDL 2D rendering system */
  
  #include "SDL_assert.h"
  #include "SDL_hints.h"
  #include "SDL_log.h"
  #include "SDL_render.h"
  #include "SDL_sysrender.h"
  #include "software/SDL_render_sw_c.h"
  
  
  #define SDL_WINDOWRENDERDATA    "_SDL_WindowRenderData"
  
  #define CHECK_RENDERER_MAGIC(renderer, retval) \
      if (!renderer || renderer->magic != &renderer_magic) { \
          SDL_SetError("Invalid renderer"); \
          return retval; \
      }
  
  #define CHECK_TEXTURE_MAGIC(texture, retval) \
      if (!texture || texture->magic != &texture_magic) { \
          SDL_SetError("Invalid texture"); \
          return retval; \
      }
  
  
  #if !SDL_RENDER_DISABLED
  static const SDL_RenderDriver *render_drivers[] = {
  #if SDL_VIDEO_RENDER_D3D
      &D3D_RenderDriver,
  #endif
  #if SDL_VIDEO_RENDER_D3D11
      &D3D11_RenderDriver,
  #endif
  #if SDL_VIDEO_RENDER_OGL
      &GL_RenderDriver,
  #endif
  #if SDL_VIDEO_RENDER_OGL_ES2
      &GLES2_RenderDriver,
  #endif
  #if SDL_VIDEO_RENDER_OGL_ES
      &GLES_RenderDriver,
  #endif
  #if SDL_VIDEO_RENDER_DIRECTFB
      &DirectFB_RenderDriver,
  #endif
  #if SDL_VIDEO_RENDER_PSP
      &PSP_RenderDriver,
  #endif
      &SW_RenderDriver
  };
  #endif /* !SDL_RENDER_DISABLED */
  
  static char renderer_magic;
  static char texture_magic;
  
  static int UpdateLogicalSize(SDL_Renderer *renderer);
  
  int
  SDL_GetNumRenderDrivers(void)
  {
  #if !SDL_RENDER_DISABLED
      return SDL_arraysize(render_drivers);
  #else
      return 0;
  #endif
  }
  
  int
  SDL_GetRenderDriverInfo(int index, SDL_RendererInfo * info)
  {
  #if !SDL_RENDER_DISABLED
      if (index < 0 || index >= SDL_GetNumRenderDrivers()) {
          return SDL_SetError("index must be in the range of 0 - %d",
                              SDL_GetNumRenderDrivers() - 1);
      }
      *info = render_drivers[index]->info;
      return 0;
  #else
      return SDL_SetError("SDL not built with rendering support");
  #endif
  }
  
  static int
  SDL_RendererEventWatch(void *userdata, SDL_Event *event)
  {
      SDL_Renderer *renderer = (SDL_Renderer *)userdata;
  
      if (event->type == SDL_WINDOWEVENT) {
          SDL_Window *window = SDL_GetWindowFromID(event->window.windowID);
          if (window == renderer->window) {
              if (renderer->WindowEvent) {
                  renderer->WindowEvent(renderer, &event->window);
              }
  
              if (event->window.event == SDL_WINDOWEVENT_SIZE_CHANGED) {
                  /* Make sure we're operating on the default render target */
                  SDL_Texture *saved_target = SDL_GetRenderTarget(renderer);
                  if (saved_target) {
                      SDL_SetRenderTarget(renderer, NULL);
                  }
  
                  if (renderer->logical_w) {
                      UpdateLogicalSize(renderer);
                  } else {
                      /* Window was resized, reset viewport */
                      int w, h;
  
                      if (renderer->GetOutputSize) {
                          renderer->GetOutputSize(renderer, &w, &h);
                      } else {
                          SDL_GetWindowSize(renderer->window, &w, &h);
                      }
  
                      if (renderer->target) {
                          renderer->viewport_backup.x = 0;
                          renderer->viewport_backup.y = 0;
                          renderer->viewport_backup.w = w;
                          renderer->viewport_backup.h = h;
                      } else {
                          renderer->viewport.x = 0;
                          renderer->viewport.y = 0;
                          renderer->viewport.w = w;
                          renderer->viewport.h = h;
                          renderer->UpdateViewport(renderer);
                      }
                  }
  
                  if (saved_target) {
                      SDL_SetRenderTarget(renderer, saved_target);
                  }
              } else if (event->window.event == SDL_WINDOWEVENT_HIDDEN) {
                  renderer->hidden = SDL_TRUE;
              } else if (event->window.event == SDL_WINDOWEVENT_SHOWN) {
                  if (!(SDL_GetWindowFlags(window) & SDL_WINDOW_MINIMIZED)) {
                      renderer->hidden = SDL_FALSE;
                  }
              } else if (event->window.event == SDL_WINDOWEVENT_MINIMIZED) {
                  renderer->hidden = SDL_TRUE;
              } else if (event->window.event == SDL_WINDOWEVENT_RESTORED || 
                         event->window.event == SDL_WINDOWEVENT_MAXIMIZED) {
                  if (!(SDL_GetWindowFlags(window) & SDL_WINDOW_HIDDEN)) {
                      renderer->hidden = SDL_FALSE;
                  }
              }
          }
      } else if (event->type == SDL_MOUSEMOTION) {
          SDL_Window *window = SDL_GetWindowFromID(event->motion.windowID);
          if (renderer->logical_w && window == renderer->window) {
              event->motion.x -= renderer->viewport.x;
              event->motion.y -= renderer->viewport.y;
              event->motion.x = (int)(event->motion.x / renderer->scale.x);
              event->motion.y = (int)(event->motion.y / renderer->scale.y);
              if (event->motion.xrel > 0) {
                  event->motion.xrel = SDL_max(1, (int)(event->motion.xrel / renderer->scale.x));
              } else if (event->motion.xrel < 0) {
                  event->motion.xrel = SDL_min(-1, (int)(event->motion.xrel / renderer->scale.x));
              }
              if (event->motion.yrel > 0) {
                  event->motion.yrel = SDL_max(1, (int)(event->motion.yrel / renderer->scale.y));
              } else if (event->motion.yrel < 0) {
                  event->motion.yrel = SDL_min(-1, (int)(event->motion.yrel / renderer->scale.y));
              }
          }
      } else if (event->type == SDL_MOUSEBUTTONDOWN ||
                 event->type == SDL_MOUSEBUTTONUP) {
          SDL_Window *window = SDL_GetWindowFromID(event->button.windowID);
          if (renderer->logical_w && window == renderer->window) {
              event->button.x -= renderer->viewport.x;
              event->button.y -= renderer->viewport.y;
              event->button.x = (int)(event->button.x / renderer->scale.x);
              event->button.y = (int)(event->button.y / renderer->scale.y);
          }
      }
      return 0;
  }
  
  int
  SDL_CreateWindowAndRenderer(int width, int height, Uint32 window_flags,
                              SDL_Window **window, SDL_Renderer **renderer)
  {
      *window = SDL_CreateWindow(NULL, SDL_WINDOWPOS_UNDEFINED,
                                       SDL_WINDOWPOS_UNDEFINED,
                                       width, height, window_flags);
      if (!*window) {
          *renderer = NULL;
          return -1;
      }
  
      *renderer = SDL_CreateRenderer(*window, -1, 0);
      if (!*renderer) {
          return -1;
      }
  
      return 0;
  }
  
  SDL_Renderer *
  SDL_CreateRenderer(SDL_Window * window, int index, Uint32 flags)
  {
  #if !SDL_RENDER_DISABLED
      SDL_Renderer *renderer = NULL;
      int n = SDL_GetNumRenderDrivers();
      const char *hint;
  
      if (!window) {
          SDL_SetError("Invalid window");
          return NULL;
      }
  
      if (SDL_GetRenderer(window)) {
          SDL_SetError("Renderer already associated with window");
          return NULL;
      }
  
      if (SDL_GetHint(SDL_HINT_RENDER_VSYNC)) {
          if (SDL_GetHintBoolean(SDL_HINT_RENDER_VSYNC, SDL_TRUE)) {
              flags |= SDL_RENDERER_PRESENTVSYNC;
          } else {
              flags &= ~SDL_RENDERER_PRESENTVSYNC;
          }
      }
  
      if (index < 0) {
          hint = SDL_GetHint(SDL_HINT_RENDER_DRIVER);
          if (hint) {
              for (index = 0; index < n; ++index) {
                  const SDL_RenderDriver *driver = render_drivers[index];
  
                  if (SDL_strcasecmp(hint, driver->info.name) == 0) {
                      /* Create a new renderer instance */
                      renderer = driver->CreateRenderer(window, flags);
                      break;
                  }
              }
          }
  
          if (!renderer) {
              for (index = 0; index < n; ++index) {
                  const SDL_RenderDriver *driver = render_drivers[index];
  
                  if ((driver->info.flags & flags) == flags) {
                      /* Create a new renderer instance */
                      renderer = driver->CreateRenderer(window, flags);
                      if (renderer) {
                          /* Yay, we got one! */
                          break;
                      }
                  }
              }
          }
          if (index == n) {
              SDL_SetError("Couldn't find matching render driver");
              return NULL;
          }
      } else {
          if (index >= SDL_GetNumRenderDrivers()) {
              SDL_SetError("index must be -1 or in the range of 0 - %d",
                           SDL_GetNumRenderDrivers() - 1);
              return NULL;
          }
          /* Create a new renderer instance */
          renderer = render_drivers[index]->CreateRenderer(window, flags);
      }
  
      if (renderer) {
          renderer->magic = &renderer_magic;
          renderer->window = window;
          renderer->scale.x = 1.0f;
          renderer->scale.y = 1.0f;
  
          if (SDL_GetWindowFlags(window) & (SDL_WINDOW_HIDDEN|SDL_WINDOW_MINIMIZED)) {
              renderer->hidden = SDL_TRUE;
          } else {
              renderer->hidden = SDL_FALSE;
          }
  
          SDL_SetWindowData(window, SDL_WINDOWRENDERDATA, renderer);
  
          SDL_RenderSetViewport(renderer, NULL);
  
          SDL_AddEventWatch(SDL_RendererEventWatch, renderer);
  
          SDL_LogInfo(SDL_LOG_CATEGORY_RENDER,
                      "Created renderer: %s", renderer->info.name);
      }
      return renderer;
  #else
      SDL_SetError("SDL not built with rendering support");
      return NULL;
  #endif
  }
  
  SDL_Renderer *
  SDL_CreateSoftwareRenderer(SDL_Surface * surface)
  {
  #if !SDL_RENDER_DISABLED
      SDL_Renderer *renderer;
  
      renderer = SW_CreateRendererForSurface(surface);
  
      if (renderer) {
          renderer->magic = &renderer_magic;
          renderer->scale.x = 1.0f;
          renderer->scale.y = 1.0f;
  
          SDL_RenderSetViewport(renderer, NULL);
      }
      return renderer;
  #else
      SDL_SetError("SDL not built with rendering support");
      return NULL;
  #endif /* !SDL_RENDER_DISABLED */
  }
  
  SDL_Renderer *
  SDL_GetRenderer(SDL_Window * window)
  {
      return (SDL_Renderer *)SDL_GetWindowData(window, SDL_WINDOWRENDERDATA);
  }
  
  int
  SDL_GetRendererInfo(SDL_Renderer * renderer, SDL_RendererInfo * info)
  {
      CHECK_RENDERER_MAGIC(renderer, -1);
  
      *info = renderer->info;
      return 0;
  }
  
  int
  SDL_GetRendererOutputSize(SDL_Renderer * renderer, int *w, int *h)
  {
      CHECK_RENDERER_MAGIC(renderer, -1);
  
      if (renderer->target) {
          return SDL_QueryTexture(renderer->target, NULL, NULL, w, h);
      } else if (renderer->GetOutputSize) {
          return renderer->GetOutputSize(renderer, w, h);
      } else if (renderer->window) {
          SDL_GetWindowSize(renderer->window, w, h);
          return 0;
      } else {
          SDL_assert(0 && "This should never happen");
          return SDL_SetError("Renderer doesn't support querying output size");
      }
  }
  
  static SDL_bool
  IsSupportedFormat(SDL_Renderer * renderer, Uint32 format)
  {
      Uint32 i;
  
      for (i = 0; i < renderer->info.num_texture_formats; ++i) {
          if (renderer->info.texture_formats[i] == format) {
              return SDL_TRUE;
          }
      }
      return SDL_FALSE;
  }
  
  static Uint32
  GetClosestSupportedFormat(SDL_Renderer * renderer, Uint32 format)
  {
      Uint32 i;
  
      if (SDL_ISPIXELFORMAT_FOURCC(format)) {
          /* Look for an exact match */
          for (i = 0; i < renderer->info.num_texture_formats; ++i) {
              if (renderer->info.texture_formats[i] == format) {
                  return renderer->info.texture_formats[i];
              }
          }
      } else {
          SDL_bool hasAlpha = SDL_ISPIXELFORMAT_ALPHA(format);
  
          /* We just want to match the first format that has the same channels */
          for (i = 0; i < renderer->info.num_texture_formats; ++i) {
              if (!SDL_ISPIXELFORMAT_FOURCC(renderer->info.texture_formats[i]) &&
                  SDL_ISPIXELFORMAT_ALPHA(renderer->info.texture_formats[i]) == hasAlpha) {
                  return renderer->info.texture_formats[i];
              }
          }
      }
      return renderer->info.texture_formats[0];
  }
  
  SDL_Texture *
  SDL_CreateTexture(SDL_Renderer * renderer, Uint32 format, int access, int w, int h)
  {
      SDL_Texture *texture;
  
      CHECK_RENDERER_MAGIC(renderer, NULL);
  
      if (!format) {
          format = renderer->info.texture_formats[0];
      }
      if (SDL_BYTESPERPIXEL(format) == 0) {
          SDL_SetError("Invalid texture format");
          return NULL;
      }
      if (SDL_ISPIXELFORMAT_INDEXED(format)) {
          SDL_SetError("Palettized textures are not supported");
          return NULL;
      }
      if (w <= 0 || h <= 0) {
          SDL_SetError("Texture dimensions can't be 0");
          return NULL;
      }
      if ((renderer->info.max_texture_width && w > renderer->info.max_texture_width) ||
          (renderer->info.max_texture_height && h > renderer->info.max_texture_height)) {
          SDL_SetError("Texture dimensions are limited to %dx%d", renderer->info.max_texture_width, renderer->info.max_texture_height);
          return NULL;
      }
      texture = (SDL_Texture *) SDL_calloc(1, sizeof(*texture));
      if (!texture) {
          SDL_OutOfMemory();
          return NULL;
      }
      texture->magic = &texture_magic;
      texture->format = format;
      texture->access = access;
      texture->w = w;
      texture->h = h;
      texture->r = 255;
      texture->g = 255;
      texture->b = 255;
      texture->a = 255;
      texture->renderer = renderer;
      texture->next = renderer->textures;
      if (renderer->textures) {
          renderer->textures->prev = texture;
      }
      renderer->textures = texture;
  
      if (IsSupportedFormat(renderer, format)) {
          if (renderer->CreateTexture(renderer, texture) < 0) {
              SDL_DestroyTexture(texture);
              return NULL;
          }
      } else {
          texture->native = SDL_CreateTexture(renderer,
                                  GetClosestSupportedFormat(renderer, format),
                                  access, w, h);
          if (!texture->native) {
              SDL_DestroyTexture(texture);
              return NULL;
          }
  
          /* Swap textures to have texture before texture->native in the list */
          texture->native->next = texture->next;
          if (texture->native->next) {
              texture->native->next->prev = texture->native;
          }
          texture->prev = texture->native->prev;
          if (texture->prev) {
              texture->prev->next = texture;
          }
          texture->native->prev = texture;
          texture->next = texture->native;
          renderer->textures = texture;
  
          if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {
              texture->yuv = SDL_SW_CreateYUVTexture(format, w, h);
              if (!texture->yuv) {
                  SDL_DestroyTexture(texture);
                  return NULL;
              }
          } else if (access == SDL_TEXTUREACCESS_STREAMING) {
              /* The pitch is 4 byte aligned */
              texture->pitch = (((w * SDL_BYTESPERPIXEL(format)) + 3) & ~3);
              texture->pixels = SDL_calloc(1, texture->pitch * h);
              if (!texture->pixels) {
                  SDL_DestroyTexture(texture);
                  return NULL;
              }
          }
      }
      return texture;
  }
  
  SDL_Texture *
  SDL_CreateTextureFromSurface(SDL_Renderer * renderer, SDL_Surface * surface)
  {
      const SDL_PixelFormat *fmt;
      SDL_bool needAlpha;
      Uint32 i;
      Uint32 format;
      SDL_Texture *texture;
  
      CHECK_RENDERER_MAGIC(renderer, NULL);
  
      if (!surface) {
          SDL_SetError("SDL_CreateTextureFromSurface() passed NULL surface");
          return NULL;
      }
  
      /* See what the best texture format is */
      fmt = surface->format;
      if (fmt->Amask || SDL_GetColorKey(surface, NULL) == 0) {
          needAlpha = SDL_TRUE;
      } else {
          needAlpha = SDL_FALSE;
      }
      format = renderer->info.texture_formats[0];
      for (i = 0; i < renderer->info.num_texture_formats; ++i) {
          if (!SDL_ISPIXELFORMAT_FOURCC(renderer->info.texture_formats[i]) &&
              SDL_ISPIXELFORMAT_ALPHA(renderer->info.texture_formats[i]) == needAlpha) {
              format = renderer->info.texture_formats[i];
              break;
          }
      }
  
      texture = SDL_CreateTexture(renderer, format, SDL_TEXTUREACCESS_STATIC,
                                  surface->w, surface->h);
      if (!texture) {
          return NULL;
      }
  
      if (format == surface->format->format) {
          if (SDL_MUSTLOCK(surface)) {
              SDL_LockSurface(surface);
              SDL_UpdateTexture(texture, NULL, surface->pixels, surface->pitch);
              SDL_UnlockSurface(surface);
          } else {
              SDL_UpdateTexture(texture, NULL, surface->pixels, surface->pitch);
          }
      } else {
          SDL_PixelFormat *dst_fmt;
          SDL_Surface *temp = NULL;
  
          /* Set up a destination surface for the texture update */
          dst_fmt = SDL_AllocFormat(format);
          if (!dst_fmt) {
             SDL_DestroyTexture(texture);
             return NULL;
          }
          temp = SDL_ConvertSurface(surface, dst_fmt, 0);
          SDL_FreeFormat(dst_fmt);
          if (temp) {
              SDL_UpdateTexture(texture, NULL, temp->pixels, temp->pitch);
              SDL_FreeSurface(temp);
          } else {
              SDL_DestroyTexture(texture);
              return NULL;
          }
      }
  
      {
          Uint8 r, g, b, a;
          SDL_BlendMode blendMode;
  
          SDL_GetSurfaceColorMod(surface, &r, &g, &b);
          SDL_SetTextureColorMod(texture, r, g, b);
  
          SDL_GetSurfaceAlphaMod(surface, &a);
          SDL_SetTextureAlphaMod(texture, a);
  
          if (SDL_GetColorKey(surface, NULL) == 0) {
              /* We converted to a texture with alpha format */
              SDL_SetTextureBlendMode(texture, SDL_BLENDMODE_BLEND);
          } else {
              SDL_GetSurfaceBlendMode(surface, &blendMode);
              SDL_SetTextureBlendMode(texture, blendMode);
          }
      }
      return texture;
  }
  
  int
  SDL_QueryTexture(SDL_Texture * texture, Uint32 * format, int *access,
                   int *w, int *h)
  {
      CHECK_TEXTURE_MAGIC(texture, -1);
  
      if (format) {
          *format = texture->format;
      }
      if (access) {
          *access = texture->access;
      }
      if (w) {
          *w = texture->w;
      }
      if (h) {
          *h = texture->h;
      }
      return 0;
  }
  
  int
  SDL_SetTextureColorMod(SDL_Texture * texture, Uint8 r, Uint8 g, Uint8 b)
  {
      SDL_Renderer *renderer;
  
      CHECK_TEXTURE_MAGIC(texture, -1);
  
      renderer = texture->renderer;
      if (r < 255 || g < 255 || b < 255) {
          texture->modMode |= SDL_TEXTUREMODULATE_COLOR;
      } else {
          texture->modMode &= ~SDL_TEXTUREMODULATE_COLOR;
      }
      texture->r = r;
      texture->g = g;
      texture->b = b;
      if (texture->native) {
          return SDL_SetTextureColorMod(texture->native, r, g, b);
      } else if (renderer->SetTextureColorMod) {
          return renderer->SetTextureColorMod(renderer, texture);
      } else {
          return 0;
      }
  }
  
  int
  SDL_GetTextureColorMod(SDL_Texture * texture, Uint8 * r, Uint8 * g,
                         Uint8 * b)
  {
      CHECK_TEXTURE_MAGIC(texture, -1);
  
      if (r) {
          *r = texture->r;
      }
      if (g) {
          *g = texture->g;
      }
      if (b) {
          *b = texture->b;
      }
      return 0;
  }
  
  int
  SDL_SetTextureAlphaMod(SDL_Texture * texture, Uint8 alpha)
  {
      SDL_Renderer *renderer;
  
      CHECK_TEXTURE_MAGIC(texture, -1);
  
      renderer = texture->renderer;
      if (alpha < 255) {
          texture->modMode |= SDL_TEXTUREMODULATE_ALPHA;
      } else {
          texture->modMode &= ~SDL_TEXTUREMODULATE_ALPHA;
      }
      texture->a = alpha;
      if (texture->native) {
          return SDL_SetTextureAlphaMod(texture->native, alpha);
      } else if (renderer->SetTextureAlphaMod) {
          return renderer->SetTextureAlphaMod(renderer, texture);
      } else {
          return 0;
      }
  }
  
  int
  SDL_GetTextureAlphaMod(SDL_Texture * texture, Uint8 * alpha)
  {
      CHECK_TEXTURE_MAGIC(texture, -1);
  
      if (alpha) {
          *alpha = texture->a;
      }
      return 0;
  }
  
  int
  SDL_SetTextureBlendMode(SDL_Texture * texture, SDL_BlendMode blendMode)
  {
      SDL_Renderer *renderer;
  
      CHECK_TEXTURE_MAGIC(texture, -1);
  
      renderer = texture->renderer;
      texture->blendMode = blendMode;
      if (texture->native) {
          return SDL_SetTextureBlendMode(texture->native, blendMode);
      } else if (renderer->SetTextureBlendMode) {
          return renderer->SetTextureBlendMode(renderer, texture);
      } else {
          return 0;
      }
  }
  
  int
  SDL_GetTextureBlendMode(SDL_Texture * texture, SDL_BlendMode *blendMode)
  {
      CHECK_TEXTURE_MAGIC(texture, -1);
  
      if (blendMode) {
          *blendMode = texture->blendMode;
      }
      return 0;
  }
  
  static int
  SDL_UpdateTextureYUV(SDL_Texture * texture, const SDL_Rect * rect,
                       const void *pixels, int pitch)
  {
      SDL_Texture *native = texture->native;
      SDL_Rect full_rect;
  
      if (SDL_SW_UpdateYUVTexture(texture->yuv, rect, pixels, pitch) < 0) {
          return -1;
      }
  
      full_rect.x = 0;
      full_rect.y = 0;
      full_rect.w = texture->w;
      full_rect.h = texture->h;
      rect = &full_rect;
  
      if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
          /* We can lock the texture and copy to it */
          void *native_pixels;
          int native_pitch;
  
          if (SDL_LockTexture(native, rect, &native_pixels, &native_pitch) < 0) {
              return -1;
          }
          SDL_SW_CopyYUVToRGB(texture->yuv, rect, native->format,
                              rect->w, rect->h, native_pixels, native_pitch);
          SDL_UnlockTexture(native);
      } else {
          /* Use a temporary buffer for updating */
          void *temp_pixels;
          int temp_pitch;
  
          temp_pitch = (((rect->w * SDL_BYTESPERPIXEL(native->format)) + 3) & ~3);
          temp_pixels = SDL_malloc(rect->h * temp_pitch);
          if (!temp_pixels) {
              return SDL_OutOfMemory();
          }
          SDL_SW_CopyYUVToRGB(texture->yuv, rect, native->format,
                              rect->w, rect->h, temp_pixels, temp_pitch);
          SDL_UpdateTexture(native, rect, temp_pixels, temp_pitch);
          SDL_free(temp_pixels);
      }
      return 0;
  }
  
  static int
  SDL_UpdateTextureNative(SDL_Texture * texture, const SDL_Rect * rect,
                          const void *pixels, int pitch)
  {
      SDL_Texture *native = texture->native;
  
      if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
          /* We can lock the texture and copy to it */
          void *native_pixels;
          int native_pitch;
  
          if (SDL_LockTexture(native, rect, &native_pixels, &native_pitch) < 0) {
              return -1;
          }
          SDL_ConvertPixels(rect->w, rect->h,
                            texture->format, pixels, pitch,
                            native->format, native_pixels, native_pitch);
          SDL_UnlockTexture(native);
      } else {
          /* Use a temporary buffer for updating */
          void *temp_pixels;
          int temp_pitch;
  
          temp_pitch = (((rect->w * SDL_BYTESPERPIXEL(native->format)) + 3) & ~3);
          temp_pixels = SDL_malloc(rect->h * temp_pitch);
          if (!temp_pixels) {
              return SDL_OutOfMemory();
          }
          SDL_ConvertPixels(rect->w, rect->h,
                            texture->format, pixels, pitch,
                            native->format, temp_pixels, temp_pitch);
          SDL_UpdateTexture(native, rect, temp_pixels, temp_pitch);
          SDL_free(temp_pixels);
      }
      return 0;
  }
  
  int
  SDL_UpdateTexture(SDL_Texture * texture, const SDL_Rect * rect,
                    const void *pixels, int pitch)
  {
      SDL_Renderer *renderer;
      SDL_Rect full_rect;
  
      CHECK_TEXTURE_MAGIC(texture, -1);
  
      if (!pixels) {
          return SDL_InvalidParamError("pixels");
      }
      if (!pitch) {
          return SDL_InvalidParamError("pitch");
      }
  
      if (!rect) {
          full_rect.x = 0;
          full_rect.y = 0;
          full_rect.w = texture->w;
          full_rect.h = texture->h;
          rect = &full_rect;
      }
  
      if ((rect->w == 0) || (rect->h == 0)) {
          return 0;  /* nothing to do. */
      } else if (texture->yuv) {
          return SDL_UpdateTextureYUV(texture, rect, pixels, pitch);
      } else if (texture->native) {
          return SDL_UpdateTextureNative(texture, rect, pixels, pitch);
      } else {
          renderer = texture->renderer;
          return renderer->UpdateTexture(renderer, texture, rect, pixels, pitch);
      }
  }
  
  static int
  SDL_UpdateTextureYUVPlanar(SDL_Texture * texture, const SDL_Rect * rect,
                             const Uint8 *Yplane, int Ypitch,
                             const Uint8 *Uplane, int Upitch,
                             const Uint8 *Vplane, int Vpitch)
  {
      SDL_Texture *native = texture->native;
      SDL_Rect full_rect;
  
      if (SDL_SW_UpdateYUVTexturePlanar(texture->yuv, rect, Yplane, Ypitch, Uplane, Upitch, Vplane, Vpitch) < 0) {
          return -1;
      }
  
      full_rect.x = 0;
      full_rect.y = 0;
      full_rect.w = texture->w;
      full_rect.h = texture->h;
      rect = &full_rect;
  
      if (texture->access == SDL_TEXTUREACCESS_STREAMING) {
          /* We can lock the texture and copy to it */
          void *native_pixels;
          int native_pitch;
  
          if (SDL_LockTexture(native, rect, &native_pixels, &native_pitch) < 0) {
              return -1;
          }
          SDL_SW_CopyYUVToRGB(texture->yuv, rect, native->format,
                              rect->w, rect->h, native_pixels, native_pitch);
          SDL_UnlockTexture(native);
      } else {
          /* Use a temporary buffer for updating */
          void *temp_pixels;
          int temp_pitch;
  
          temp_pitch = (((rect->w * SDL_BYTESPERPIXEL(native->format)) + 3) & ~3);
          temp_pixels = SDL_malloc(rect->h * temp_pitch);
          if (!temp_pixels) {
              return SDL_OutOfMemory();
          }
          SDL_SW_CopyYUVToRGB(texture->yuv, rect, native->format,
                              rect->w, rect->h, temp_pixels, temp_pitch);
          SDL_UpdateTexture(native, rect, temp_pixels, temp_pitch);
          SDL_free(temp_pixels);
      }
      return 0;
  }
  
  int SDL_UpdateYUVTexture(SDL_Texture * texture, const SDL_Rect * rect,
                           const Uint8 *Yplane, int Ypitch,
                           const Uint8 *Uplane, int Upitch,
                           const Uint8 *Vplane, int Vpitch)
  {
      SDL_Renderer *renderer;
      SDL_Rect full_rect;
  
      CHECK_TEXTURE_MAGIC(texture, -1);
  
      if (!Yplane) {
          return SDL_InvalidParamError("Yplane");
      }
      if (!Ypitch) {
          return SDL_InvalidParamError("Ypitch");
      }
      if (!Uplane) {
          return SDL_InvalidParamError("Uplane");
      }
      if (!Upitch) {
          return SDL_InvalidParamError("Upitch");
      }
      if (!Vplane) {
          return SDL_InvalidParamError("Vplane");
      }
      if (!Vpitch) {
          return SDL_InvalidParamError("Vpitch");
      }
  
      if (texture->format != SDL_PIXELFORMAT_YV12 &&
          texture->format != SDL_PIXELFORMAT_IYUV) {
          return SDL_SetError("Texture format must by YV12 or IYUV");
      }
  
      if (!rect) {
          full_rect.x = 0;
          full_rect.y = 0;
          full_rect.w = texture->w;
          full_rect.h = texture->h;
          rect = &full_rect;
      }
  
      if (texture->yuv) {
          return SDL_UpdateTextureYUVPlanar(texture, rect, Yplane, Ypitch, Uplane, Upitch, Vplane, Vpitch);
      } else {
          SDL_assert(!texture->native);
          renderer = texture->renderer;
          SDL_assert(renderer->UpdateTextureYUV);
          if (renderer->UpdateTextureYUV) {
              return renderer->UpdateTextureYUV(renderer, texture, rect, Yplane, Ypitch, Uplane, Upitch, Vplane, Vpitch);
          } else {
              return SDL_Unsupported();
          }
      }
  }
  
  static int
  SDL_LockTextureYUV(SDL_Texture * texture, const SDL_Rect * rect,
                     void **pixels, int *pitch)
  {
      return SDL_SW_LockYUVTexture(texture->yuv, rect, pixels, pitch);
  }
  
  static int
  SDL_LockTextureNative(SDL_Texture * texture, const SDL_Rect * rect,
                        void **pixels, int *pitch)
  {
      texture->locked_rect = *rect;
      *pixels = (void *) ((Uint8 *) texture->pixels +
                          rect->y * texture->pitch +
                          rect->x * SDL_BYTESPERPIXEL(texture->format));
      *pitch = texture->pitch;
      return 0;
  }
  
  int
  SDL_LockTexture(SDL_Texture * texture, const SDL_Rect * rect,
                  void **pixels, int *pitch)
  {
      SDL_Renderer *renderer;
      SDL_Rect full_rect;
  
      CHECK_TEXTURE_MAGIC(texture, -1);
  
      if (texture->access != SDL_TEXTUREACCESS_STREAMING) {
          return SDL_SetError("SDL_LockTexture(): texture must be streaming");
      }
  
      if (!rect) {
          full_rect.x = 0;
          full_rect.y = 0;
          full_rect.w = texture->w;
          full_rect.h = texture->h;
          rect = &full_rect;
      }
  
      if (texture->yuv) {
          return SDL_LockTextureYUV(texture, rect, pixels, pitch);
      } else if (texture->native) {
          return SDL_LockTextureNative(texture, rect, pixels, pitch);
      } else {
          renderer = texture->renderer;
          return renderer->LockTexture(renderer, texture, rect, pixels, pitch);
      }
  }
  
  static void
  SDL_UnlockTextureYUV(SDL_Texture * texture)
  {
      SDL_Texture *native = texture->native;
      void *native_pixels = NULL;
      int native_pitch = 0;
      SDL_Rect rect;
  
      rect.x = 0;
      rect.y = 0;
      rect.w = texture->w;
      rect.h = texture->h;
  
      if (SDL_LockTexture(native, &rect, &native_pixels, &native_pitch) < 0) {
          return;
      }
      SDL_SW_CopyYUVToRGB(texture->yuv, &rect, native->format,
                          rect.w, rect.h, native_pixels, native_pitch);
      SDL_UnlockTexture(native);
  }
  
  static void
  SDL_UnlockTextureNative(SDL_Texture * texture)
  {
      SDL_Texture *native = texture->native;
      void *native_pixels = NULL;
      int native_pitch = 0;
      const SDL_Rect *rect = &texture->locked_rect;
      const void* pixels = (void *) ((Uint8 *) texture->pixels +
                          rect->y * texture->pitch +
                          rect->x * SDL_BYTESPERPIXEL(texture->format));
      int pitch = texture->pitch;
  
      if (SDL_LockTexture(native, rect, &native_pixels, &native_pitch) < 0) {
          return;
      }
      SDL_ConvertPixels(rect->w, rect->h,
                        texture->format, pixels, pitch,
                        native->format, native_pixels, native_pitch);
      SDL_UnlockTexture(native);
  }
  
  void
  SDL_UnlockTexture(SDL_Texture * texture)
  {
      SDL_Renderer *renderer;
  
      CHECK_TEXTURE_MAGIC(texture, );
  
      if (texture->access != SDL_TEXTUREACCESS_STREAMING) {
          return;
      }
      if (texture->yuv) {
          SDL_UnlockTextureYUV(texture);
      } else if (texture->native) {
          SDL_UnlockTextureNative(texture);
      } else {
          renderer = texture->renderer;
          renderer->UnlockTexture(renderer, texture);
      }
  }
  
  SDL_bool
  SDL_RenderTargetSupported(SDL_Renderer *renderer)
  {
      if (!renderer || !renderer->SetRenderTarget) {
          return SDL_FALSE;
      }
      return (renderer->info.flags & SDL_RENDERER_TARGETTEXTURE) != 0;
  }
  
  int
  SDL_SetRenderTarget(SDL_Renderer *renderer, SDL_Texture *texture)
  {
      if (!SDL_RenderTargetSupported(renderer)) {
          return SDL_Unsupported();
      }
      if (texture == renderer->target) {
          /* Nothing to do! */
          return 0;
      }
  
      /* texture == NULL is valid and means reset the target to the window */
      if (texture) {
          CHECK_TEXTURE_MAGIC(texture, -1);
          if (renderer != texture->renderer) {
              return SDL_SetError("Texture was not created with this renderer");
          }
          if (texture->access != SDL_TEXTUREACCESS_TARGET) {
              return SDL_SetError("Texture not created with SDL_TEXTUREACCESS_TARGET");
          }
          if (texture->native) {
              /* Always render to the native texture */
              texture = texture->native;
          }
      }
  
      if (texture && !renderer->target) {
          /* Make a backup of the viewport */
          renderer->viewport_backup = renderer->viewport;
          renderer->clip_rect_backup = renderer->clip_rect;
          renderer->clipping_enabled_backup = renderer->clipping_enabled;
          renderer->scale_backup = renderer->scale;
          renderer->logical_w_backup = renderer->logical_w;
          renderer->logical_h_backup = renderer->logical_h;
      }
      renderer->target = texture;
  
      if (renderer->SetRenderTarget(renderer, texture) < 0) {
          return -1;
      }
  
      if (texture) {
          renderer->viewport.x = 0;
          renderer->viewport.y = 0;
          renderer->viewport.w = texture->w;
          renderer->viewport.h = texture->h;
          SDL_zero(renderer->clip_rect);
          renderer->clipping_enabled = SDL_FALSE;
          renderer->scale.x = 1.0f;
          renderer->scale.y = 1.0f;
          renderer->logical_w = texture->w;
          renderer->logical_h = texture->h;
      } else {
          renderer->viewport = renderer->viewport_backup;
          renderer->clip_rect = renderer->clip_rect_backup;
          renderer->clipping_enabled = renderer->clipping_enabled_backup;
          renderer->scale = renderer->scale_backup;
          renderer->logical_w = renderer->logical_w_backup;
          renderer->logical_h = renderer->logical_h_backup;
      }
      if (renderer->UpdateViewport(renderer) < 0) {
          return -1;
      }
      if (renderer->UpdateClipRect(renderer) < 0) {
          return -1;
      }
  
      /* All set! */
      return 0;
  }
  
  SDL_Texture *
  SDL_GetRenderTarget(SDL_Renderer *renderer)
  {
      return renderer->target;
  }
  
  static int
  UpdateLogicalSize(SDL_Renderer *renderer)
  {
      int w = 1, h = 1;
      float want_aspect;
      float real_aspect;
      float scale;
      SDL_Rect viewport;
  
      if (!renderer->logical_w || !renderer->logical_h) {
          return 0;
      }
      if (SDL_GetRendererOutputSize(renderer, &w, &h) < 0) {
          return -1;
      }
  
      want_aspect = (float)renderer->logical_w / renderer->logical_h;
      real_aspect = (float)w / h;
  
      /* Clear the scale because we're setting viewport in output coordinates */
      SDL_RenderSetScale(renderer, 1.0f, 1.0f);
  
      if (renderer->integer_scale) {
          if (want_aspect > real_aspect) {
              scale = (float)(w / renderer->logical_w);
          } else {
              scale = (float)(h / renderer->logical_h);
          }
          viewport.w = (int)SDL_ceil(renderer->logical_w * scale);
          viewport.x = (w - viewport.w) / 2;
          viewport.h = (int)SDL_ceil(renderer->logical_h * scale);
          viewport.y = (h - viewport.h) / 2;
  
          SDL_RenderSetViewport(renderer, &viewport);
      } else if (SDL_fabs(want_aspect-real_aspect) < 0.0001) {
          /* The aspect ratios are the same, just scale appropriately */
          scale = (float)w / renderer->logical_w;
          SDL_RenderSetViewport(renderer, NULL);
      } else if (want_aspect > real_aspect) {
          /* We want a wider aspect ratio than is available - letterbox it */
          scale = (float)w / renderer->logical_w;
          viewport.x = 0;
          viewport.w = w;
          viewport.h = (int)SDL_ceil(renderer->logical_h * scale);
          viewport.y = (h - viewport.h) / 2;
          SDL_RenderSetViewport(renderer, &viewport);
      } else {
          /* We want a narrower aspect ratio than is available - use side-bars */
          scale = (float)h / renderer->logical_h;
          viewport.y = 0;
          viewport.h = h;
          viewport.w = (int)SDL_ceil(renderer->logical_w * scale);
          viewport.x = (w - viewport.w) / 2;
          SDL_RenderSetViewport(renderer, &viewport);
      }
  
      /* Set the new scale */
      SDL_RenderSetScale(renderer, scale, scale);
  
      return 0;
  }
  
  int
  SDL_RenderSetLogicalSize(SDL_Renderer * renderer, int w, int h)
  {
      CHECK_RENDERER_MAGIC(renderer, -1);
  
      if (!w || !h) {
          /* Clear any previous logical resolution */
          renderer->logical_w = 0;
          renderer->logical_h = 0;
          SDL_RenderSetViewport(renderer, NULL);
          SDL_RenderSetScale(renderer, 1.0f, 1.0f);
          return 0;
      }
  
      renderer->logical_w = w;
      renderer->logical_h = h;
  
      return UpdateLogicalSize(renderer);
  }
  
  void
  SDL_RenderGetLogicalSize(SDL_Renderer * renderer, int *w, int *h)
  {
      CHECK_RENDERER_MAGIC(renderer, );
  
      if (w) {
          *w = renderer->logical_w;
      }
      if (h) {
          *h = renderer->logical_h;
      }
  }
  
  int
  SDL_RenderSetIntegerScale(SDL_Renderer * renderer, SDL_bool enable)
  {
      CHECK_RENDERER_MAGIC(renderer, -1);
  
      renderer->integer_scale = enable;
  
      return UpdateLogicalSize(renderer);
  }
  
  SDL_bool
  SDLCALL SDL_RenderGetIntegerScale(SDL_Renderer * renderer)
  {
      CHECK_RENDERER_MAGIC(renderer, SDL_FALSE);
  
      return renderer->integer_scale;
  }
  
  int
  SDL_RenderSetViewport(SDL_Renderer * renderer, const SDL_Rect * rect)
  {
      CHECK_RENDERER_MAGIC(renderer, -1);
  
      if (rect) {
          renderer->viewport.x = (int)SDL_floor(rect->x * renderer->scale.x);
          renderer->viewport.y = (int)SDL_floor(rect->y * renderer->scale.y);
          renderer->viewport.w = (int)SDL_ceil(rect->w * renderer->scale.x);
          renderer->viewport.h = (int)SDL_ceil(rect->h * renderer->scale.y);
      } else {
          renderer->viewport.x = 0;
          renderer->viewport.y = 0;
          if (SDL_GetRendererOutputSize(renderer, &renderer->viewport.w, &renderer->viewport.h) < 0) {
              return -1;
          }
      }
      return renderer->UpdateViewport(renderer);
  }
  
  void
  SDL_RenderGetViewport(SDL_Renderer * renderer, SDL_Rect * rect)
  {
      CHECK_RENDERER_MAGIC(renderer, );
  
      if (rect) {
          rect->x = (int)(renderer->viewport.x / renderer->scale.x);
          rect->y = (int)(renderer->viewport.y / renderer->scale.y);
          rect->w = (int)(renderer->viewport.w / renderer->scale.x);
          rect->h = (int)(renderer->viewport.h / renderer->scale.y);
      }
  }
  
  int
  SDL_RenderSetClipRect(SDL_Renderer * renderer, const SDL_Rect * rect)
  {
      CHECK_RENDERER_MAGIC(renderer, -1)
  
      if (rect) {
          renderer->clipping_enabled = SDL_TRUE;
          renderer->clip_rect.x = (int)SDL_floor(rect->x * renderer->scale.x);
          renderer->clip_rect.y = (int)SDL_floor(rect->y * renderer->scale.y);
          renderer->clip_rect.w = (int)SDL_ceil(rect->w * renderer->scale.x);
          renderer->clip_rect.h = (int)SDL_ceil(rect->h * renderer->scale.y);
      } else {
          renderer->clipping_enabled = SDL_FALSE;
          SDL_zero(renderer->clip_rect);
      }
      return renderer->UpdateClipRect(renderer);
  }
  
  void
  SDL_RenderGetClipRect(SDL_Renderer * renderer, SDL_Rect * rect)
  {
      CHECK_RENDERER_MAGIC(renderer, )
  
      if (rect) {
          rect->x = (int)(renderer->clip_rect.x / renderer->scale.x);
          rect->y = (int)(renderer->clip_rect.y / renderer->scale.y);
          rect->w = (int)(renderer->clip_rect.w / renderer->scale.x);
          rect->h = (int)(renderer->clip_rect.h / renderer->scale.y);
      }
  }
  
  SDL_bool
  SDL_RenderIsClipEnabled(SDL_Renderer * renderer)
  {
      CHECK_RENDERER_MAGIC(renderer, SDL_FALSE)
      return renderer->clipping_enabled;
  }
  
  int
  SDL_RenderSetScale(SDL_Renderer * renderer, float scaleX, float scaleY)
  {
      CHECK_RENDERER_MAGIC(renderer, -1);
  
      renderer->scale.x = scaleX;
      renderer->scale.y = scaleY;
      return 0;
  }
  
  void
  SDL_RenderGetScale(SDL_Renderer * renderer, float *scaleX, float *scaleY)
  {
      CHECK_RENDERER_MAGIC(renderer, );
  
      if (scaleX) {
          *scaleX = renderer->scale.x;
      }
      if (scaleY) {
          *scaleY = renderer->scale.y;
      }
  }
  
  int
  SDL_SetRenderDrawColor(SDL_Renderer * renderer,
                         Uint8 r, Uint8 g, Uint8 b, Uint8 a)
  {
      CHECK_RENDERER_MAGIC(renderer, -1);
  
      renderer->r = r;
      renderer->g = g;
      renderer->b = b;
      renderer->a = a;
      return 0;
  }
  
  int
  SDL_GetRenderDrawColor(SDL_Renderer * renderer,
                         Uint8 * r, Uint8 * g, Uint8 * b, Uint8 * a)
  {
      CHECK_RENDERER_MAGIC(renderer, -1);
  
      if (r) {
          *r = renderer->r;
      }
      if (g) {
          *g = renderer->g;
      }
      if (b) {
          *b = renderer->b;
      }
      if (a) {
          *a = renderer->a;
      }
      return 0;
  }
  
  int
  SDL_SetRenderDrawBlendMode(SDL_Renderer * renderer, SDL_BlendMode blendMode)
  {
      CHECK_RENDERER_MAGIC(renderer, -1);
  
      renderer->blendMode = blendMode;
      return 0;
  }
  
  int
  SDL_GetRenderDrawBlendMode(SDL_Renderer * renderer, SDL_BlendMode *blendMode)
  {
      CHECK_RENDERER_MAGIC(renderer, -1);
  
      *blendMode = renderer->blendMode;
      return 0;
  }
  
  int
  SDL_RenderClear(SDL_Renderer * renderer)
  {
      CHECK_RENDERER_MAGIC(renderer, -1);
  
      /* Don't draw while we're hidden */
      if (renderer->hidden) {
          return 0;
      }
      return renderer->RenderClear(renderer);
  }
  
  int
  SDL_RenderDrawPoint(SDL_Renderer * renderer, int x, int y)
  {
      SDL_Point point;
  
      point.x = x;
      point.y = y;
      return SDL_RenderDrawPoints(renderer, &point, 1);
  }
  
  static int
  RenderDrawPointsWithRects(SDL_Renderer * renderer,
                       const SDL_Point * points, int count)
  {
      SDL_FRect *frects;
      int i;
      int status;
  
      frects = SDL_stack_alloc(SDL_FRect, count);
      if (!frects) {
          return SDL_OutOfMemory();
      }
      for (i = 0; i < count; ++i) {
          frects[i].x = points[i].x * renderer->scale.x;
          frects[i].y = points[i].y * renderer->scale.y;
          frects[i].w = renderer->scale.x;
          frects[i].h = renderer->scale.y;
      }
  
      status = renderer->RenderFillRects(renderer, frects, count);
  
      SDL_stack_free(frects);
  
      return status;
  }
  
  int
  SDL_RenderDrawPoints(SDL_Renderer * renderer,
                       const SDL_Point * points, int count)
  {
      SDL_FPoint *fpoints;
      int i;
      int status;
  
      CHECK_RENDERER_MAGIC(renderer, -1);
  
      if (!points) {
          return SDL_SetError("SDL_RenderDrawPoints(): Passed NULL points");
      }
      if (count < 1) {
          return 0;
      }
  
      /* Don't draw while we're hidden */
      if (renderer->hidden) {
          return 0;
      }
  
      if (renderer->scale.x != 1.0f || renderer->scale.y != 1.0f) {
          return RenderDrawPointsWithRects(renderer, points, count);
      }
  
      fpoints = SDL_stack_alloc(SDL_FPoint, count);
      if (!fpoints) {
          return SDL_OutOfMemory();
      }
      for (i = 0; i < count; ++i) {
          fpoints[i].x = points[i].x * renderer->scale.x;
          fpoints[i].y = points[i].y * renderer->scale.y;
      }
  
      status = renderer->RenderDrawPoints(renderer, fpoints, count);
  
      SDL_stack_free(fpoints);
  
      return status;
  }
  
  int
  SDL_RenderDrawLine(SDL_Renderer * renderer, int x1, int y1, int x2, int y2)
  {
      SDL_Point points[2];
  
      points[0].x = x1;
      points[0].y = y1;
      points[1].x = x2;
      points[1].y = y2;
      return SDL_RenderDrawLines(renderer, points, 2);
  }
  
  static int
  RenderDrawLinesWithRects(SDL_Renderer * renderer,
                       const SDL_Point * points, int count)
  {
      SDL_FRect *frect;
      SDL_FRect *frects;
      SDL_FPoint fpoints[2];
      int i, nrects;
      int status;
  
      frects = SDL_stack_alloc(SDL_FRect, count-1);
      if (!frects) {
          return SDL_OutOfMemory();
      }
  
      status = 0;
      nrects = 0;
      for (i = 0; i < count-1; ++i) {
          if (points[i].x == points[i+1].x) {
              int minY = SDL_min(points[i].y, points[i+1].y);
              int maxY = SDL_max(points[i].y, points[i+1].y);
  
              frect = &frects[nrects++];
              frect->x = points[i].x * renderer->scale.x;
              frect->y = minY * renderer->scale.y;
              frect->w = renderer->scale.x;
              frect->h = (maxY - minY + 1) * renderer->scale.y;
          } else if (points[i].y == points[i+1].y) {
              int minX = SDL_min(points[i].x, points[i+1].x);
              int maxX = SDL_max(points[i].x, points[i+1].x);
  
              frect = &frects[nrects++];
              frect->x = minX * renderer->scale.x;
              frect->y = points[i].y * renderer->scale.y;
              frect->w = (maxX - minX + 1) * renderer->scale.x;
              frect->h = renderer->scale.y;
          } else {
              /* FIXME: We can't use a rect for this line... */
              fpoints[0].x = points[i].x * renderer->scale.x;
              fpoints[0].y = points[i].y * renderer->scale.y;
              fpoints[1].x = points[i+1].x * renderer->scale.x;
              fpoints[1].y = points[i+1].y * renderer->scale.y;
              status += renderer->RenderDrawLines(renderer, fpoints, 2);
          }
      }
  
      status += renderer->RenderFillRects(renderer, frects, nrects);
  
      SDL_stack_free(frects);
  
      if (status < 0) {
          status = -1;
      }
      return status;
  }
  
  int
  SDL_RenderDrawLines(SDL_Renderer * renderer,
                      const SDL_Point * points, int count)
  {
      SDL_FPoint *fpoints;
      int i;
      int status;
  
      CHECK_RENDERER_MAGIC(renderer, -1);
  
      if (!points) {
          return SDL_SetError("SDL_RenderDrawLines(): Passed NULL points");
      }
      if (count < 2) {
          return 0;
      }
  
      /* Don't draw while we're hidden */
      if (renderer->hidden) {
          return 0;
      }
  
      if (renderer->scale.x != 1.0f || renderer->scale.y != 1.0f) {
          return RenderDrawLinesWithRects(renderer, points, count);
      }
  
      fpoints = SDL_stack_alloc(SDL_FPoint, count);
      if (!fpoints) {
          return SDL_OutOfMemory();
      }
      for (i = 0; i < count; ++i) {
          fpoints[i].x = points[i].x * renderer->scale.x;
          fpoints[i].y = points[i].y * renderer->scale.y;
      }
  
      status = renderer->RenderDrawLines(renderer, fpoints, count);
  
      SDL_stack_free(fpoints);
  
      return status;
  }
  
  int
  SDL_RenderDrawRect(SDL_Renderer * renderer, const SDL_Rect * rect)
  {
      SDL_Rect full_rect;
      SDL_Point points[5];
  
      CHECK_RENDERER_MAGIC(renderer, -1);
  
      /* If 'rect' == NULL, then outline the whole surface */
      if (!rect) {
          SDL_RenderGetViewport(renderer, &full_rect);
          full_rect.x = 0;
          full_rect.y = 0;
          rect = &full_rect;
      }
  
      points[0].x = rect->x;
      points[0].y = rect->y;
      points[1].x = rect->x+rect->w-1;
      points[1].y = rect->y;
      points[2].x = rect->x+rect->w-1;
      points[2].y = rect->y+rect->h-1;
      points[3].x = rect->x;
      points[3].y = rect->y+rect->h-1;
      points[4].x = rect->x;
      points[4].y = rect->y;
      return SDL_RenderDrawLines(renderer, points, 5);
  }
  
  int
  SDL_RenderDrawRects(SDL_Renderer * renderer,
                      const SDL_Rect * rects, int count)
  {
      int i;
  
      CHECK_RENDERER_MAGIC(renderer, -1);
  
      if (!rects) {
          return SDL_SetError("SDL_RenderDrawRects(): Passed NULL rects");
      }
      if (count < 1) {
          return 0;
      }
  
      /* Don't draw while we're hidden */
      if (renderer->hidden) {
          return 0;
      }
  
      for (i = 0; i < count; ++i) {
          if (SDL_RenderDrawRect(renderer, &rects[i]) < 0) {
              return -1;
          }
      }
      return 0;
  }
  
  int
  SDL_RenderFillRect(SDL_Renderer * renderer, const SDL_Rect * rect)
  {
      SDL_Rect full_rect = { 0, 0, 0, 0 };
  
      CHECK_RENDERER_MAGIC(renderer, -1);
  
      /* If 'rect' == NULL, then outline the whole surface */
      if (!rect) {
          SDL_RenderGetViewport(renderer, &full_rect);
          full_rect.x = 0;
          full_rect.y = 0;
          rect = &full_rect;
      }
      return SDL_RenderFillRects(renderer, rect, 1);
  }
  
  int
  SDL_RenderFillRects(SDL_Renderer * renderer,
                      const SDL_Rect * rects, int count)
  {
      SDL_FRect *frects;
      int i;
      int status;
  
      CHECK_RENDERER_MAGIC(renderer, -1);
  
      if (!rects) {
          return SDL_SetError("SDL_RenderFillRects(): Passed NULL rects");
      }
      if (count < 1) {
          return 0;
      }
  
      /* Don't draw while we're hidden */
      if (renderer->hidden) {
          return 0;
      }
  
      frects = SDL_stack_alloc(SDL_FRect, count);
      if (!frects) {
          return SDL_OutOfMemory();
      }
      for (i = 0; i < count; ++i) {
          frects[i].x = rects[i].x * renderer->scale.x;
          frects[i].y = rects[i].y * renderer->scale.y;
          frects[i].w = rects[i].w * renderer->scale.x;
          frects[i].h = rects[i].h * renderer->scale.y;
      }
  
      status = renderer->RenderFillRects(renderer, frects, count);
  
      SDL_stack_free(frects);
  
      return status;
  }
  
  int
  SDL_RenderCopy(SDL_Renderer * renderer, SDL_Texture * texture,
                 const SDL_Rect * srcrect, const SDL_Rect * dstrect)
  {
      SDL_Rect real_srcrect = { 0, 0, 0, 0 };
      SDL_Rect real_dstrect = { 0, 0, 0, 0 };
      SDL_FRect frect;
  
      CHECK_RENDERER_MAGIC(renderer, -1);
      CHECK_TEXTURE_MAGIC(texture, -1);
  
      if (renderer != texture->renderer) {
          return SDL_SetError("Texture was not created with this renderer");
      }
  
      /* Don't draw while we're hidden */
      if (renderer->hidden) {
          return 0;
      }
  
      real_srcrect.x = 0;
      real_srcrect.y = 0;
      real_srcrect.w = texture->w;
      real_srcrect.h = texture->h;
      if (srcrect) {
          if (!SDL_IntersectRect(srcrect, &real_srcrect, &real_srcrect)) {
              return 0;
          }
      }
  
      SDL_RenderGetViewport(renderer, &real_dstrect);
      real_dstrect.x = 0;
      real_dstrect.y = 0;
      if (dstrect) {
          if (!SDL_HasIntersection(dstrect, &real_dstrect)) {
              return 0;
          }
          real_dstrect = *dstrect;
      }
  
      if (texture->native) {
          texture = texture->native;
      }
  
      frect.x = real_dstrect.x * renderer->scale.x;
      frect.y = real_dstrect.y * renderer->scale.y;
      frect.w = real_dstrect.w * renderer->scale.x;
      frect.h = real_dstrect.h * renderer->scale.y;
  
      return renderer->RenderCopy(renderer, texture, &real_srcrect, &frect);
  }
  
  
  int
  SDL_RenderCopyEx(SDL_Renderer * renderer, SDL_Texture * texture,
                 const SDL_Rect * srcrect, const SDL_Rect * dstrect,
                 const double angle, const SDL_Point *center, const SDL_RendererFlip flip)
  {
      SDL_Rect real_srcrect = { 0, 0, 0, 0 };
      SDL_Rect real_dstrect = { 0, 0, 0, 0 };
      SDL_Point real_center;
      SDL_FRect frect;
      SDL_FPoint fcenter;
  
      if (flip == SDL_FLIP_NONE && (int)(angle/360) == angle/360) { /* fast path when we don't need rotation or flipping */
          return SDL_RenderCopy(renderer, texture, srcrect, dstrect);
      }
  
      CHECK_RENDERER_MAGIC(renderer, -1);
      CHECK_TEXTURE_MAGIC(texture, -1);
  
      if (renderer != texture->renderer) {
          return SDL_SetError("Texture was not created with this renderer");
      }
      if (!renderer->RenderCopyEx) {
          return SDL_SetError("Renderer does not support RenderCopyEx");
      }
  
      /* Don't draw while we're hidden */
      if (renderer->hidden) {
          return 0;
      }
  
      real_srcrect.x = 0;
      real_srcrect.y = 0;
      real_srcrect.w = texture->w;
      real_srcrect.h = texture->h;
      if (srcrect) {
          if (!SDL_IntersectRect(srcrect, &real_srcrect, &real_srcrect)) {
              return 0;
          }
      }
  
      /* We don't intersect the dstrect with the viewport as RenderCopy does because of potential rotation clipping issues... TODO: should we? */
      if (dstrect) {
          real_dstrect = *dstrect;
      } else {
          SDL_RenderGetViewport(renderer, &real_dstrect);
          real_dstrect.x = 0;
          real_dstrect.y = 0;
      }
  
      if (texture->native) {
          texture = texture->native;
      }
  
      if (center) {
          real_center = *center;
      } else {
          real_center.x = real_dstrect.w/2;
          real_center.y = real_dstrect.h/2;
      }
  
      frect.x = real_dstrect.x * renderer->scale.x;
      frect.y = real_dstrect.y * renderer->scale.y;
      frect.w = real_dstrect.w * renderer->scale.x;
      frect.h = real_dstrect.h * renderer->scale.y;
  
      fcenter.x = real_center.x * renderer->scale.x;
      fcenter.y = real_center.y * renderer->scale.y;
  
      return renderer->RenderCopyEx(renderer, texture, &real_srcrect, &frect, angle, &fcenter, flip);
  }
  
  int
  SDL_RenderReadPixels(SDL_Renderer * renderer, const SDL_Rect * rect,
                       Uint32 format, void * pixels, int pitch)
  {
      SDL_Rect real_rect;
  
      CHECK_RENDERER_MAGIC(renderer, -1);
  
      if (!renderer->RenderReadPixels) {
          return SDL_Unsupported();
      }
  
      if (!format) {
          format = SDL_GetWindowPixelFormat(renderer->window);
      }
  
      real_rect.x = renderer->viewport.x;
      real_rect.y = renderer->viewport.y;
      real_rect.w = renderer->viewport.w;
      real_rect.h = renderer->viewport.h;
      if (rect) {
          if (!SDL_IntersectRect(rect, &real_rect, &real_rect)) {
              return 0;
          }
          if (real_rect.y > rect->y) {
              pixels = (Uint8 *)pixels + pitch * (real_rect.y - rect->y);
          }
          if (real_rect.x > rect->x) {
              int bpp = SDL_BYTESPERPIXEL(format);
              pixels = (Uint8 *)pixels + bpp * (real_rect.x - rect->x);
          }
      }
  
      return renderer->RenderReadPixels(renderer, &real_rect,
                                        format, pixels, pitch);
  }
  
  void
  SDL_RenderPresent(SDL_Renderer * renderer)
  {
      CHECK_RENDERER_MAGIC(renderer, );
  
      /* Don't draw while we're hidden */
      if (renderer->hidden) {
          return;
      }
      renderer->RenderPresent(renderer);
  }
  
  void
  SDL_DestroyTexture(SDL_Texture * texture)
  {
      SDL_Renderer *renderer;
  
      CHECK_TEXTURE_MAGIC(texture, );
  
      renderer = texture->renderer;
      if (texture == renderer->target) {
          SDL_SetRenderTarget(renderer, NULL);
      }
  
      texture->magic = NULL;
  
      if (texture->next) {
          texture->next->prev = texture->prev;
      }
      if (texture->prev) {
          texture->prev->next = texture->next;
      } else {
          renderer->textures = texture->next;
      }
  
      if (texture->native) {
          SDL_DestroyTexture(texture->native);
      }
      if (texture->yuv) {
          SDL_SW_DestroyYUVTexture(texture->yuv);
      }
      SDL_free(texture->pixels);
  
      renderer->DestroyTexture(renderer, texture);
      SDL_free(texture);
  }
  
  void
  SDL_DestroyRenderer(SDL_Renderer * renderer)
  {
      CHECK_RENDERER_MAGIC(renderer, );
  
      SDL_DelEventWatch(SDL_RendererEventWatch, renderer);
  
      /* Free existing textures for this renderer */
      while (renderer->textures) {
          SDL_DestroyTexture(renderer->textures);
      }
  
      if (renderer->window) {
          SDL_SetWindowData(renderer->window, SDL_WINDOWRENDERDATA, NULL);
      }
  
      /* It's no longer magical... */
      renderer->magic = NULL;
  
      /* Free the renderer instance */
      renderer->DestroyRenderer(renderer);
  }
  
  int SDL_GL_BindTexture(SDL_Texture *texture, float *texw, float *texh)
  {
      SDL_Renderer *renderer;
  
      CHECK_TEXTURE_MAGIC(texture, -1);
      renderer = texture->renderer;
      if (texture->native) {
          return SDL_GL_BindTexture(texture->native, texw, texh);
      } else if (renderer && renderer->GL_BindTexture) {
          return renderer->GL_BindTexture(renderer, texture, texw, texh);
      } else {
          return SDL_Unsupported();
      }
  }
  
  int SDL_GL_UnbindTexture(SDL_Texture *texture)
  {
      SDL_Renderer *renderer;
  
      CHECK_TEXTURE_MAGIC(texture, -1);
      renderer = texture->renderer;
      if (texture->native) {
          return SDL_GL_UnbindTexture(texture->native);
      } else if (renderer && renderer->GL_UnbindTexture) {
          return renderer->GL_UnbindTexture(renderer, texture);
      }
  
      return SDL_Unsupported();
  }
  
  /* vi: set ts=4 sw=4 expandtab: */
  

Download