/*

    SDL - Simple DirectMedia Layer

    Copyright (C) 1997-2004 Sam Lantinga

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

    modify it under the terms of the GNU Library General Public

    License as published by the Free Software Foundation; either

    version 2 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

    Library General Public License for more details.

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

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

    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    Sam Lantinga

    slouken@libsdl.org

*/

#include "SDL_config.h"

/*

     File added by Alan Buckley (alan_baa@hotmail.com) for RISC OS compatability

	 27 March 2003

     Implements RISC OS full screen display.

*/

#include "SDL_video.h"

#include "SDL_mouse.h"

#include "../SDL_sysvideo.h"

#include "../SDL_pixels_c.h"

#include "../../events/SDL_events_c.h"

#include "SDL_riscostask.h"

#include "SDL_riscosvideo.h"

#include "SDL_riscosevents_c.h"

#include "SDL_riscosmouse_c.h"

#include "kernel.h"

#include "swis.h"

#include "unixlib/os.h"

#include "unixlib/local.h"

/* Private structures */

typedef struct tagScreenModeBlock

{

   int flags;  // mode selector flags, bit 0 = 1, bit 1-7 format specifier, 8-31 reserved

   int x_pixels;

   int y_pixels;

   int pixel_depth;  // 2^pixel_depth = bpp,i.e. 0 = 1, 1 = 2, 4 = 16, 5 = 32

   int frame_rate;   // -1 use first match

   int mode_vars[5]; // array of index, value pairs terminated by -1

} SCREENMODEBLOCK;

/* Helper functions */

void FULLSCREEN_SetDeviceMode(_THIS);

int FULLSCREEN_SetMode(int width, int height, int bpp);

void FULLSCREEN_SetupBanks(_THIS);

/* SDL video device functions for fullscreen mode */

static int FULLSCREEN_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color *colors);

static int FULLSCREEN_FlipHWSurface(_THIS, SDL_Surface *surface);

void FULLSCREEN_SetWMCaption(_THIS, const char *title, const char *icon);

extern int RISCOS_GetWmInfo(_THIS, SDL_SysWMinfo *info);

/* UpdateRects variants */

static void FULLSCREEN_UpdateRects(_THIS, int numrects, SDL_Rect *rects);

static void FULLSCREEN_UpdateRectsMemCpy(_THIS, int numrects, SDL_Rect *rects);

static void FULLSCREEN_UpdateRects8bpp(_THIS, int numrects, SDL_Rect *rects);

static void FULLSCREEN_UpdateRects16bpp(_THIS, int numrects, SDL_Rect *rects);

static void FULLSCREEN_UpdateRects32bpp(_THIS, int numrects, SDL_Rect *rects);

static void FULLSCREEN_UpdateRectsOS(_THIS, int numrects, SDL_Rect *rects);

/* Local helper functions */

static int cmpmodes(const void *va, const void *vb);

static int FULLSCREEN_AddMode(_THIS, int bpp, int w, int h);

void FULLSCREEN_SetWriteBank(int bank);

void FULLSCREEN_SetDisplayBank(int bank);

static void FULLSCREEN_DisableEscape();

static void FULLSCREEN_EnableEscape();

void FULLSCREEN_BuildModeList(_THIS);

/* Following variable is set up in riskosTask.c */

extern int riscos_backbuffer; /* Create a back buffer in system memory for full screen mode */

/* Following is used to create a sprite back buffer */

extern unsigned char *WIMP_CreateBuffer(int width, int height, int bpp);

/* Fast assembler copy */

extern void RISCOS_Put32(void *to, int pixels, int pitch, int rows, void *from, int src_skip_bytes);

SDL_Surface *FULLSCREEN_SetVideoMode(_THIS, SDL_Surface *current,

				int width, int height, int bpp, Uint32 flags)

{

   _kernel_swi_regs regs;

   Uint32 Rmask = 0;

   Uint32 Gmask = 0;

   Uint32 Bmask = 0;

   int create_back_buffer = riscos_backbuffer;

   switch(bpp)

   {

	case 8:

		flags |= SDL_HWPALETTE;

		break;

	case 15:

	case 16:

		Bmask = 0x00007c00;

		Gmask = 0x000003e0;

		Rmask = 0x0000001f;

		break;

	case 32:

		Bmask = 0x00ff0000;

		Gmask = 0x0000ff00;

		Rmask = 0x000000ff;

		break;

	default:

		SDL_SetError("Pixel depth not supported");

		return NULL;

		break;

   }

   if (FULLSCREEN_SetMode(width, height, bpp) == 0)

   {

	   SDL_SetError("Couldn't set requested mode");

	   return (NULL);

   }

/* 	printf("Setting mode %dx%d\n", width, height); */

	/* Allocate the new pixel format for the screen */

	if ( ! SDL_ReallocFormat(current, bpp, Rmask, Gmask, Bmask, 0) ) {

	    RISCOS_RestoreWimpMode();

		SDL_SetError("Couldn't allocate new pixel format for requested mode");

		return(NULL);

	}

	/* Set up the new mode framebuffer */

	current->w = width;

	this->hidden->height = current->h = height;

   regs.r[0] = -1; /* -1 for current screen mode */

   /* Get screen width in bytes */

   regs.r[1] = 6; // Screen Width in bytes

   _kernel_swi(OS_ReadModeVariable, &regs, &regs);

   current->pitch = regs.r[2];

   if (flags & SDL_DOUBLEBUF)

   {

	   regs.r[0] = 2; /* Screen area */

	   _kernel_swi(OS_ReadDynamicArea, &regs, &regs);

	   /* Reg 1 has amount of memory currently used for display */

	   regs.r[0] = 2; /* Screen area */

	   regs.r[1] = (current->pitch * height * 2) - regs.r[1];

	   if (_kernel_swi(OS_ChangeDynamicArea, &regs, &regs) != NULL)

	   {

		   /* Can't allocate enough screen memory for double buffer */

		   flags &= ~SDL_DOUBLEBUF;

	   }

   }

  	current->flags = flags | SDL_FULLSCREEN | SDL_HWSURFACE | SDL_PREALLOC;

	/* Need to set display banks here for double buffering */

	if (flags & SDL_DOUBLEBUF)

	{

	   FULLSCREEN_SetWriteBank(0);

	   FULLSCREEN_SetDisplayBank(1);

         create_back_buffer = 0; /* Don't need a back buffer for a double buffered display */

    }

    FULLSCREEN_SetupBanks(this);

    if (create_back_buffer)

    {

       /* If not double buffered we may need to create a memory

         ** back buffer to simulate processing on other OSes.

         ** This is turned on by setting the enviromental variable

         ** SDL$<name>$BackBuffer >= 1

         */

       if (riscos_backbuffer == 3)

          this->hidden->bank[0] = WIMP_CreateBuffer(width, height, bpp);

       else

          this->hidden->bank[0] = SDL_malloc(height * current->pitch);

       if (this->hidden->bank[0] == 0)

       {

 	       RISCOS_RestoreWimpMode();

           SDL_SetError("Couldnt allocate memory for back buffer");

           return (NULL);

       }

       /* Surface updated in programs is now a software surface */

       current->flags &= ~SDL_HWSURFACE;

    }

    /* Store address of allocated screen bank to be freed later */

    if (this->hidden->alloc_bank) SDL_free(this->hidden->alloc_bank);

    if (create_back_buffer)

    {

        this->hidden->alloc_bank = this->hidden->bank[0];

        if (riscos_backbuffer == 3)

        {

           this->hidden->bank[0] += 60; /* Start of sprite data */

           if (bpp == 8) this->hidden->bank[0] += 2048; /* 8bpp sprite have palette first */

        }

    } else

	  this->hidden->alloc_bank = 0;

    // Clear both banks to black

    SDL_memset(this->hidden->bank[0], 0, height * current->pitch);

    SDL_memset(this->hidden->bank[1], 0, height * current->pitch);

 	   this->hidden->current_bank = 0;

	   current->pixels = this->hidden->bank[0];

    /* Have to set the screen here, so SetDeviceMode will pick it up */

    this->screen = current;

	/* Reset device functions for the wimp */

	FULLSCREEN_SetDeviceMode(this);

/*	FULLSCREEN_DisableEscape(); */

	/* We're done */

	return(current);

}

/* Reset any device functions that have been changed because we have run in WIMP mode */

void FULLSCREEN_SetDeviceMode(_THIS)

{

	/* Update rects is different if we have a backbuffer */

	if (riscos_backbuffer && (this->screen->flags & SDL_DOUBLEBUF) == 0)

      {

	   switch(riscos_backbuffer)

         {

            case 2: /* ARM code full word copy */

               switch(this->screen->format->BytesPerPixel)

               {

                  case 1: /* 8bpp modes */

               	   this->UpdateRects = FULLSCREEN_UpdateRects8bpp;

                     break;

                  case 2: /* 15/16bpp modes */

               	   this->UpdateRects = FULLSCREEN_UpdateRects16bpp;

                     break;

                  case 4: /* 32 bpp modes */

               	   this->UpdateRects = FULLSCREEN_UpdateRects32bpp;

                     break;

                  default: /* Just default to the memcpy routine */

               	   this->UpdateRects = FULLSCREEN_UpdateRectsMemCpy;

                     break;

                }

               break;

            case 3: /* Use OS sprite plot routine */

               this->UpdateRects = FULLSCREEN_UpdateRectsOS;

               break;

            default: /* Old but safe memcpy */

               this->UpdateRects = FULLSCREEN_UpdateRectsMemCpy;

               break;

         }

      } else

	   this->UpdateRects = FULLSCREEN_UpdateRects; /* Default do nothing implementation */

	this->SetColors   = FULLSCREEN_SetColors;

	this->FlipHWSurface = FULLSCREEN_FlipHWSurface;

	this->SetCaption = FULLSCREEN_SetWMCaption;

	this->SetIcon = NULL;

	this->IconifyWindow = NULL;

	this->ShowWMCursor = RISCOS_ShowWMCursor;

	this->WarpWMCursor = FULLSCREEN_WarpWMCursor;

	this->PumpEvents = FULLSCREEN_PumpEvents;	

}

/* Query for the list of available video modes */

void FULLSCREEN_BuildModeList(_THIS)

{

	_kernel_swi_regs regs;

	char *enumInfo = NULL;

	char *enum_ptr;

	int *blockInfo;

	int j;

	int num_modes;

	/* Find out how much space we need */

	regs.r[0] = 2; /* Reason code */

	regs.r[2] = 0; /* Number of modes to skip */

	regs.r[6] = 0; /* pointer to block or 0 for count */

	regs.r[7] = 0; /* Size of block in bytes */

	_kernel_swi(OS_ScreenMode, &regs, &regs);

    num_modes = -regs.r[2];

	/* Video memory should be in r[5] */

	this->info.video_mem = regs.r[5]/1024;

	enumInfo = (unsigned char *)SDL_malloc(-regs.r[7]);

	if (enumInfo == NULL)

	{

		SDL_OutOfMemory();

		return;

	}

	/* Read mode information into block */

	regs.r[2] = 0;

	regs.r[6] = (int)enumInfo;

	regs.r[7] = -regs.r[7];

	_kernel_swi(OS_ScreenMode, &regs, &regs);

	enum_ptr = enumInfo;

	for (j =0; j < num_modes;j++)

	{

		blockInfo = (int *)enum_ptr;

		if ((blockInfo[1] & 255) == 1) /* We understand this format */

		{

			switch(blockInfo[4])

			{

			case 3: /* 8 bits per pixel */

				FULLSCREEN_AddMode(this, 8, blockInfo[2], blockInfo[3]);

				break;

			case 4: /* 15 bits per pixel */

				FULLSCREEN_AddMode(this, 15, blockInfo[2], blockInfo[3]);

				break;

			case 5: /* 32 bits per pixel */

				FULLSCREEN_AddMode(this, 32, blockInfo[2], blockInfo[3]);

				break;

			}

		}

		enum_ptr += blockInfo[0];

	}

	SDL_free(enumInfo);

	/* Sort the mode lists */

	for ( j=0; j<NUM_MODELISTS; ++j ) {

		if ( SDL_nummodes[j] > 0 ) {

			SDL_qsort(SDL_modelist[j], SDL_nummodes[j], sizeof *SDL_modelist[j], cmpmodes);

		}

	}

}

static int FULLSCREEN_FlipHWSurface(_THIS, SDL_Surface *surface)

{

   _kernel_swi_regs regs;

   regs.r[0] = 19;

   FULLSCREEN_SetDisplayBank(this->hidden->current_bank);

   this->hidden->current_bank ^= 1;

   FULLSCREEN_SetWriteBank(this->hidden->current_bank);

   surface->pixels = this->hidden->bank[this->hidden->current_bank];

   /* Wait for Vsync */

   _kernel_swi(OS_Byte, &regs, &regs);

	return(0);

}

/* Nothing to do if we are writing direct to hardware */

static void FULLSCREEN_UpdateRects(_THIS, int numrects, SDL_Rect *rects)

{

}

/* Safe but slower Memory copy from our allocated back buffer */

static void FULLSCREEN_UpdateRectsMemCpy(_THIS, int numrects, SDL_Rect *rects)

{

      int j;

      char *to, *from;

      int pitch = this->screen->pitch;

      int row;

      int xmult = this->screen->format->BytesPerPixel;

      for (j = 0; j < numrects; j++)

      {

         from = this->hidden->bank[0] + rects->x * xmult + rects->y * pitch;

         to  = this->hidden->bank[1] + rects->x * xmult + rects->y * pitch;

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

         {

             SDL_memcpy(to, from, rects->w * xmult);

             from += pitch;

             to += pitch;

         }

         rects++;

      }

}

/* Use optimized assembler memory copy. Deliberately copies extra columns if

   necessary to ensure the rectangle is word aligned. */

static void FULLSCREEN_UpdateRects8bpp(_THIS, int numrects, SDL_Rect *rects)

{

   int j;

   char *to, *from;

   int pitch = this->screen->pitch;

   int width_bytes;

   int src_skip_bytes;

   for (j = 0; j < numrects; j++)

   {

      from = this->hidden->bank[0] + rects->x + rects->y * pitch;

      to  = this->hidden->bank[1] + rects->x + rects->y * pitch;

      width_bytes = rects->w;

      if ((int)from & 3)

      {

         int extra = ((int)from & 3);

         from -= extra;

         to -= extra;

         width_bytes += extra;

      }

      if (width_bytes & 3) width_bytes += 4 - (width_bytes & 3);

      src_skip_bytes = pitch - width_bytes;

      RISCOS_Put32(to, (width_bytes >> 2), pitch, (int)rects->h, from, src_skip_bytes);

      rects++;

   }

}

/* Use optimized assembler memory copy. Deliberately copies extra columns if

   necessary to ensure the rectangle is word aligned. */

static void FULLSCREEN_UpdateRects16bpp(_THIS, int numrects, SDL_Rect *rects)

{

   int j;

   char *to, *from;

   int pitch = this->screen->pitch;

   int width_bytes;

   int src_skip_bytes;

   for (j = 0; j < numrects; j++)

   {

      from = this->hidden->bank[0] + (rects->x << 1) + rects->y * pitch;

      to  = this->hidden->bank[1] + (rects->x << 1) + rects->y * pitch;

      width_bytes = (((int)rects->w) << 1);

      if ((int)from & 3)

      {

         from -= 2;

         to -= 2;

         width_bytes += 2;

      }

      if (width_bytes & 3) width_bytes += 2;

      src_skip_bytes = pitch - width_bytes;

      RISCOS_Put32(to, (width_bytes >> 2), pitch, (int)rects->h, from, src_skip_bytes);

      rects++;

   }

}

/* Use optimized assembler memory copy. 32 bpp modes are always word aligned */

static void FULLSCREEN_UpdateRects32bpp(_THIS, int numrects, SDL_Rect *rects)

{

   int j;

   char *to, *from;

   int pitch = this->screen->pitch;

   int width;

   for (j = 0; j < numrects; j++)

   {

      from = this->hidden->bank[0] + (rects->x << 2) + rects->y * pitch;

      to  = this->hidden->bank[1] + (rects->x << 2) + rects->y * pitch;

      width = (int)rects->w ;

      RISCOS_Put32(to, width, pitch, (int)rects->h, from, pitch - (width << 2));

      rects++;

   }

}

/* Use operating system sprite plots. Currently this is much slower than the

   other variants however accelerated sprite plotting can be seen on the horizon

   so this prepares for it. */

static void FULLSCREEN_UpdateRectsOS(_THIS, int numrects, SDL_Rect *rects)

{

   _kernel_swi_regs regs;

   _kernel_oserror *err;

   int j;

   int y;

   regs.r[0] = 28 + 512;

   regs.r[1] = (unsigned int)this->hidden->alloc_bank;

   regs.r[2] = (unsigned int)this->hidden->alloc_bank+16;

   regs.r[5] = 0;

   for (j = 0; j < numrects; j++)

   {

      y = this->screen->h - rects->y; /* top of clipping region */

      _kernel_oswrch(24); /* Set graphics clip region */

      _kernel_oswrch((rects->x << this->hidden->xeig) & 0xFF); /* left */

      _kernel_oswrch(((rects->x << this->hidden->xeig) >> 8) & 0xFF);

      _kernel_oswrch(((y - rects->h) << this->hidden->yeig) & 0xFF); /* bottom */

      _kernel_oswrch((((y - rects->h) << this->hidden->yeig)>> 8) & 0xFF);

      _kernel_oswrch(((rects->x + rects->w - 1) << this->hidden->xeig) & 0xFF); /* right */

      _kernel_oswrch((((rects->x + rects->w - 1)<< this->hidden->xeig) >> 8) & 0xFF);

      _kernel_oswrch(((y-1) << this->hidden->yeig) & 0xFF); /* top */

      _kernel_oswrch((((y-1) << this->hidden->yeig) >> 8) & 0xFF);

      regs.r[3] = 0;

      regs.r[4] = 0;

      if ((err = _kernel_swi(OS_SpriteOp, &regs, &regs)) != 0)

      {

         printf("OS_SpriteOp failed \n%s\n",err->errmess);

      }

      rects++;

      /* Reset to full screen clipping */

      _kernel_oswrch(24); /* Set graphics clip region */

      _kernel_oswrch(0); /* left */

      _kernel_oswrch(0);

      _kernel_oswrch(0); /* bottom */

      _kernel_oswrch(0);

      _kernel_oswrch(((this->screen->w-1) << this->hidden->xeig) & 0xFF); /* right */

      _kernel_oswrch((((this->screen->w-1) << this->hidden->xeig) >> 8) & 0xFF);

      _kernel_oswrch(((this->screen->h-1) << this->hidden->yeig) & 0xFF); /* top */

      _kernel_oswrch((((this->screen->h-1) << this->hidden->yeig) >> 8) & 0xFF);

   }