/*

SDL - Simple DirectMedia Layer

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

modify it under the terms of the GNU Lesser General Public

License as published by the Free Software Foundation; either

version 2.1 of the License, or (at your option) any later version.

This library is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public

License along with this library; if not, write to the Free Software

Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA

Sam Lantinga

slouken@libsdl.org

*/

#include "SDL_config.h"

#if SDL_VIDEO_RENDER_GDI

#include "SDL_win32video.h"

#include "../SDL_yuv_sw_c.h"

/* GDI renderer implementation */

static int GDI_CreateTexture(SDL_Renderer * renderer, SDL_Texture * texture);

static int GDI_QueryTexturePixels(SDL_Renderer * renderer,

SDL_Texture * texture, void **pixels,

int *pitch);

static int GDI_SetTexturePalette(SDL_Renderer * renderer,

SDL_Texture * texture,

const SDL_Color * colors, int firstcolor,

int ncolors);

static int GDI_GetTexturePalette(SDL_Renderer * renderer,

SDL_Texture * texture, SDL_Color * colors,

int firstcolor, int ncolors);

static int GDI_SetTextureAlphaMod(SDL_Renderer * renderer,

SDL_Texture * texture);

static int GDI_SetTextureBlendMode(SDL_Renderer * renderer,

SDL_Texture * texture);

static int GDI_SetTextureScaleMode(SDL_Renderer * renderer,

SDL_Texture * texture);

static int GDI_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,

const SDL_Rect * rect, const void *pixels,

int pitch);

static int GDI_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,

const SDL_Rect * rect, int markDirty,

void **pixels, int *pitch);

static void GDI_UnlockTexture(SDL_Renderer * renderer, SDL_Texture * texture);

static int GDI_RenderPoint(SDL_Renderer * renderer, int x, int y);

static int GDI_RenderLine(SDL_Renderer * renderer, int x1, int y1, int x2,

int y2);

static void GDI_RenderPresent(SDL_Renderer * renderer);

static void GDI_DestroyTexture(SDL_Renderer * renderer,

SDL_Texture * texture);

static void GDI_DestroyRenderer(SDL_Renderer * renderer);

SDL_RenderDriver GDI_RenderDriver = {

GDI_CreateRenderer,

{

"gdi",

SDL_PIXELFORMAT_INDEX8,

SDL_PIXELFORMAT_RGB555,

SDL_PIXELFORMAT_RGB565,

SDL_PIXELFORMAT_RGB888,

SDL_PIXELFORMAT_BGR888,

SDL_PIXELFORMAT_ARGB8888,

SDL_PIXELFORMAT_RGBA8888,

SDL_PIXELFORMAT_ABGR8888,

SDL_PIXELFORMAT_BGRA8888,

SDL_PIXELFORMAT_YV12,

SDL_PIXELFORMAT_IYUV,

SDL_PIXELFORMAT_UYVY,

SDL_PIXELFORMAT_YVYU},

0,

0}

};

typedef struct

{

HWND hwnd;

HDC window_hdc;

HDC render_hdc;

HDC memory_hdc;

HDC current_hdc;

LPBITMAPINFO bmi;

HBITMAP hbm[3];

int current_hbm;

SDL_DirtyRectList dirty;

SDL_bool makedirty;

typedef struct

{

SDL_SW_YUVTexture *yuv;

Uint32 format;

HPALETTE hpal;

HBITMAP hbm;

void *pixels;

int pitch;

static void

UpdateYUVTextureData(SDL_Texture * texture)

{

SDL_Rect rect;

rect.x = 0;

rect.y = 0;

rect.w = texture->w;

rect.h = texture->h;

SDL_SW_CopyYUVToRGB(data->yuv, &rect, data->format, texture->w,

texture->h, data->pixels, data->pitch);

}

void

GDI_AddRenderDriver(_THIS)

{

}

SDL_Renderer *

{

SDL_WindowData *windowdata = (SDL_WindowData *) window->driverdata;

SDL_Renderer *renderer;

int bmi_size;

HBITMAP hbm;

if (!renderer) {

SDL_OutOfMemory();

return NULL;

}

SDL_OutOfMemory();

return NULL;

}

renderer->CreateTexture = GDI_CreateTexture;

renderer->QueryTexturePixels = GDI_QueryTexturePixels;

renderer->SetTexturePalette = GDI_SetTexturePalette;

renderer->GetTexturePalette = GDI_GetTexturePalette;

renderer->SetTextureAlphaMod = GDI_SetTextureAlphaMod;

renderer->SetTextureBlendMode = GDI_SetTextureBlendMode;

renderer->SetTextureScaleMode = GDI_SetTextureScaleMode;

renderer->UpdateTexture = GDI_UpdateTexture;

renderer->LockTexture = GDI_LockTexture;

renderer->UnlockTexture = GDI_UnlockTexture;

renderer->RenderPoint = GDI_RenderPoint;

renderer->RenderLine = GDI_RenderLine;

renderer->RenderFill = GDI_RenderFill;

renderer->RenderCopy = GDI_RenderCopy;

renderer->RenderPresent = GDI_RenderPresent;

renderer->DestroyTexture = GDI_DestroyTexture;

renderer->DestroyRenderer = GDI_DestroyRenderer;

renderer->info = GDI_RenderDriver.info;

renderer->window = window->id;

renderer->driverdata = data;

data->render_hdc = CreateCompatibleDC(data->window_hdc);

data->memory_hdc = CreateCompatibleDC(data->window_hdc);

/* Fill in the compatible bitmap info */

bmi_size = sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD);

SDL_OutOfMemory();

return NULL;

}

data->bmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);

hbm = CreateCompatibleBitmap(data->window_hdc, 1, 1);

GetDIBits(data->window_hdc, hbm, 0, 1, NULL, data->bmi, DIB_RGB_COLORS);

GetDIBits(data->window_hdc, hbm, 0, 1, NULL, data->bmi, DIB_RGB_COLORS);

DeleteObject(hbm);

} else if (flags & SDL_RENDERER_PRESENTFLIP2) {

renderer->info.flags |= SDL_RENDERER_PRESENTFLIP2;

} else if (flags & SDL_RENDERER_PRESENTFLIP3) {

renderer->info.flags |= SDL_RENDERER_PRESENTFLIP3;

n = 3;

} else {

n = 1;

}

for (i = 0; i < n; ++i) {

data->hbm[i] =

CreateCompatibleBitmap(data->window_hdc, window->w, window->h);

if (!data->hbm[i]) {

WIN_SetError("CreateCompatibleBitmap()");

return NULL;

}

}

if (n > 0) {

SelectObject(data->render_hdc, data->hbm[0]);

data->current_hdc = data->render_hdc;

data->makedirty = SDL_TRUE;

} else {

data->current_hdc = data->window_hdc;

data->makedirty = SDL_FALSE;

}

data->current_hbm = 0;

return renderer;

}

static int

GDI_DisplayModeChanged(SDL_Renderer * renderer)

{

GDI_RenderData *data = (GDI_RenderData *) renderer->driverdata;

SDL_Window *window = SDL_GetWindowFromID(renderer->window);

int i, n;

if (renderer->info.flags & SDL_RENDERER_SINGLEBUFFER) {

n = 0;

} else if (renderer->info.flags & SDL_RENDERER_PRESENTFLIP2) {

n = 2;

} else if (renderer->info.flags & SDL_RENDERER_PRESENTFLIP3) {

n = 3;

} else {

n = 1;

}

for (i = 0; i < n; ++i) {

if (data->hbm[i]) {

DeleteObject(data->hbm[i]);

data->hbm[i] = NULL;

}

}

for (i = 0; i < n; ++i) {

data->hbm[i] =

CreateCompatibleBitmap(data->window_hdc, window->w, window->h);

if (!data->hbm[i]) {

WIN_SetError("CreateCompatibleBitmap()");

return -1;

}

}

if (n > 0) {

SelectObject(data->render_hdc, data->hbm[0]);

}

data->current_hbm = 0;

return 0;

}

SDL_Window *window = SDL_GetWindowFromID(renderer->window);

SDL_VideoDisplay *display = SDL_GetDisplayFromWindow(window);

if (!data) {

SDL_OutOfMemory();

return -1;

}

texture->driverdata = data;

if (SDL_ISPIXELFORMAT_FOURCC(texture->format)) {

data->yuv =

SDL_SW_CreateYUVTexture(texture->format, texture->w, texture->h);

if (!data->yuv) {

return -1;

}

data->format = display->current_mode.format;

} else {

data->format = texture->format;

}

data->pitch = (texture->w * SDL_BYTESPERPIXEL(data->format));

int bmi_size;

LPBITMAPINFO bmi;

bmi_size = sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD);

if (!bmi) {

SDL_OutOfMemory();

return -1;

}

bmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);

bmi->bmiHeader.biWidth = texture->w;

bmi->bmiHeader.biHeight = -texture->h; /* topdown bitmap */

bmi->bmiHeader.biPlanes = 1;

bmi->bmiHeader.biSizeImage = texture->h * data->pitch;

bmi->bmiHeader.biXPelsPerMeter = 0;

bmi->bmiHeader.biYPelsPerMeter = 0;

bmi->bmiHeader.biClrUsed = 0;

bmi->bmiHeader.biClrImportant = 0;

bmi->bmiHeader.biBitCount = SDL_BYTESPERPIXEL(data->format) * 8;

if (SDL_ISPIXELFORMAT_INDEXED(data->format)) {

int i, ncolors;

LOGPALETTE *palette;

bmi->bmiHeader.biCompression = BI_RGB;

ncolors = (1 << SDL_BITSPERPIXEL(data->format));

palette =

(LOGPALETTE *) SDL_malloc(sizeof(*palette) +

ncolors * sizeof(PALETTEENTRY));

if (!palette) {

SDL_free(bmi);

SDL_OutOfMemory();

return -1;

}

palette->palVersion = 0x300;

palette->palNumEntries = ncolors;

for (i = 0; i < ncolors; ++i) {

palette->palPalEntry[i].peRed = 0xFF;

palette->palPalEntry[i].peGreen = 0xFF;

palette->palPalEntry[i].peBlue = 0xFF;

palette->palPalEntry[i].peFlags = 0;

}

data->hpal = CreatePalette(palette);

SDL_free(palette);

} else {

int bpp;

Uint32 Rmask, Gmask, Bmask, Amask;

bmi->bmiHeader.biCompression = BI_BITFIELDS;

SDL_PixelFormatEnumToMasks(data->format, &bpp, &Rmask, &Gmask,

&Bmask, &Amask);

((Uint32 *) bmi->bmiColors)[0] = Rmask;

((Uint32 *) bmi->bmiColors)[1] = Gmask;

((Uint32 *) bmi->bmiColors)[2] = Bmask;

data->hpal = NULL;

}

data->hbm =

CreateDIBSection(renderdata->memory_hdc, bmi, DIB_RGB_COLORS,

&data->pixels, NULL, 0);

} else {

data->hbm =

CreateCompatibleBitmap(renderdata->window_hdc, texture->w,

texture->h);

data->pixels = NULL;

}

if (!data->hbm) {

WIN_SetError("Couldn't create bitmap");

return -1;

}

return 0;

}

static int

GDI_QueryTexturePixels(SDL_Renderer * renderer, SDL_Texture * texture,

void **pixels, int *pitch)

if (data->yuv) {

return SDL_SW_QueryYUVTexturePixels(data->yuv, pixels, pitch);

} else {

*pixels = data->pixels;

return 0;

}

}

static int

GDI_SetTexturePalette(SDL_Renderer * renderer, SDL_Texture * texture,

const SDL_Color * colors, int firstcolor, int ncolors)

GDI_RenderData *renderdata = (GDI_RenderData *) renderer->driverdata;

GDI_TextureData *data = (GDI_TextureData *) texture->driverdata;

if (data->yuv) {

SDL_SetError("YUV textures don't have a palette");

return -1;

} else {

PALETTEENTRY entries[256];

int i;

for (i = 0; i < ncolors; ++i) {

entries[i].peRed = colors[i].r;

entries[i].peGreen = colors[i].g;

entries[i].peBlue = colors[i].b;

entries[i].peFlags = 0;

}

if (!SetPaletteEntries(data->hpal, firstcolor, ncolors, entries)) {

WIN_SetError("SetPaletteEntries()");

return -1;

}

return 0;

}

}

static int

GDI_GetTexturePalette(SDL_Renderer * renderer, SDL_Texture * texture,

SDL_Color * colors, int firstcolor, int ncolors)

if (data->yuv) {

SDL_SetError("YUV textures don't have a palette");

return -1;

} else {

PALETTEENTRY entries[256];

int i;

if (!GetPaletteEntries(data->hpal, firstcolor, ncolors, entries)) {

WIN_SetError("GetPaletteEntries()");

return -1;

}

for (i = 0; i < ncolors; ++i) {

colors[i].r = entries[i].peRed;

colors[i].g = entries[i].peGreen;

colors[i].b = entries[i].peBlue;

}

return 0;

}

}

static int

GDI_SetTextureAlphaMod(SDL_Renderer * renderer, SDL_Texture * texture)

{

return 0;

}

static int

GDI_SetTextureBlendMode(SDL_Renderer * renderer, SDL_Texture * texture)

{

switch (texture->blendMode) {

case SDL_BLENDMODE_NONE:

case SDL_BLENDMODE_MASK:

case SDL_BLENDMODE_BLEND:

return 0;

default:

SDL_Unsupported();

return -1;

}

}

static int

GDI_SetTextureScaleMode(SDL_Renderer * renderer, SDL_Texture * texture)

{

switch (texture->scaleMode) {

case SDL_TEXTURESCALEMODE_NONE:

case SDL_TEXTURESCALEMODE_FAST:

return 0;

case SDL_TEXTURESCALEMODE_SLOW:

case SDL_TEXTURESCALEMODE_BEST:

SDL_Unsupported();

texture->scaleMode = SDL_TEXTURESCALEMODE_FAST;

return -1;

default:

SDL_Unsupported();

texture->scaleMode = SDL_TEXTURESCALEMODE_NONE;

return -1;

}

return 0;

}

GDI_UpdateTexture(SDL_Renderer * renderer, SDL_Texture * texture,

const SDL_Rect * rect, const void *pixels, int pitch)

if (data->yuv) {

if (SDL_SW_UpdateYUVTexture(data->yuv, rect, pixels, pitch) < 0) {

return -1;

}

UpdateYUVTextureData(texture);

return 0;

} else {

if (data->pixels) {

Uint8 *src, *dst;

int row;

size_t length;

src = (Uint8 *) pixels;

dst =

(Uint8 *) data->pixels + rect->y * data->pitch +

rect->x * SDL_BYTESPERPIXEL(texture->format);

length = rect->w * SDL_BYTESPERPIXEL(texture->format);

for (row = 0; row < rect->h; ++row) {

SDL_memcpy(dst, src, length);

src += pitch;

dst += data->pitch;

}

} else if (rect->w == texture->w && pitch == data->pitch) {

if (!SetDIBits

(renderdata->window_hdc, data->hbm, rect->y, rect->h, pixels,

renderdata->bmi, DIB_RGB_COLORS)) {

WIN_SetError("SetDIBits()");

return -1;

}

} else {

SDL_SetError

("FIXME: Need to allocate temporary memory and do GetDIBits() followed by SetDIBits(), since we can only set blocks of scanlines at a time");

return -1;

}

return 0;

}

}

static int

GDI_LockTexture(SDL_Renderer * renderer, SDL_Texture * texture,

const SDL_Rect * rect, int markDirty, void **pixels,

int *pitch)

if (data->yuv) {

return SDL_SW_LockYUVTexture(data->yuv, rect, markDirty, pixels,

pitch);

GdiFlush();

*pixels =

(void *) ((Uint8 *) data->pixels + rect->y * data->pitch +

rect->x * SDL_BYTESPERPIXEL(texture->format));

*pitch = data->pitch;

return 0;

} else {

SDL_SetError("No pixels available");

return -1;

}

}

static void

if (data->yuv) {

SDL_SW_UnlockYUVTexture(data->yuv);

UpdateYUVTextureData(texture);

}

}

static int

GDI_SetDrawBlendMode(SDL_Renderer * renderer)

{

switch (renderer->blendMode) {

case SDL_BLENDMODE_NONE:

return 0;

default:

SDL_Unsupported();

renderer->blendMode = SDL_BLENDMODE_NONE;

return -1;

}

}

static int

GDI_RenderPoint(SDL_Renderer * renderer, int x, int y)

{

GDI_RenderData *data = (GDI_RenderData *) renderer->driverdata;

if (data->makedirty) {

SDL_Rect rect;

rect.x = x;

rect.y = y;

rect.w = 1;

rect.h = 1;

SDL_AddDirtyRect(&data->dirty, &rect);

}

SetPixel(data->current_hdc, x, y,

RGB(renderer->r, renderer->g, renderer->b));

return 0;

}

static int

GDI_RenderLine(SDL_Renderer * renderer, int x1, int y1, int x2, int y2)

{

GDI_RenderData *data = (GDI_RenderData *) renderer->driverdata;

POINT points[2];

HBRUSH brush;

BOOL status;

if (data->makedirty) {

SDL_Rect rect;

if (x1 < x2) {

rect.x = x1;

rect.w = (x2 - x1) + 1;

} else {

rect.x = x2;

rect.w = (x1 - x2) + 1;

}

if (y1 < y2) {

rect.y = y1;

rect.h = (y2 - y1) + 1;

} else {

rect.y = y2;

rect.h = (y1 - y2) + 1;

}

SDL_AddDirtyRect(&data->dirty, &rect);

}

/* Should we cache the brushes? .. it looks like GDI does for us. :) */

brush = CreateSolidBrush(RGB(renderer->r, renderer->g, renderer->b));

SelectObject(data->current_hdc, brush);

points[0].x = x1;

points[0].y = y1;

points[1].x = x2;

points[1].y = y2;

status = Polyline(data->current_hdc, points, 2);

DeleteObject(brush);

if (!status) {

WIN_SetError("FillRect()");

return -1;

}

return 0;

}

int status;

if (data->makedirty) {

SDL_AddDirtyRect(&data->dirty, rect);

}

rc.left = rect->x;

rc.top = rect->y;

rc.right = rect->x + rect->w + 1;

rc.bottom = rect->y + rect->h + 1;

/* Should we cache the brushes? .. it looks like GDI does for us. :) */

SelectObject(data->current_hdc, brush);

status = FillRect(data->current_hdc, &rc, brush);

DeleteObject(brush);

if (!status) {

WIN_SetError("FillRect()");

return -1;

}

return 0;

}

static int

GDI_RenderData *data = (GDI_RenderData *) renderer->driverdata;

GDI_TextureData *texturedata = (GDI_TextureData *) texture->driverdata;

if (data->makedirty) {

SDL_AddDirtyRect(&data->dirty, dstrect);

}

SelectObject(data->memory_hdc, texturedata->hbm);

if (texturedata->hpal) {

SelectPalette(data->memory_hdc, texturedata->hpal, TRUE);

RealizePalette(data->memory_hdc);

}

AC_SRC_OVER,

0,

AC_SRC_ALPHA

};

/* FIXME: GDI uses premultiplied alpha!

* Once we solve this and somehow support blended drawing we can enable SDL_BLENDMODE_BLEND

*/

if (!AlphaBlend

(data->current_hdc, dstrect->x, dstrect->y, dstrect->w,

dstrect->h, data->memory_hdc, srcrect->x, srcrect->y, srcrect->w,

srcrect->h, blendFunc)) {

WIN_SetError("AlphaBlend()");

return -1;

}

} else {

if (srcrect->w == dstrect->w && srcrect->h == dstrect->h) {

if (!BitBlt

(data->current_hdc, dstrect->x, dstrect->y, dstrect->w,

srcrect->h, data->memory_hdc, srcrect->x, srcrect->y,

SRCCOPY)) {

WIN_SetError("BitBlt()");

return -1;

}

} else {

if (!StretchBlt

(data->current_hdc, dstrect->x, dstrect->y, dstrect->w,

dstrect->h, data->memory_hdc, srcrect->x, srcrect->y,

srcrect->w, srcrect->h, SRCCOPY)) {

WIN_SetError("StretchBlt()");

return -1;

}

}

}

return 0;

}

static void

SDL_DirtyRect *dirty;

/* Send the data to the display */

for (dirty = data->dirty.list; dirty; dirty = dirty->next) {

const SDL_Rect *rect = &dirty->rect;

BitBlt(data->window_hdc, rect->x, rect->y, rect->w, rect->h,

data->render_hdc, rect->x, rect->y, SRCCOPY);

}

SDL_ClearDirtyRects(&data->dirty);

}

/* Update the flipping chain, if any */

data->current_hbm = (data->current_hbm + 1) % 2;

SelectObject(data->render_hdc, data->hbm[data->current_hbm]);

data->current_hbm = (data->current_hbm + 1) % 3;

SelectObject(data->render_hdc, data->hbm[data->current_hbm]);

}

}

static void

if (!data) {

return;

}

if (data->yuv) {

SDL_SW_DestroyYUVTexture(data->yuv);

}

if (data->hpal) {

DeleteObject(data->hpal);

}

if (data->hbm) {

DeleteObject(data->hbm);

}

SDL_free(data);

texture->driverdata = NULL;

}

if (data) {

DeleteDC(data->render_hdc);

DeleteDC(data->memory_hdc);

if (data->bmi) {

SDL_free(data->bmi);

}

for (i = 0; i < SDL_arraysize(data->hbm); ++i) {

if (data->hbm[i]) {

DeleteObject(data->hbm[i]);

}

}

SDL_FreeDirtyRects(&data->dirty);

SDL_free(data);

}

SDL_free(renderer);

}

#endif /* SDL_VIDEO_RENDER_GDI */

/* vi: set ts=4 sw=4 expandtab: */