uGFX
/
ugfx
2
0
Fork 0
Code Issues 2 Pull Requests Projects Releases Wiki Activity

Added type gDelay to replace V2.x delaytime_t 

Added type gTicks          to replace V2.x systemticks_t
Added type gThreadreturn   to replace V2.x threadreturn_t
Added type gThreadpriority to replace V2.x threadpriority_t
release/v2.9
inmarket 2018-07-08 14:30:31 +10:00
parent e23ae94e91
commit 215f31ee3d
63 changed files with 359 additions and 348 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
boards/base/STM32F439i-Eval/CubeHal/stm32f439i_raw32_ugfx.c
View File

@ -13,12 +13,12 @@
{ {
} }
systemticks_t gfxSystemTicks(void) gTicks gfxSystemTicks(void)
{ {
return HAL_GetTick(); return HAL_GetTick();
} }
systemticks_t gfxMillisecondsToTicks(delaytime_t ms) gTicks gfxMillisecondsToTicks(gDelay ms)
{ {
return ms; return ms;
} }

4
boards/base/STM32F469i-Discovery/stm32f469i_raw32_ugfx.c
View File

@ -8,12 +8,12 @@
#include "stm32f4xx_hal.h" #include "stm32f4xx_hal.h"
#if !GFX_USE_OS_CHIBIOS #if !GFX_USE_OS_CHIBIOS
systemticks_t gfxSystemTicks(void) gTicks gfxSystemTicks(void)
{ {
return HAL_GetTick(); return HAL_GetTick();
} }
systemticks_t gfxMillisecondsToTicks(delaytime_t ms) gTicks gfxMillisecondsToTicks(gDelay ms)
{ {
return ms; return ms;
} }

2
boards/base/STM32F746-Discovery/stm32f746g_discovery_sdram.c
View File

@ -259,7 +259,7 @@ static HAL_StatusTypeDef _HAL_SDRAM_SendCommand(SDRAM_HandleTypeDef *hsdram, FMC
static HAL_StatusTypeDef _FMC_SDRAM_SendCommand(FMC_SDRAM_TypeDef *Device, FMC_SDRAM_CommandTypeDef *Command, uint32_t Timeout) static HAL_StatusTypeDef _FMC_SDRAM_SendCommand(FMC_SDRAM_TypeDef *Device, FMC_SDRAM_CommandTypeDef *Command, uint32_t Timeout)
{ {
__IO uint32_t tmpr = 0; __IO uint32_t tmpr = 0;
systemticks_t tickstart = 0; gTicks tickstart = 0;
/* Set command register */ /* Set command register */
tmpr = (uint32_t)((Command->CommandMode) |\ tmpr = (uint32_t)((Command->CommandMode) |\

4
boards/base/STM32F746-Discovery/stm32f746g_raw32_ugfx.c
View File

@ -9,12 +9,12 @@
#if GFX_USE_OS_CHIBIOS #if GFX_USE_OS_CHIBIOS
#define HAL_GPIO_Init(port, ptr) palSetGroupMode(port, (ptr)->Pin, 0, (ptr)->Mode|((ptr)->Speed<<3)|((ptr)->Pull<<5)|((ptr)->Alternate<<7)) #define HAL_GPIO_Init(port, ptr) palSetGroupMode(port, (ptr)->Pin, 0, (ptr)->Mode|((ptr)->Speed<<3)|((ptr)->Pull<<5)|((ptr)->Alternate<<7))
#else #else
systemticks_t gfxSystemTicks(void) gTicks gfxSystemTicks(void)
{ {
return HAL_GetTick(); return HAL_GetTick();
} }
systemticks_t gfxMillisecondsToTicks(delaytime_t ms) gTicks gfxMillisecondsToTicks(gDelay ms)
{ {
return ms; return ms;
} }

26
changelog.txt
View File

@ -15,17 +15,21 @@ FEATURE: Added GFX_COMPAT_OLDCOLORS to allow V2.x Red, Green, Blue color names.
CHANGE: Added GFX_RED, GFX_BLUE, GFX_GREEN etc to replace V2.x Red, Gree, Blue color names CHANGE: Added GFX_RED, GFX_BLUE, GFX_GREEN etc to replace V2.x Red, Gree, Blue color names
CHANGE: Added GFXON/GFXOFF to replace V2.x TRUE/FALSE for configuration options. CHANGE: Added GFXON/GFXOFF to replace V2.x TRUE/FALSE for configuration options.
CHANGE: Added types gI8, gU8 .. gI32, gU32 to replace V2.x int8_t etc CHANGE: Added types gI8, gU8 .. gI32, gU32 to replace V2.x int8_t etc
CHANGE: Added type gBool to replace V2.x bool_t, and values gTrue/gFalse to replace TRUE/FALSE CHANGE: Added type gBool to replace V2.x bool_t, and values gTrue/gFalse to replace TRUE/FALSE
CHANGE: Added type gPoint to replace V2.x point and point_t CHANGE: Added type gDelay to replace V2.x delaytime_t
CHANGE: Added type gCoord to replace V2.x coord_t CHANGE: Added type gTicks to replace V2.x systemticks_t
CHANGE: Added type gPixel to replace V2.x pixel_t CHANGE: Added type gThreadreturn to replace V2.x threadreturn_t
CHANGE: Added type gColor to replace V2.x color_t CHANGE: Added type gThreadpriority to replace V2.x threadpriority_t
CHANGE: Added type gColorformat to replace V2.x colorformat CHANGE: Added type gPoint to replace V2.x point and point_t
CHANGE: Added type gFont to replace V2.x font_t CHANGE: Added type gCoord to replace V2.x coord_t
CHANGE: Added type gPowermode to replace V2.x powermode_t, and values gPowerXXX replace powerXXX CHANGE: Added type gPixel to replace V2.x pixel_t
CHANGE: Added type gJustify to replace V2.x justify_t, and values gJustifyXXX replace justifyXXX CHANGE: Added type gColor to replace V2.x color_t
CHANGE: Added type gFontmetric to replace V2.x fontmetric_t, and values gFontXXX replace fontXXX CHANGE: Added type gColorformat to replace V2.x colorformat
CHANGE: Added type gOrientation to replace V2.x orientation_t, and values gOrientationX replace GDISP_ROTATE_X CHANGE: Added type gFont to replace V2.x font_t
CHANGE: Added type gPowermode to replace V2.x powermode_t, and values gPowerXXX replace powerXXX
CHANGE: Added type gJustify to replace V2.x justify_t, and values gJustifyXXX replace justifyXXX
CHANGE: Added type gFontmetric to replace V2.x fontmetric_t, and values gFontXXX replace fontXXX
CHANGE: Added type gOrientation to replace V2.x orientation_t, and values gOrientationX replace GDISP_ROTATE_X
CHANGE: Added macros JUSTIFYMASK_HORIZONTAL, JUSTIFYMASK_VERTICAL to replace macros JUSTIFYMASK_LEFTRIGHT, JUSTIFYMASK_TOPBOTTOM CHANGE: Added macros JUSTIFYMASK_HORIZONTAL, JUSTIFYMASK_VERTICAL to replace macros JUSTIFYMASK_LEFTRIGHT, JUSTIFYMASK_TOPBOTTOM
FEATURE: Added types gPtr and gPtrDiff FEATURE: Added types gPtr and gPtrDiff
FEATURE: Added gI64 and gU64 when the compiler supports it. GFX_TYPE_64 macro is defined as GFXON if it does. FEATURE: Added gI64 and gU64 when the compiler supports it. GFX_TYPE_64 macro is defined as GFXON if it does.

4
demos/games/justget10/jg10.c
View File

@ -102,8 +102,8 @@ static void clean_SelCheck(void) {
static void remove_Selected(void) { static void remove_Selected(void) {
uint16_t i ,j, step; uint16_t i ,j, step;
systemticks_t delay_start = 0; gTicks delay_start = 0;
systemticks_t delay=0; gTicks delay=0;
for (step = 0; step < JG10_ANIM_IMAGES; step++) { for (step = 0; step < JG10_ANIM_IMAGES; step++) {
delay_start = gfxSystemTicks(); delay_start = gfxSystemTicks();
for (i = 0; i < JG10_FIELD_WIDTH; i++) { for (i = 0; i < JG10_FIELD_WIDTH; i++) {

6
demos/games/tetris/tetris.c
View File

@ -78,8 +78,8 @@ const int tetrisShapes[TETRIS_SHAPE_COUNT][4][2] = {
int tetrisField[TETRIS_FIELD_HEIGHT][TETRIS_FIELD_WIDTH]; // main tetris field array int tetrisField[TETRIS_FIELD_HEIGHT][TETRIS_FIELD_WIDTH]; // main tetris field array
unsigned int tetrisGameSpeed = 500; // game auto-move speed in ms unsigned int tetrisGameSpeed = 500; // game auto-move speed in ms
unsigned int tetrisKeySpeed = 140; // game key repeat speed in ms unsigned int tetrisKeySpeed = 140; // game key repeat speed in ms
systemticks_t tetrisPreviousGameTime = 0; gTicks tetrisPreviousGameTime = 0;
systemticks_t tetrisPreviousKeyTime = 0; gTicks tetrisPreviousKeyTime = 0;
int tetrisCurrentShape[4][2]; int tetrisCurrentShape[4][2];
int tetrisNextShape[4][2]; int tetrisNextShape[4][2];
int tetrisOldShape[4][2]; int tetrisOldShape[4][2];
@ -474,7 +474,7 @@ static DECLARE_THREAD_FUNCTION(thdTetris, arg) {
tetrisPreviousKeyTime = gfxSystemTicks(); tetrisPreviousKeyTime = gfxSystemTicks();
} }
} }
return (threadreturn_t)0; return (gThreadreturn)0;
} }
static void tetrisDeinit(void) { static void tetrisDeinit(void) {

2
demos/modules/gdisp/images_animated/main.c
View File

@ -55,7 +55,7 @@ static gdispImage myImage;
*/ */
int main(void) { int main(void) {
gCoord swidth, sheight, errx, erry, errcx, errcy; gCoord swidth, sheight, errx, erry, errcx, errcy;
delaytime_t delay; gDelay delay;
gfxInit(); // Initialize the display gfxInit(); // Initialize the display

8
demos/modules/gos/threads/main.c
View File

@ -22,7 +22,7 @@
#error "--" #error "--"
#endif #endif
threadreturn_t heartbeat1(void* param) gThreadreturn heartbeat1(void* param)
{ {
(void)param; (void)param;
@ -31,10 +31,10 @@ threadreturn_t heartbeat1(void* param)
gfxSleepMilliseconds(500); gfxSleepMilliseconds(500);
} }
return (threadreturn_t)0; return (gThreadreturn)0;
} }
threadreturn_t heartbeat2(void* param) gThreadreturn heartbeat2(void* param)
{ {
(void)param; (void)param;
@ -43,7 +43,7 @@ threadreturn_t heartbeat2(void* param)
gfxSleepMilliseconds(900); gfxSleepMilliseconds(900);
} }
return (threadreturn_t)0; return (gThreadreturn)0;
} }
int main(void) int main(void)

4
demos/modules/gos/threads_advanced/main.c
View File

@ -63,7 +63,7 @@ gfxThreadHandle thd;
* Thread function * Thread function
* Prints a message * Prints a message
*/ */
threadreturn_t Thread_function(void* param) gThreadreturn Thread_function(void* param)
{ {
/* Cast the paramter into a gBool pointer so we can use it */ /* Cast the paramter into a gBool pointer so we can use it */
gBool* doExit = (gBool*)param; gBool* doExit = (gBool*)param;
@ -75,7 +75,7 @@ threadreturn_t Thread_function(void* param)
} }
/* Don't return anything */ /* Don't return anything */
return (threadreturn_t)0; return (gThreadreturn)0;
} }
/* /*

2
src/gadc/gadc.c
View File

@ -224,7 +224,7 @@ void gadcHighSpeedSetISRCallback(GADCISRCallbackFunction isrfn) {
hsISRcallback = isrfn; hsISRcallback = isrfn;
} }
GDataBuffer *gadcHighSpeedGetData(delaytime_t ms) { GDataBuffer *gadcHighSpeedGetData(gDelay ms) {
return (GDataBuffer *)gfxQueueGSyncGet(&hsListDone, ms); return (GDataBuffer *)gfxQueueGSyncGet(&hsListDone, ms);
} }

2
src/gadc/gadc.h
View File

@ -172,7 +172,7 @@ void gadcHighSpeedSetISRCallback(GADCISRCallbackFunction isrfn);
* @api * @api
* @{ * @{
*/ */
GDataBuffer *gadcHighSpeedGetData(delaytime_t ms); GDataBuffer *gadcHighSpeedGetData(gDelay ms);
GDataBuffer *gadcHighSpeedGetDataI(void); GDataBuffer *gadcHighSpeedGetDataI(void);
/** @} */ /** @} */

4
src/gaudio/gaudio.c
View File

@ -119,7 +119,7 @@ void _gaudioDeinit(void)
return gaudio_play_lld_set_volume(vol); return gaudio_play_lld_set_volume(vol);
} }
gBool gaudioPlayWait(delaytime_t ms) { gBool gaudioPlayWait(gDelay ms) {
if (!(playFlags & PLAYFLG_PLAYING)) if (!(playFlags & PLAYFLG_PLAYING))
return gTrue; return gTrue;
return gfxSemWait(&playComplete, ms); return gfxSemWait(&playComplete, ms);
@ -213,7 +213,7 @@ void _gaudioDeinit(void)
gfxBufferRelease(pd); gfxBufferRelease(pd);
} }
GDataBuffer *gaudioRecordGetData(delaytime_t ms) { GDataBuffer *gaudioRecordGetData(gDelay ms) {
return (GDataBuffer *)gfxQueueGSyncGet(&recordList, ms); return (GDataBuffer *)gfxQueueGSyncGet(&recordList, ms);
} }

4
src/gaudio/gaudio.h
View File

@ -193,7 +193,7 @@
* *
* @api * @api
*/ */
gBool gaudioPlayWait(delaytime_t ms); gBool gaudioPlayWait(gDelay ms);
#endif #endif
#if GAUDIO_NEED_RECORD || defined(__DOXYGEN__) #if GAUDIO_NEED_RECORD || defined(__DOXYGEN__)
@ -260,7 +260,7 @@
* *
* @api * @api
*/ */
GDataBuffer *gaudioRecordGetData(delaytime_t ms); GDataBuffer *gaudioRecordGetData(gDelay ms);
#if GFX_USE_GEVENT || defined(__DOXYGEN__) #if GFX_USE_GEVENT || defined(__DOXYGEN__)
/** /**

14
src/gdisp/gdisp_image.c
View File

@ -16,7 +16,7 @@
extern void gdispImageClose_NATIVE(gdispImage *img); extern void gdispImageClose_NATIVE(gdispImage *img);
extern gdispImageError gdispImageCache_NATIVE(gdispImage *img); extern gdispImageError gdispImageCache_NATIVE(gdispImage *img);
extern gdispImageError gdispGImageDraw_NATIVE(GDisplay *g, gdispImage *img, gCoord x, gCoord y, gCoord cx, gCoord cy, gCoord sx, gCoord sy); extern gdispImageError gdispGImageDraw_NATIVE(GDisplay *g, gdispImage *img, gCoord x, gCoord y, gCoord cx, gCoord cy, gCoord sx, gCoord sy);
extern delaytime_t gdispImageNext_NATIVE(gdispImage *img); extern gDelay gdispImageNext_NATIVE(gdispImage *img);
#endif #endif
#if GDISP_NEED_IMAGE_GIF #if GDISP_NEED_IMAGE_GIF
@ -24,7 +24,7 @@
extern void gdispImageClose_GIF(gdispImage *img); extern void gdispImageClose_GIF(gdispImage *img);
extern gdispImageError gdispImageCache_GIF(gdispImage *img); extern gdispImageError gdispImageCache_GIF(gdispImage *img);
extern gdispImageError gdispGImageDraw_GIF(GDisplay *g, gdispImage *img, gCoord x, gCoord y, gCoord cx, gCoord cy, gCoord sx, gCoord sy); extern gdispImageError gdispGImageDraw_GIF(GDisplay *g, gdispImage *img, gCoord x, gCoord y, gCoord cx, gCoord cy, gCoord sx, gCoord sy);
extern delaytime_t gdispImageNext_GIF(gdispImage *img); extern gDelay gdispImageNext_GIF(gdispImage *img);
#endif #endif
#if GDISP_NEED_IMAGE_BMP #if GDISP_NEED_IMAGE_BMP
@ -32,7 +32,7 @@
extern void gdispImageClose_BMP(gdispImage *img); extern void gdispImageClose_BMP(gdispImage *img);
extern gdispImageError gdispImageCache_BMP(gdispImage *img); extern gdispImageError gdispImageCache_BMP(gdispImage *img);
extern gdispImageError gdispGImageDraw_BMP(GDisplay *g, gdispImage *img, gCoord x, gCoord y, gCoord cx, gCoord cy, gCoord sx, gCoord sy); extern gdispImageError gdispGImageDraw_BMP(GDisplay *g, gdispImage *img, gCoord x, gCoord y, gCoord cx, gCoord cy, gCoord sx, gCoord sy);
extern delaytime_t gdispImageNext_BMP(gdispImage *img); extern gDelay gdispImageNext_BMP(gdispImage *img);
extern uint16_t gdispImageGetPaletteSize_BMP(gdispImage *img); extern uint16_t gdispImageGetPaletteSize_BMP(gdispImage *img);
extern gColor gdispImageGetPalette_BMP(gdispImage *img, uint16_t index); extern gColor gdispImageGetPalette_BMP(gdispImage *img, uint16_t index);
extern gBool gdispImageAdjustPalette_BMP(gdispImage *img, uint16_t index, gColor newColor); extern gBool gdispImageAdjustPalette_BMP(gdispImage *img, uint16_t index, gColor newColor);
@ -43,7 +43,7 @@
extern void gdispImageClose_JPG(gdispImage *img); extern void gdispImageClose_JPG(gdispImage *img);
extern gdispImageError gdispImageCache_JPG(gdispImage *img); extern gdispImageError gdispImageCache_JPG(gdispImage *img);
extern gdispImageError gdispGImageDraw_JPG(GDisplay *g, gdispImage *img, gCoord x, gCoord y, gCoord cx, gCoord cy, gCoord sx, gCoord sy); extern gdispImageError gdispGImageDraw_JPG(GDisplay *g, gdispImage *img, gCoord x, gCoord y, gCoord cx, gCoord cy, gCoord sx, gCoord sy);
extern delaytime_t gdispImageNext_JPG(gdispImage *img); extern gDelay gdispImageNext_JPG(gdispImage *img);
#endif #endif
#if GDISP_NEED_IMAGE_PNG #if GDISP_NEED_IMAGE_PNG
@ -51,7 +51,7 @@
extern void gdispImageClose_PNG(gdispImage *img); extern void gdispImageClose_PNG(gdispImage *img);
extern gdispImageError gdispImageCache_PNG(gdispImage *img); extern gdispImageError gdispImageCache_PNG(gdispImage *img);
extern gdispImageError gdispGImageDraw_PNG(GDisplay *g, gdispImage *img, gCoord x, gCoord y, gCoord cx, gCoord cy, gCoord sx, gCoord sy); extern gdispImageError gdispGImageDraw_PNG(GDisplay *g, gdispImage *img, gCoord x, gCoord y, gCoord cx, gCoord cy, gCoord sx, gCoord sy);
extern delaytime_t gdispImageNext_PNG(gdispImage *img); extern gDelay gdispImageNext_PNG(gdispImage *img);
#endif #endif
/* The structure defining the routines for image drawing */ /* The structure defining the routines for image drawing */
@ -64,7 +64,7 @@ typedef struct gdispImageHandlers {
gCoord x, gCoord y, gCoord x, gCoord y,
gCoord cx, gCoord cy, gCoord cx, gCoord cy,
gCoord sx, gCoord sy); /* The draw function */ gCoord sx, gCoord sy); /* The draw function */
delaytime_t (*next)(gdispImage *img); /* The next frame function */ gDelay (*next)(gdispImage *img); /* The next frame function */
uint16_t (*getPaletteSize)(gdispImage *img); /* Retrieve the size of the palette (number of entries) */ uint16_t (*getPaletteSize)(gdispImage *img); /* Retrieve the size of the palette (number of entries) */
gColor (*getPalette)(gdispImage *img, uint16_t index); /* Retrieve a specific color value of the palette */ gColor (*getPalette)(gdispImage *img, uint16_t index); /* Retrieve a specific color value of the palette */
gBool (*adjustPalette)(gdispImage *img, uint16_t index, gColor newColor); /* Replace a color value in the palette */ gBool (*adjustPalette)(gdispImage *img, uint16_t index, gColor newColor); /* Replace a color value in the palette */
@ -186,7 +186,7 @@ gdispImageError gdispGImageDraw(GDisplay *g, gdispImage *img, gCoord x, gCoord y
return img->fns->draw(g, img, x, y, cx, cy, sx, sy); return img->fns->draw(g, img, x, y, cx, cy, sx, sy);
} }
delaytime_t gdispImageNext(gdispImage *img) { gDelay gdispImageNext(gdispImage *img) {
if (!img) return GDISP_IMAGE_ERR_NULLPOINTER; if (!img) return GDISP_IMAGE_ERR_NULLPOINTER;
if (!img->fns) return GDISP_IMAGE_ERR_BADFORMAT; if (!img->fns) return GDISP_IMAGE_ERR_BADFORMAT;
return img->fns->next(img); return img->fns->next(img);

2
src/gdisp/gdisp_image.h
View File

@ -243,7 +243,7 @@ gdispImageError gdispGImageDraw(GDisplay *g, gdispImage *img, gCoord x, gCoord y
* @note Calling gdispImageDraw() after getting a TIME_INFINITE will go back to drawing the first * @note Calling gdispImageDraw() after getting a TIME_INFINITE will go back to drawing the first
* frame/page. * frame/page.
*/ */
delaytime_t gdispImageNext(gdispImage *img); gDelay gdispImageNext(gdispImage *img);
/** /**
* @brief Get the number of entries in the color palette. * @brief Get the number of entries in the color palette.

2
src/gdisp/gdisp_image_bmp.c
View File

@ -815,7 +815,7 @@ gdispImageError gdispGImageDraw_BMP(GDisplay *g, gdispImage *img, gCoord x, gCoo
return GDISP_IMAGE_ERR_OK; return GDISP_IMAGE_ERR_OK;
} }
delaytime_t gdispImageNext_BMP(gdispImage *img) { gDelay gdispImageNext_BMP(gdispImage *img) {
(void) img; (void) img;
/* No more frames/pages */ /* No more frames/pages */

6
src/gdisp/gdisp_image_gif.c
View File

@ -1106,15 +1106,15 @@ baddatacleanup:
return GDISP_IMAGE_ERR_BADDATA; return GDISP_IMAGE_ERR_BADDATA;
} }
delaytime_t gdispImageNext_GIF(gdispImage *img) { gDelay gdispImageNext_GIF(gdispImage *img) {
gdispImagePrivate_GIF * priv; gdispImagePrivate_GIF * priv;
delaytime_t delay; gDelay delay;
uint8_t blocksz; uint8_t blocksz;
priv = (gdispImagePrivate_GIF *)img->priv; priv = (gdispImagePrivate_GIF *)img->priv;
// Save the delay and convert to millisecs // Save the delay and convert to millisecs
delay = (delaytime_t)priv->frame.delay * 10; delay = (gDelay)priv->frame.delay * 10;
// We need to get to the end of this frame // We need to get to the end of this frame
if (!priv->frame.posend) { if (!priv->frame.posend) {

2
src/gdisp/gdisp_image_jpg.c
View File

@ -198,7 +198,7 @@ gdispImageError gdispGImageDraw_JPG(GDisplay *g, gdispImage *img, gCoord x, gCoo
return GDISP_IMAGE_ERR_OK; return GDISP_IMAGE_ERR_OK;
} }
delaytime_t gdispImageNext_JPG(gdispImage *img) { gDelay gdispImageNext_JPG(gdispImage *img) {
(void) img; (void) img;
/* No more frames/pages */ /* No more frames/pages */

2
src/gdisp/gdisp_image_native.c
View File

@ -140,7 +140,7 @@ gdispImageError gdispGImageDraw_NATIVE(GDisplay *g, gdispImage *img, gCoord x, g
return GDISP_IMAGE_ERR_OK; return GDISP_IMAGE_ERR_OK;
} }
delaytime_t gdispImageNext_NATIVE(gdispImage *img) { gDelay gdispImageNext_NATIVE(gdispImage *img) {
(void) img; (void) img;
/* No more frames/pages */ /* No more frames/pages */

2
src/gdisp/gdisp_image_png.c
View File

@ -1621,7 +1621,7 @@ baddata:
return GDISP_IMAGE_ERR_BADDATA; return GDISP_IMAGE_ERR_BADDATA;
} }
delaytime_t gdispImageNext_PNG(gdispImage *img) { gDelay gdispImageNext_PNG(gdispImage *img) {
(void) img; (void) img;
/* No more frames/pages */ /* No more frames/pages */

2
src/gevent/gevent.c
View File

@ -115,7 +115,7 @@ void geventDetachSource(GListener *pl, GSourceHandle gsh) {
} }
} }
GEvent *geventEventWait(GListener *pl, delaytime_t timeout) { GEvent *geventEventWait(GListener *pl, gDelay timeout) {
/* NOTE: /* NOTE:
We no longer try to protect against two threads trying to listen on the We no longer try to protect against two threads trying to listen on the
one listener. This was never allowed, it makes little sense to try to do so, one listener. This was never allowed, it makes little sense to try to do so,

2
src/gevent/gevent.h
View File

@ -157,7 +157,7 @@ void geventDetachSource(GListener *pl, GSourceHandle gsh);
* *
* @return NULL on timeout * @return NULL on timeout
*/ */
GEvent *geventEventWait(GListener *pl, delaytime_t timeout); GEvent *geventEventWait(GListener *pl, gDelay timeout);
/** /**
* @brief Release the GEvent buffer associated with a listener. * @brief Release the GEvent buffer associated with a listener.

2
src/gfile/gfile_fatfs_wrapper.c
View File

@ -48,7 +48,7 @@
/*------------------------------------------------------------------------*/ /*------------------------------------------------------------------------*/
int ff_req_grant(_SYNC_t sobj) int ff_req_grant(_SYNC_t sobj)
{ {
if (gfxSemWait( (gfxSem*)&sobj, (delaytime_t)_FS_TIMEOUT) ) if (gfxSemWait( (gfxSem*)&sobj, (gDelay)_FS_TIMEOUT) )
return gTrue; return gTrue;
return gFalse; return gFalse;
} }

2
src/ginput/ginput_driver_mouse.h
View File

@ -51,7 +51,7 @@ typedef struct GMouse {
#define GMOUSE_FLG_NEEDREAD 0x0040 // The mouse needs reading #define GMOUSE_FLG_NEEDREAD 0x0040 // The mouse needs reading
#define GMOUSE_FLG_DRIVER_FIRST 0x0100 // The first flag available for the driver #define GMOUSE_FLG_DRIVER_FIRST 0x0100 // The first flag available for the driver
gPoint clickpos; // The position of the last click event gPoint clickpos; // The position of the last click event
systemticks_t clicktime; // The time of the last click event gTicks clicktime; // The time of the last click event
GDisplay * display; // The display the mouse is associated with GDisplay * display; // The display the mouse is associated with
#if !GINPUT_TOUCH_NOCALIBRATE #if !GINPUT_TOUCH_NOCALIBRATE
GMouseCalibration caldata; // The calibration data GMouseCalibration caldata; // The calibration data

39
src/gos/gos.h
View File

@ -57,11 +57,11 @@
* @note Your platform may use slightly different definitions to these * @note Your platform may use slightly different definitions to these
* @{ * @{
*/ */
typedef unsigned long delaytime_t; typedef unsigned long gDelay;
typedef unsigned long systemticks_t; typedef unsigned long gTicks;
typedef short semcount_t; typedef short gSemcount;
typedef int threadreturn_t; typedef int gThreadreturn;
typedef int threadpriority_t; typedef int gThreadpriority;
/** @} */ /** @} */
/** /**
@ -70,7 +70,7 @@
* @param[in] fnName The name of the function * @param[in] fnName The name of the function
* @param[in] param A custom parameter that is passed to the function * @param[in] param A custom parameter that is passed to the function
*/ */
#define DECLARE_THREAD_FUNCTION(fnName, param) threadreturn_t fnName(void *param) #define DECLARE_THREAD_FUNCTION(fnName, param) gThreadreturn fnName(void *param)
/** /**
* @brief Declare a thread stack * @brief Declare a thread stack
@ -100,8 +100,8 @@
* @{ * @{
*/ */
#define TIME_IMMEDIATE 0 #define TIME_IMMEDIATE 0
#define TIME_INFINITE ((delaytime_t)-1) #define TIME_INFINITE ((gDelay)-1)
#define MAX_SEMAPHORE_COUNT ((semcount_t)(((unsigned long)((semcount_t)(-1))) >> 1)) #define MAX_SEMAPHORE_COUNT ((gSemcount)(((unsigned long)((gSemcount)(-1))) >> 1))
#define LOW_PRIORITY 0 #define LOW_PRIORITY 0
#define NORMAL_PRIORITY 1 #define NORMAL_PRIORITY 1
#define HIGH_PRIORITY 2 #define HIGH_PRIORITY 2
@ -221,7 +221,7 @@
* *
* @api * @api
*/ */
void gfxSleepMilliseconds(delaytime_t ms); void gfxSleepMilliseconds(gDelay ms);
/** /**
* @brief Put the current thread to sleep for the specified period in microseconds * @brief Put the current thread to sleep for the specified period in microseconds
@ -233,7 +233,7 @@
* *
* @api * @api
*/ */
void gfxSleepMicroseconds(delaytime_t us); void gfxSleepMicroseconds(gDelay us);
/** /**
* @brief Get the current operating system tick time * @brief Get the current operating system tick time
@ -249,7 +249,7 @@
* *
* @api * @api
*/ */
systemticks_t gfxSystemTicks(void); gTicks gfxSystemTicks(void);
/** /**
* @brief Convert a given number of millseconds to a number of operating system ticks * @brief Convert a given number of millseconds to a number of operating system ticks
@ -262,7 +262,7 @@
* *
* @api * @api
*/ */
systemticks_t gfxMillisecondsToTicks(delaytime_t ms); gTicks gfxMillisecondsToTicks(gDelay ms);
/** /**
* @brief Lock the operating system to protect a sequence of code * @brief Lock the operating system to protect a sequence of code
@ -344,7 +344,7 @@
* *
* @api * @api
*/ */
void gfxSemInit(gfxSem *psem, semcount_t val, semcount_t limit); void gfxSemInit(gfxSem *psem, gSemcount val, gSemcount limit);
/** /**
* @brief Destroy a Counted Semaphore * @brief Destroy a Counted Semaphore
@ -368,7 +368,7 @@
* *
* @api * @api
*/ */
gBool gfxSemWait(gfxSem *psem, delaytime_t ms); gBool gfxSemWait(gfxSem *psem, gDelay ms);
/** /**
* @brief Test if a wait on a semaphore can be satisfied immediately * @brief Test if a wait on a semaphore can be satisfied immediately
@ -420,7 +420,7 @@
* *
* @api * @api
*/ */
gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param); gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param);
/** /**
* @brief Wait for a thread to finish. * @brief Wait for a thread to finish.
@ -432,7 +432,7 @@
* once the thread has ended. * once the thread has ended.
* @api * @api
*/ */
threadreturn_t gfxThreadWait(gfxThreadHandle thread); gThreadreturn gfxThreadWait(gfxThreadHandle thread);
/** /**
* @brief Get the current thread handle. * @brief Get the current thread handle.
@ -493,5 +493,12 @@
#error "Your operating system is not supported yet" #error "Your operating system is not supported yet"
#endif #endif
#if GFX_COMPAT_V2
typedef gDelay delaytime_t;
typedef gTicks systemticks_t;
typedef gThreadreturn threadreturn_t;
typedef gThreadpriority threadpriority_t;
#endif
#endif /* _GOS_H */ #endif /* _GOS_H */
/** @} */ /** @} */

4
src/gos/gos_arduino.c
View File

@ -72,10 +72,10 @@ void gfxExit(void) {
* Sleep functions * Sleep functions
*********************************************************/ *********************************************************/
systemticks_t gfxSystemTicks(void) { gTicks gfxSystemTicks(void) {
return millis(); return millis();
} }
systemticks_t gfxMillisecondsToTicks(delaytime_t ms) { gTicks gfxMillisecondsToTicks(gDelay ms) {
return ms; return ms;
} }

4
src/gos/gos_arduino.h
View File

@ -17,8 +17,8 @@
* malloc(), realloc and free() - if GOS_RAW_HEAP_SIZE == 0 * malloc(), realloc and free() - if GOS_RAW_HEAP_SIZE == 0
* *
* You must also define the following routines in your own code so that timing functions will work... * You must also define the following routines in your own code so that timing functions will work...
* systemticks_t gfxSystemTicks(void); * gTicks gfxSystemTicks(void);
* systemticks_t gfxMillisecondsToTicks(delaytime_t ms); * gTicks gfxMillisecondsToTicks(gDelay ms);
*/ */
#ifndef _GOS_ARDUINO_H #ifndef _GOS_ARDUINO_H
#define _GOS_ARDUINO_H #define _GOS_ARDUINO_H

10
src/gos/gos_chibios.c
View File

@ -81,7 +81,7 @@ void *gfxRealloc(void *ptr, size_t oldsz, size_t newsz)
return np; return np;
} }
void gfxSleepMilliseconds(delaytime_t ms) void gfxSleepMilliseconds(gDelay ms)
{ {
switch(ms) { switch(ms) {
case TIME_IMMEDIATE: chThdYield(); return; case TIME_IMMEDIATE: chThdYield(); return;
@ -90,7 +90,7 @@ void gfxSleepMilliseconds(delaytime_t ms)
} }
} }
void gfxSleepMicroseconds(delaytime_t ms) void gfxSleepMicroseconds(gDelay ms)
{ {
switch(ms) { switch(ms) {
case TIME_IMMEDIATE: return; case TIME_IMMEDIATE: return;
@ -99,7 +99,7 @@ void gfxSleepMicroseconds(delaytime_t ms)
} }
} }
void gfxSemInit(gfxSem *psem, semcount_t val, semcount_t limit) void gfxSemInit(gfxSem *psem, gSemcount val, gSemcount limit)
{ {
if (val > limit) if (val > limit)
val = limit; val = limit;
@ -118,7 +118,7 @@ void gfxSemDestroy(gfxSem *psem)
chSemReset(&psem->sem, 1); chSemReset(&psem->sem, 1);
} }
gBool gfxSemWait(gfxSem *psem, delaytime_t ms) gBool gfxSemWait(gfxSem *psem, gDelay ms)
{ {
#if CH_KERNEL_MAJOR <= 2 #if CH_KERNEL_MAJOR <= 2
switch(ms) { switch(ms) {
@ -175,7 +175,7 @@ void gfxSemSignalI(gfxSem *psem)
#endif #endif
} }
gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param) gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param)
{ {
if (!stackarea) { if (!stackarea) {
if (!stacksz) stacksz = 256; if (!stacksz) stacksz = 256;

30
src/gos/gos_chibios.h
View File

@ -31,28 +31,28 @@
*/ */
#if CH_KERNEL_MAJOR <= 4 #if CH_KERNEL_MAJOR <= 4
typedef systime_t delaytime_t; typedef systime_t gDelay;
#else #else
typedef sysinterval_t delaytime_t; typedef sysinterval_t gDelay;
#endif #endif
typedef systime_t systemticks_t; typedef systime_t gTicks;
typedef cnt_t semcount_t; typedef cnt_t gSemcount;
typedef msg_t threadreturn_t; typedef msg_t gThreadreturn;
typedef tprio_t threadpriority_t; typedef tprio_t gThreadpriority;
#define MAX_SEMAPHORE_COUNT ((semcount_t)(((unsigned long)((semcount_t)(-1))) >> 1)) #define MAX_SEMAPHORE_COUNT ((gSemcount)(((unsigned long)((gSemcount)(-1))) >> 1))
#define LOW_PRIORITY LOWPRIO #define LOW_PRIORITY LOWPRIO
#define NORMAL_PRIORITY NORMALPRIO #define NORMAL_PRIORITY NORMALPRIO
#define HIGH_PRIORITY HIGHPRIO #define HIGH_PRIORITY HIGHPRIO
#define DECLARE_THREAD_STACK(name, sz) WORKING_AREA(name, sz) #define DECLARE_THREAD_STACK(name, sz) WORKING_AREA(name, sz)
#define DECLARE_THREAD_FUNCTION(fnName, param) threadreturn_t fnName(void *param) #define DECLARE_THREAD_FUNCTION(fnName, param) gThreadreturn fnName(void *param)
#define THREAD_RETURN(retval) return retval #define THREAD_RETURN(retval) return retval
#if CH_KERNEL_MAJOR <= 2 #if CH_KERNEL_MAJOR <= 2
typedef struct { typedef struct {
Semaphore sem; Semaphore sem;
semcount_t limit; gSemcount limit;
} gfxSem; } gfxSem;
typedef Mutex gfxMutex; typedef Mutex gfxMutex;
@ -63,7 +63,7 @@ typedef tprio_t threadpriority_t;
typedef struct { typedef struct {
semaphore_t sem; semaphore_t sem;
semcount_t limit; gSemcount limit;
} gfxSem; } gfxSem;
typedef mutex_t gfxMutex; typedef mutex_t gfxMutex;
@ -104,15 +104,15 @@ typedef tprio_t threadpriority_t;
#define gfxMutexDestroy(pmutex) (void)pmutex #define gfxMutexDestroy(pmutex) (void)pmutex
#define gfxMutexEnter(pmutex) chMtxLock(pmutex) #define gfxMutexEnter(pmutex) chMtxLock(pmutex)
void *gfxRealloc(void *ptr, size_t oldsz, size_t newsz); void *gfxRealloc(void *ptr, size_t oldsz, size_t newsz);
void gfxSleepMilliseconds(delaytime_t ms); void gfxSleepMilliseconds(gDelay ms);
void gfxSleepMicroseconds(delaytime_t ms); void gfxSleepMicroseconds(gDelay ms);
void gfxSemInit(gfxSem *psem, semcount_t val, semcount_t limit); void gfxSemInit(gfxSem *psem, gSemcount val, gSemcount limit);
void gfxSemDestroy(gfxSem *psem); void gfxSemDestroy(gfxSem *psem);
gBool gfxSemWait(gfxSem *psem, delaytime_t ms); gBool gfxSemWait(gfxSem *psem, gDelay ms);
gBool gfxSemWaitI(gfxSem *psem); gBool gfxSemWaitI(gfxSem *psem);
void gfxSemSignal(gfxSem *psem); void gfxSemSignal(gfxSem *psem);
void gfxSemSignalI(gfxSem *psem); void gfxSemSignalI(gfxSem *psem);
gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param); gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param);
#define gfxThreadWait(thread) chThdWait(thread) #define gfxThreadWait(thread) chThdWait(thread)
#define gfxThreadMe() chThdSelf() #define gfxThreadMe() chThdSelf()
#define gfxThreadClose(thread) (void)thread #define gfxThreadClose(thread) (void)thread

8
src/gos/gos_cmsis.c
View File

@ -46,7 +46,7 @@ void gfxMutexInit(gfxMutex* pmutex)
pmutex->id = osMutexCreate(&def); pmutex->id = osMutexCreate(&def);
} }
void gfxSemInit(gfxSem* psem, semcount_t val, semcount_t limit) void gfxSemInit(gfxSem* psem, gSemcount val, gSemcount limit)
{ {
osSemaphoreDef_t def; osSemaphoreDef_t def;
def.semaphore = psem->semaphore; def.semaphore = psem->semaphore;
@ -61,7 +61,7 @@ void gfxSemDestroy(gfxSem* psem)
osSemaphoreDelete(psem->id); osSemaphoreDelete(psem->id);
} }
gBool gfxSemWait(gfxSem* psem, delaytime_t ms) gBool gfxSemWait(gfxSem* psem, gDelay ms)
{ {
if (osSemaphoreWait(psem->id, ms) > 0) { if (osSemaphoreWait(psem->id, ms) > 0) {
psem->available++; psem->available++;
@ -88,7 +88,7 @@ void gfxSemSignalI(gfxSem* psem)
} }
} }
gfxThreadHandle gfxThreadCreate(void* stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION((*fn),p), void* param) gfxThreadHandle gfxThreadCreate(void* stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION((*fn),p), void* param)
{ {
osThreadDef_t def; osThreadDef_t def;
@ -102,7 +102,7 @@ gfxThreadHandle gfxThreadCreate(void* stackarea, size_t stacksz, threadpriority_
return osThreadCreate(&def, param); return osThreadCreate(&def, param);
} }
threadreturn_t gfxThreadWait(gfxThreadHandle thread) { gThreadreturn gfxThreadWait(gfxThreadHandle thread) {
while(osThreadGetPriority(thread) == osPriorityError) while(osThreadGetPriority(thread) == osPriorityError)
gfxYield(); gfxYield();
} }

20
src/gos/gos_cmsis.h
View File

@ -27,11 +27,11 @@
#define TIME_IMMEDIATE 0 #define TIME_IMMEDIATE 0
#define TIME_INFINITE osWaitForever #define TIME_INFINITE osWaitForever
typedef uint32_t delaytime_t; typedef uint32_t gDelay;
typedef uint32_t systemticks_t; typedef uint32_t gTicks;
typedef uint16_t semcount_t; typedef uint16_t gSemcount;
typedef void threadreturn_t; typedef void gThreadreturn;
typedef osPriority threadpriority_t; typedef osPriority gThreadpriority;
#define MAX_SEMAPHORE_COUNT osFeature_Semaphore #define MAX_SEMAPHORE_COUNT osFeature_Semaphore
#define LOW_PRIORITY osPriorityLow #define LOW_PRIORITY osPriorityLow
@ -41,7 +41,7 @@ typedef osPriority threadpriority_t;
typedef struct gfxSem { typedef struct gfxSem {
uint32_t semaphore[2]; uint32_t semaphore[2];
osSemaphoreId id; osSemaphoreId id;
semcount_t available; gSemcount available;
} gfxSem; } gfxSem;
typedef struct gfxMutex { typedef struct gfxMutex {
@ -52,7 +52,7 @@ typedef struct gfxMutex {
typedef osThreadId gfxThreadHandle; typedef osThreadId gfxThreadHandle;
#define DECLARE_THREAD_STACK(name, sz) uint8_t name[1]; // Some compilers don't allow zero sized arrays. Let's waste one byte #define DECLARE_THREAD_STACK(name, sz) uint8_t name[1]; // Some compilers don't allow zero sized arrays. Let's waste one byte
#define DECLARE_THREAD_FUNCTION(fnName, param) threadreturn_t fnName(void* param) #define DECLARE_THREAD_FUNCTION(fnName, param) gThreadreturn fnName(void* param)
#define THREAD_RETURN(retval) #define THREAD_RETURN(retval)
/*===========================================================================*/ /*===========================================================================*/
@ -72,14 +72,14 @@ void gfxMutexInit(gfxMutex* pmutex);
#define gfxMutexEnter(pmutex) osMutexWait((pmutex)->id, TIME_INFINITE) #define gfxMutexEnter(pmutex) osMutexWait((pmutex)->id, TIME_INFINITE)
#define gfxMutexExit(pmutex) osMutexRelease((pmutex)->id) #define gfxMutexExit(pmutex) osMutexRelease((pmutex)->id)
void gfxSemInit(gfxSem* psem, semcount_t val, semcount_t limit); void gfxSemInit(gfxSem* psem, gSemcount val, gSemcount limit);
void gfxSemDestroy(gfxSem* psem); void gfxSemDestroy(gfxSem* psem);
gBool gfxSemWait(gfxSem* psem, delaytime_t ms); gBool gfxSemWait(gfxSem* psem, gDelay ms);
gBool gfxSemWaitI(gfxSem* psem); gBool gfxSemWaitI(gfxSem* psem);
void gfxSemSignal(gfxSem* psem); void gfxSemSignal(gfxSem* psem);
void gfxSemSignalI(gfxSem* psem); void gfxSemSignalI(gfxSem* psem);
gfxThreadHandle gfxThreadCreate(void* stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION((*fn),p), void* param); gfxThreadHandle gfxThreadCreate(void* stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION((*fn),p), void* param);
#define gfxYield() osThreadYield() #define gfxYield() osThreadYield()
#define gfxThreadMe() osThreadGetId() #define gfxThreadMe() osThreadGetId()
#define gfxThreadClose(thread) {} #define gfxThreadClose(thread) {}

8
src/gos/gos_cmsis2.c
View File

@ -64,19 +64,19 @@ void gfxMutexInit(gfxMutex* pmutex)
*pmutex = osMutexNew(NULL); *pmutex = osMutexNew(NULL);
} }
void gfxSemInit(gfxSem* psem, semcount_t val, semcount_t limit) void gfxSemInit(gfxSem* psem, gSemcount val, gSemcount limit)
{ {
*psem = osSemaphoreNew(limit, val, NULL); *psem = osSemaphoreNew(limit, val, NULL);
} }
gBool gfxSemWait(gfxSem* psem, delaytime_t ms) gBool gfxSemWait(gfxSem* psem, gDelay ms)
{ {
if (osSemaphoreAcquire(*psem, gfxMillisecondsToTicks(ms)) == osOK) if (osSemaphoreAcquire(*psem, gfxMillisecondsToTicks(ms)) == osOK)
return gTrue; return gTrue;
return gFalse; return gFalse;
} }
gfxThreadHandle gfxThreadCreate(void* stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION((*fn),p), void* param) gfxThreadHandle gfxThreadCreate(void* stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION((*fn),p), void* param)
{ {
osThreadAttr_t def; osThreadAttr_t def;
@ -93,7 +93,7 @@ gfxThreadHandle gfxThreadCreate(void* stackarea, size_t stacksz, threadpriority_
return osThreadNew((osThreadFunc_t)fn, param, &def); return osThreadNew((osThreadFunc_t)fn, param, &def);
} }
threadreturn_t gfxThreadWait(gfxThreadHandle thread) { gThreadreturn gfxThreadWait(gfxThreadHandle thread) {
while(1) { while(1) {
switch(osThreadGetState(thread)) { switch(osThreadGetState(thread)) {
case osThreadReady: case osThreadReady:

18
src/gos/gos_cmsis2.h
View File

@ -27,11 +27,11 @@
#define TIME_IMMEDIATE 0 #define TIME_IMMEDIATE 0
#define TIME_INFINITE osWaitForever #define TIME_INFINITE osWaitForever
typedef uint32_t delaytime_t; typedef uint32_t gDelay;
typedef uint32_t systemticks_t; typedef uint32_t gTicks;
typedef uint16_t semcount_t; typedef uint16_t gSemcount;
typedef void threadreturn_t; typedef void gThreadreturn;
typedef osPriority_t threadpriority_t; typedef osPriority_t gThreadpriority;
#define MAX_SEMAPHORE_COUNT 65535UL #define MAX_SEMAPHORE_COUNT 65535UL
#define LOW_PRIORITY osPriorityLow #define LOW_PRIORITY osPriorityLow
@ -45,7 +45,7 @@ typedef osMutexId_t gfxMutex;
typedef osThreadId_t gfxThreadHandle; typedef osThreadId_t gfxThreadHandle;
#define DECLARE_THREAD_STACK(name, sz) uint8_t name[1]; // Some compilers don't allow zero sized arrays. Let's waste one byte #define DECLARE_THREAD_STACK(name, sz) uint8_t name[1]; // Some compilers don't allow zero sized arrays. Let's waste one byte
#define DECLARE_THREAD_FUNCTION(fnName, param) threadreturn_t fnName(void* param) #define DECLARE_THREAD_FUNCTION(fnName, param) gThreadreturn fnName(void* param)
#define THREAD_RETURN(retval) #define THREAD_RETURN(retval)
/*===========================================================================*/ /*===========================================================================*/
@ -65,14 +65,14 @@ void gfxMutexInit(gfxMutex* pmutex);
#define gfxMutexEnter(pmutex) osMutexAcquire(*(pmutex), TIME_INFINITE) #define gfxMutexEnter(pmutex) osMutexAcquire(*(pmutex), TIME_INFINITE)
#define gfxMutexExit(pmutex) osMutexRelease(*(pmutex)) #define gfxMutexExit(pmutex) osMutexRelease(*(pmutex))
void gfxSemInit(gfxSem* psem, semcount_t val, semcount_t limit); void gfxSemInit(gfxSem* psem, gSemcount val, gSemcount limit);
#define gfxSemDestroy(psem) osSemaphoreDelete(*(psem)) #define gfxSemDestroy(psem) osSemaphoreDelete(*(psem))
gBool gfxSemWait(gfxSem* psem, delaytime_t ms); gBool gfxSemWait(gfxSem* psem, gDelay ms);
#define gfxSemWaitI(psem) gfxSemWait((psem), 0) #define gfxSemWaitI(psem) gfxSemWait((psem), 0)
#define gfxSemSignal(psem) osSemaphoreRelease(*(psem)) #define gfxSemSignal(psem) osSemaphoreRelease(*(psem))
#define gfxSemSignalI(psem) osSemaphoreRelease(*(psem)) #define gfxSemSignalI(psem) osSemaphoreRelease(*(psem))
gfxThreadHandle gfxThreadCreate(void* stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION((*fn),p), void* param); gfxThreadHandle gfxThreadCreate(void* stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION((*fn),p), void* param);
#define gfxYield() osThreadYield() #define gfxYield() osThreadYield()
#define gfxThreadMe() osThreadGetId() #define gfxThreadMe() osThreadGetId()
#define gfxThreadClose(thread) {} #define gfxThreadClose(thread) {}

10
src/gos/gos_ecos.c
View File

@ -32,7 +32,7 @@ void _gosDeinit(void)
/* ToDo */ /* ToDo */
} }
void gfxSleepMilliseconds(delaytime_t ms) void gfxSleepMilliseconds(gDelay ms)
{ {
switch(ms) { switch(ms) {
case TIME_IMMEDIATE: cyg_thread_yield(); return; case TIME_IMMEDIATE: cyg_thread_yield(); return;
@ -41,7 +41,7 @@ void gfxSleepMilliseconds(delaytime_t ms)
} }
} }
void gfxSleepMicroseconds(delaytime_t ms) void gfxSleepMicroseconds(gDelay ms)
{ {
switch(ms) { switch(ms) {
case TIME_IMMEDIATE: return; case TIME_IMMEDIATE: return;
@ -50,7 +50,7 @@ void gfxSleepMicroseconds(delaytime_t ms)
} }
} }
void gfxSemInit(gfxSem *psem, semcount_t val, semcount_t limit) void gfxSemInit(gfxSem *psem, gSemcount val, gSemcount limit)
{ {
if (val > limit) if (val > limit)
val = limit; val = limit;
@ -64,7 +64,7 @@ void gfxSemDestroy(gfxSem *psem)
cyg_semaphore_destroy(&psem->sem); cyg_semaphore_destroy(&psem->sem);
} }
gBool gfxSemWait(gfxSem *psem, delaytime_t ms) gBool gfxSemWait(gfxSem *psem, gDelay ms)
{ {
switch(ms) { switch(ms) {
case TIME_IMMEDIATE: return cyg_semaphore_trywait(&psem->sem); case TIME_IMMEDIATE: return cyg_semaphore_trywait(&psem->sem);
@ -96,7 +96,7 @@ void gfxSemSignalI(gfxSem *psem)
cyg_semaphore_post(&psem->sem); cyg_semaphore_post(&psem->sem);
} }
gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param) gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param)
{ {
gfxThreadHandle th; gfxThreadHandle th;

24
src/gos/gos_ecos.h
View File

@ -21,11 +21,11 @@
#define TIME_IMMEDIATE 0 #define TIME_IMMEDIATE 0
#define TIME_INFINITE 0xFFFFFFFF #define TIME_INFINITE 0xFFFFFFFF
typedef cyg_ucount32 delaytime_t; typedef cyg_ucount32 gDelay;
typedef cyg_tick_count_t systemticks_t; typedef cyg_tick_count_t gTicks;
typedef cyg_count32 semcount_t; typedef cyg_count32 gSemcount;
typedef void threadreturn_t; typedef void gThreadreturn;
typedef cyg_addrword_t threadpriority_t; typedef cyg_addrword_t gThreadpriority;
typedef cyg_handle_t gfxThreadHandle; typedef cyg_handle_t gfxThreadHandle;
#define MAX_SEMAPHORE_COUNT 0x7FFFFFFF #define MAX_SEMAPHORE_COUNT 0x7FFFFFFF
@ -34,12 +34,12 @@ typedef cyg_handle_t gfxThreadHandle;
#define HIGH_PRIORITY 0 #define HIGH_PRIORITY 0
#define DECLARE_THREAD_STACK(name, sz) struct { cyg_thread t; unsigned char stk[(sz) & ~3]; } name[1] #define DECLARE_THREAD_STACK(name, sz) struct { cyg_thread t; unsigned char stk[(sz) & ~3]; } name[1]
#define DECLARE_THREAD_FUNCTION(fnName, param) threadreturn_t fnName(cyg_addrword_t param) #define DECLARE_THREAD_FUNCTION(fnName, param) gThreadreturn fnName(cyg_addrword_t param)
#define THREAD_RETURN(retval) #define THREAD_RETURN(retval)
typedef struct { typedef struct {
cyg_sem_t sem; cyg_sem_t sem;
semcount_t limit; gSemcount limit;
} gfxSem; } gfxSem;
typedef cyg_mutex_t gfxMutex; typedef cyg_mutex_t gfxMutex;
@ -55,8 +55,8 @@ typedef cyg_mutex_t gfxMutex;
#define gfxYield() cyg_thread_yield() #define gfxYield() cyg_thread_yield()
#define gfxMillisecondsToTicks(ms) (((ms)*(CYGNUM_HAL_RTC_DENOMINATOR*1000))/(CYGNUM_HAL_RTC_NUMERATOR/1000)) #define gfxMillisecondsToTicks(ms) (((ms)*(CYGNUM_HAL_RTC_DENOMINATOR*1000))/(CYGNUM_HAL_RTC_NUMERATOR/1000))
void gfxSleepMilliseconds(delaytime_t ms); void gfxSleepMilliseconds(gDelay ms);
void gfxSleepMicroseconds(delaytime_t ms); void gfxSleepMicroseconds(gDelay ms);
#define gfxAlloc(sz) malloc(sz) #define gfxAlloc(sz) malloc(sz)
#define gfxFree(ptr) free(ptr) #define gfxFree(ptr) free(ptr)
@ -70,14 +70,14 @@ void gfxSleepMicroseconds(delaytime_t ms);
#define gfxMutexDestroy(pmutex) cyg_mutex_destroy(pmutex) #define gfxMutexDestroy(pmutex) cyg_mutex_destroy(pmutex)
#define gfxMutexEnter(pmutex) cyg_mutex_lock(pmutex) #define gfxMutexEnter(pmutex) cyg_mutex_lock(pmutex)
void gfxSemInit(gfxSem *psem, semcount_t val, semcount_t limit); void gfxSemInit(gfxSem *psem, gSemcount val, gSemcount limit);
void gfxSemDestroy(gfxSem *psem); void gfxSemDestroy(gfxSem *psem);
gBool gfxSemWait(gfxSem *psem, delaytime_t ms); gBool gfxSemWait(gfxSem *psem, gDelay ms);
gBool gfxSemWaitI(gfxSem *psem); gBool gfxSemWaitI(gfxSem *psem);
void gfxSemSignal(gfxSem *psem); void gfxSemSignal(gfxSem *psem);
void gfxSemSignalI(gfxSem *psem); void gfxSemSignalI(gfxSem *psem);
gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param); gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param);
#define gfxThreadWait(thread) NOTIMPLEMENTED_YET #define gfxThreadWait(thread) NOTIMPLEMENTED_YET
#define gfxThreadMe() cyg_thread_self() #define gfxThreadMe() cyg_thread_self()
#define gfxThreadClose(thread) (void)thread #define gfxThreadClose(thread) (void)thread

12
src/gos/gos_freertos.c
View File

@ -85,12 +85,12 @@ void* gfxRealloc(void *ptr, size_t oldsz, size_t newsz)
return np; return np;
} }
void gfxSleepMilliseconds(delaytime_t ms) void gfxSleepMilliseconds(gDelay ms)
{ {
vTaskDelay(gfxMillisecondsToTicks(ms)); vTaskDelay(gfxMillisecondsToTicks(ms));
} }
void gfxSleepMicroseconds(delaytime_t ms) void gfxSleepMicroseconds(gDelay ms)
{ {
// delay milli seconds - microsecond resolution delay is not supported in FreeRTOS // delay milli seconds - microsecond resolution delay is not supported in FreeRTOS
@ -106,7 +106,7 @@ void gfxMutexInit(gfxMutex *pmutex)
#endif #endif
} }
void gfxSemInit(gfxSem* psem, semcount_t val, semcount_t limit) void gfxSemInit(gfxSem* psem, gSemcount val, gSemcount limit)
{ {
if (val > limit) if (val > limit)
val = limit; val = limit;
@ -117,7 +117,7 @@ void gfxSemInit(gfxSem* psem, semcount_t val, semcount_t limit)
#endif #endif
} }
gBool gfxSemWait(gfxSem* psem, delaytime_t ms) gBool gfxSemWait(gfxSem* psem, gDelay ms)
{ {
if (xSemaphoreTake(*psem, gfxMillisecondsToTicks(ms)) == pdPASS) if (xSemaphoreTake(*psem, gfxMillisecondsToTicks(ms)) == pdPASS)
return gTrue; return gTrue;
@ -146,7 +146,7 @@ void gfxSemSignalI(gfxSem* psem)
xSemaphoreGiveFromISR(*psem,&xHigherPriorityTaskWoken); xSemaphoreGiveFromISR(*psem,&xHigherPriorityTaskWoken);
} }
gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param) gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param)
{ {
gfxThreadHandle task; gfxThreadHandle task;
(void) stackarea; (void) stackarea;
@ -165,7 +165,7 @@ gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_
} }
#if INCLUDE_eTaskGetState == 1 #if INCLUDE_eTaskGetState == 1
threadreturn_t gfxThreadWait(gfxThreadHandle thread) { gThreadreturn gfxThreadWait(gfxThreadHandle thread) {
while (eTaskGetState(thread) != eDeleted) while (eTaskGetState(thread) != eDeleted)
gfxYield(); gfxYield();
} }

30
src/gos/gos_freertos.h
View File

@ -25,21 +25,21 @@
/*===========================================================================*/ /*===========================================================================*/
#define TIME_IMMEDIATE 0 #define TIME_IMMEDIATE 0
#define TIME_INFINITE ((delaytime_t)-1) #define TIME_INFINITE ((gDelay)-1)
typedef uint32_t delaytime_t; typedef uint32_t gDelay;
typedef portTickType systemticks_t; typedef portTickType gTicks;
typedef int32_t semcount_t; typedef int32_t gSemcount;
typedef void threadreturn_t; typedef void gThreadreturn;
typedef portBASE_TYPE threadpriority_t; typedef portBASE_TYPE gThreadpriority;
#define MAX_SEMAPHORE_COUNT ((semcount_t)(((unsigned long)((semcount_t)(-1))) >> 1)) #define MAX_SEMAPHORE_COUNT ((gSemcount)(((unsigned long)((gSemcount)(-1))) >> 1))
#define LOW_PRIORITY 0 #define LOW_PRIORITY 0
#define NORMAL_PRIORITY configMAX_PRIORITIES/2 #define NORMAL_PRIORITY configMAX_PRIORITIES/2
#define HIGH_PRIORITY configMAX_PRIORITIES-1 #define HIGH_PRIORITY configMAX_PRIORITIES-1
/* FreeRTOS will allocate the stack when creating the thread */ /* FreeRTOS will allocate the stack when creating the thread */
#define DECLARE_THREAD_STACK(name, sz) uint8_t name[1] #define DECLARE_THREAD_STACK(name, sz) uint8_t name[1]
#define DECLARE_THREAD_FUNCTION(fnName, param) threadreturn_t fnName(void *param) #define DECLARE_THREAD_FUNCTION(fnName, param) gThreadreturn fnName(void *param)
#define THREAD_RETURN(retval) #define THREAD_RETURN(retval)
typedef xSemaphoreHandle gfxSem; typedef xSemaphoreHandle gfxSem;
@ -56,7 +56,7 @@ typedef xTaskHandle gfxThreadHandle;
#define gfxFree(ptr) vPortFree(ptr) #define gfxFree(ptr) vPortFree(ptr)
#define gfxYield() taskYIELD() #define gfxYield() taskYIELD()
#define gfxSystemTicks() xTaskGetTickCount() #define gfxSystemTicks() xTaskGetTickCount()
#define gfxMillisecondsToTicks(ms) ((systemticks_t)((ms) / portTICK_PERIOD_MS)) #define gfxMillisecondsToTicks(ms) ((gTicks)((ms) / portTICK_PERIOD_MS))
#define gfxSystemLock() taskENTER_CRITICAL() #define gfxSystemLock() taskENTER_CRITICAL()
#define gfxSystemUnlock() taskEXIT_CRITICAL() #define gfxSystemUnlock() taskEXIT_CRITICAL()
@ -66,20 +66,20 @@ void gfxMutexInit(gfxMutex* s);
#define gfxMutexExit(pmutex) xSemaphoreGive(*(pmutex)) #define gfxMutexExit(pmutex) xSemaphoreGive(*(pmutex))
void *gfxRealloc(void *ptr, size_t oldsz, size_t newsz); void *gfxRealloc(void *ptr, size_t oldsz, size_t newsz);
void gfxSleepMilliseconds(delaytime_t ms); void gfxSleepMilliseconds(gDelay ms);
void gfxSleepMicroseconds(delaytime_t ms); void gfxSleepMicroseconds(gDelay ms);
void gfxSemInit(gfxSem* psem, semcount_t val, semcount_t limit); void gfxSemInit(gfxSem* psem, gSemcount val, gSemcount limit);
#define gfxSemDestroy(psem) vSemaphoreDelete(*(psem)) #define gfxSemDestroy(psem) vSemaphoreDelete(*(psem))
gBool gfxSemWait(gfxSem* psem, delaytime_t ms); gBool gfxSemWait(gfxSem* psem, gDelay ms);
gBool gfxSemWaitI(gfxSem* psem); gBool gfxSemWaitI(gfxSem* psem);
void gfxSemSignal(gfxSem* psem); void gfxSemSignal(gfxSem* psem);
void gfxSemSignalI(gfxSem* psem); void gfxSemSignalI(gfxSem* psem);
gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param); gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param);
#define gfxThreadMe() xTaskGetCurrentTaskHandle() #define gfxThreadMe() xTaskGetCurrentTaskHandle()
#if INCLUDE_eTaskGetState == 1 #if INCLUDE_eTaskGetState == 1
threadreturn_t gfxThreadWait(gfxThreadHandle thread); gThreadreturn gfxThreadWait(gfxThreadHandle thread);
#endif #endif
#define gfxThreadClose(thread) #define gfxThreadClose(thread)

20
src/gos/gos_linux.c
View File

@ -60,7 +60,7 @@ void gfxHalt(const char *msg) {
exit(1); exit(1);
} }
void gfxSleepMilliseconds(delaytime_t ms) { void gfxSleepMilliseconds(gDelay ms) {
struct timespec ts; struct timespec ts;
switch(ms) { switch(ms) {
@ -81,7 +81,7 @@ void gfxSleepMilliseconds(delaytime_t ms) {
} }
} }
void gfxSleepMicroseconds(delaytime_t us) { void gfxSleepMicroseconds(gDelay us) {
struct timespec ts; struct timespec ts;
switch(us) { switch(us) {
@ -102,14 +102,14 @@ void gfxSleepMicroseconds(delaytime_t us) {
} }
} }
systemticks_t gfxSystemTicks(void) { gTicks gfxSystemTicks(void) {
struct timespec ts; struct timespec ts;
clock_gettime(CLOCK_MONOTONIC, &ts); clock_gettime(CLOCK_MONOTONIC, &ts);
return ts.tv_sec * 1000 + ts.tv_nsec / 1000000; return ts.tv_sec * 1000 + ts.tv_nsec / 1000000;
} }
gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param) { gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param) {
gfxThreadHandle th; gfxThreadHandle th;
(void) stackarea; (void) stackarea;
(void) stacksz; (void) stacksz;
@ -128,8 +128,8 @@ gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_
return th; return th;
} }
threadreturn_t gfxThreadWait(gfxThreadHandle thread) { gThreadreturn gfxThreadWait(gfxThreadHandle thread) {
threadreturn_t retval; gThreadreturn retval;
if (pthread_join(thread, &retval)) if (pthread_join(thread, &retval))
return 0; return 0;
@ -138,14 +138,14 @@ threadreturn_t gfxThreadWait(gfxThreadHandle thread) {
} }
#if GFX_USE_POSIX_SEMAPHORES #if GFX_USE_POSIX_SEMAPHORES
void gfxSemInit(gfxSem *pSem, semcount_t val, semcount_t limit) { void gfxSemInit(gfxSem *pSem, gSemcount val, gSemcount limit) {
pSem->max = limit; pSem->max = limit;
sem_init(&pSem->sem, 0, val); sem_init(&pSem->sem, 0, val);
} }
void gfxSemDestroy(gfxSem *pSem) { void gfxSemDestroy(gfxSem *pSem) {
sem_destroy(&pSem->sem); sem_destroy(&pSem->sem);
} }
gBool gfxSemWait(gfxSem *pSem, delaytime_t ms) { gBool gfxSemWait(gfxSem *pSem, gDelay ms) {
switch (ms) { switch (ms) {
case TIME_INFINITE: case TIME_INFINITE:
return sem_wait(&pSem->sem) ? gFalse : gTrue; return sem_wait(&pSem->sem) ? gFalse : gTrue;
@ -173,7 +173,7 @@ threadreturn_t gfxThreadWait(gfxThreadHandle thread) {
sem_post(&pSem->sem); sem_post(&pSem->sem);
} }
#else #else
void gfxSemInit(gfxSem *pSem, semcount_t val, semcount_t limit) { void gfxSemInit(gfxSem *pSem, gSemcount val, gSemcount limit) {
pthread_mutex_init(&pSem->mtx, 0); pthread_mutex_init(&pSem->mtx, 0);
pthread_cond_init(&pSem->cond, 0); pthread_cond_init(&pSem->cond, 0);
pthread_mutex_lock(&pSem->mtx); pthread_mutex_lock(&pSem->mtx);
@ -185,7 +185,7 @@ threadreturn_t gfxThreadWait(gfxThreadHandle thread) {
pthread_mutex_destroy(&pSem->mtx); pthread_mutex_destroy(&pSem->mtx);
pthread_cond_destroy(&pSem->cond); pthread_cond_destroy(&pSem->cond);
} }
gBool gfxSemWait(gfxSem *pSem, delaytime_t ms) { gBool gfxSemWait(gfxSem *pSem, gDelay ms) {
pthread_mutex_lock(&pSem->mtx); pthread_mutex_lock(&pSem->mtx);
switch (ms) { switch (ms) {

36
src/gos/gos_linux.h
View File

@ -23,15 +23,15 @@
#include <semaphore.h> #include <semaphore.h>
#endif #endif
typedef unsigned long systemticks_t; typedef unsigned long gTicks;
typedef void * threadreturn_t; typedef void * gThreadreturn;
typedef unsigned long delaytime_t; typedef unsigned long gDelay;
typedef pthread_t gfxThreadHandle; typedef pthread_t gfxThreadHandle;
typedef int threadpriority_t; typedef int gThreadpriority;
typedef uint32_t semcount_t; typedef uint32_t gSemcount;
typedef pthread_mutex_t gfxMutex; typedef pthread_mutex_t gfxMutex;
#define DECLARE_THREAD_FUNCTION(fnName, param) threadreturn_t fnName(void *param) #define DECLARE_THREAD_FUNCTION(fnName, param) gThreadreturn fnName(void *param)
#define DECLARE_THREAD_STACK(name, sz) uint8_t name[0]; #define DECLARE_THREAD_STACK(name, sz) uint8_t name[0];
#define THREAD_RETURN(retval) return retval #define THREAD_RETURN(retval) return retval
@ -50,8 +50,8 @@ typedef pthread_mutex_t gfxMutex;
#define gfxSemSignalI(psem) gfxSemSignal(psem) #define gfxSemSignalI(psem) gfxSemSignal(psem)
#define TIME_IMMEDIATE 0 #define TIME_IMMEDIATE 0
#define TIME_INFINITE ((delaytime_t)-1) #define TIME_INFINITE ((gDelay)-1)
#define MAX_SEMAPHORE_COUNT ((semcount_t)-1) #define MAX_SEMAPHORE_COUNT ((gSemcount)-1)
#define LOW_PRIORITY 10 #define LOW_PRIORITY 10
#define NORMAL_PRIORITY 0 #define NORMAL_PRIORITY 0
#define HIGH_PRIORITY -10 #define HIGH_PRIORITY -10
@ -59,14 +59,14 @@ typedef pthread_mutex_t gfxMutex;
#if GFX_USE_POSIX_SEMAPHORES #if GFX_USE_POSIX_SEMAPHORES
typedef struct gfxSem { typedef struct gfxSem {
sem_t sem; sem_t sem;
semcount_t max; gSemcount max;
} gfxSem; } gfxSem;
#else #else
typedef struct gfxSem { typedef struct gfxSem {
pthread_mutex_t mtx; pthread_mutex_t mtx;
pthread_cond_t cond; pthread_cond_t cond;
semcount_t cnt; gSemcount cnt;
semcount_t max; gSemcount max;
} gfxSem; } gfxSem;
#endif #endif
@ -76,17 +76,17 @@ typedef pthread_mutex_t gfxMutex;
void gfxYield(void); void gfxYield(void);
void gfxHalt(const char *msg); void gfxHalt(const char *msg);
void gfxSleepMilliseconds(delaytime_t ms); void gfxSleepMilliseconds(gDelay ms);
void gfxSleepMicroseconds(delaytime_t ms); void gfxSleepMicroseconds(gDelay ms);
systemticks_t gfxSystemTicks(void); gTicks gfxSystemTicks(void);
void gfxSystemLock(void); void gfxSystemLock(void);
void gfxSystemUnlock(void); void gfxSystemUnlock(void);
void gfxSemInit(gfxSem *psem, semcount_t val, semcount_t limit); void gfxSemInit(gfxSem *psem, gSemcount val, gSemcount limit);
void gfxSemDestroy(gfxSem *psem); void gfxSemDestroy(gfxSem *psem);
gBool gfxSemWait(gfxSem *psem, delaytime_t ms); gBool gfxSemWait(gfxSem *psem, gDelay ms);
void gfxSemSignal(gfxSem *psem); void gfxSemSignal(gfxSem *psem);
gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param); gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param);
threadreturn_t gfxThreadWait(gfxThreadHandle thread); gThreadreturn gfxThreadWait(gfxThreadHandle thread);
#endif /* GFX_USE_OS_LINUX */ #endif /* GFX_USE_OS_LINUX */

4
src/gos/gos_nios.c
View File

@ -52,12 +52,12 @@ void gfxExit(void) {
} }
} }
systemticks_t gfxSystemTicks(void) gTicks gfxSystemTicks(void)
{ {
return alt_nticks(); return alt_nticks();
} }
systemticks_t gfxMillisecondsToTicks(delaytime_t ms) gTicks gfxMillisecondsToTicks(gDelay ms)
{ {
return ms; return ms;
} }

8
src/gos/gos_nios.h
View File

@ -12,13 +12,13 @@
#include <sys/alt_alarm.h> #include <sys/alt_alarm.h>
typedef alt_u32 systemticks_t; typedef alt_u32 gTicks;
typedef alt_u32 delaytime_t; typedef alt_u32 gDelay;
void gfxHalt(const char* msg); void gfxHalt(const char* msg);
void gfxExit(void); void gfxExit(void);
systemticks_t gfxSystemTicks(void); gTicks gfxSystemTicks(void);
systemticks_t gfxMillisecondsToTicks(delaytime_t ms); gTicks gfxMillisecondsToTicks(gDelay ms);
// Use the generic thread handling and heap handling // Use the generic thread handling and heap handling
#define GOS_NEED_X_THREADS GFXON #define GOS_NEED_X_THREADS GFXON

16
src/gos/gos_osx.c
View File

@ -53,7 +53,7 @@ void gfxHalt(const char *msg) {
exit(1); exit(1);
} }
void gfxSleepMilliseconds(delaytime_t ms) { void gfxSleepMilliseconds(gDelay ms) {
struct timespec ts; struct timespec ts;
switch(ms) { switch(ms) {
@ -67,7 +67,7 @@ void gfxSleepMilliseconds(delaytime_t ms) {
} }
} }
void gfxSleepMicroseconds(delaytime_t us) { void gfxSleepMicroseconds(gDelay us) {
struct timespec ts; struct timespec ts;
switch(us) { switch(us) {
@ -81,7 +81,7 @@ void gfxSleepMicroseconds(delaytime_t us) {
} }
} }
systemticks_t gfxSystemTicks(void) { gTicks gfxSystemTicks(void) {
mach_timespec_t ts; mach_timespec_t ts;
clock_serv_t cclock; clock_serv_t cclock;
@ -92,7 +92,7 @@ systemticks_t gfxSystemTicks(void) {
return ts.tv_sec * 1000UL + ts.tv_nsec / 1000000; return ts.tv_sec * 1000UL + ts.tv_nsec / 1000000;
} }
gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param) { gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param) {
gfxThreadHandle th; gfxThreadHandle th;
(void) stackarea; (void) stackarea;
(void) stacksz; (void) stacksz;
@ -110,15 +110,15 @@ gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_
return th; return th;
} }
threadreturn_t gfxThreadWait(gfxThreadHandle thread) { gThreadreturn gfxThreadWait(gfxThreadHandle thread) {
threadreturn_t retval; gThreadreturn retval;
if (pthread_join(thread, &retval)) if (pthread_join(thread, &retval))
return 0; return 0;
return retval; return retval;
} }
void gfxSemInit(gfxSem *pSem, semcount_t val, semcount_t limit) { void gfxSemInit(gfxSem *pSem, gSemcount val, gSemcount limit) {
pthread_mutex_init(&pSem->mtx, 0); pthread_mutex_init(&pSem->mtx, 0);
pthread_cond_init(&pSem->cond, 0); pthread_cond_init(&pSem->cond, 0);
pthread_mutex_lock(&pSem->mtx); pthread_mutex_lock(&pSem->mtx);
@ -132,7 +132,7 @@ void gfxSemDestroy(gfxSem *pSem) {
pthread_cond_destroy(&pSem->cond); pthread_cond_destroy(&pSem->cond);
} }
gBool gfxSemWait(gfxSem *pSem, delaytime_t ms) { gBool gfxSemWait(gfxSem *pSem, gDelay ms) {
pthread_mutex_lock(&pSem->mtx); pthread_mutex_lock(&pSem->mtx);
switch (ms) { switch (ms) {
case TIME_INFINITE: case TIME_INFINITE:

34
src/gos/gos_osx.h
View File

@ -14,15 +14,15 @@
#include <pthread.h> #include <pthread.h>
#include <stdlib.h> #include <stdlib.h>
typedef unsigned long systemticks_t; typedef unsigned long gTicks;
typedef void * threadreturn_t; typedef void * gThreadreturn;
typedef unsigned long delaytime_t; typedef unsigned long gDelay;
typedef pthread_t gfxThreadHandle; typedef pthread_t gfxThreadHandle;
typedef int threadpriority_t; typedef int gThreadpriority;
typedef uint32_t semcount_t; typedef uint32_t gSemcount;
typedef pthread_mutex_t gfxMutex; typedef pthread_mutex_t gfxMutex;
#define DECLARE_THREAD_FUNCTION(fnName, param) threadreturn_t fnName(void *param) #define DECLARE_THREAD_FUNCTION(fnName, param) gThreadreturn fnName(void *param)
#define DECLARE_THREAD_STACK(name, sz) uint8_t name[0]; #define DECLARE_THREAD_STACK(name, sz) uint8_t name[0];
#define THREAD_RETURN(retval) return retval #define THREAD_RETURN(retval) return retval
@ -42,8 +42,8 @@ typedef pthread_mutex_t gfxMutex;
#define gfxSemSignalI(psem) gfxSemSignal(psem) #define gfxSemSignalI(psem) gfxSemSignal(psem)
#define TIME_IMMEDIATE 0 #define TIME_IMMEDIATE 0
#define TIME_INFINITE ((delaytime_t)-1) #define TIME_INFINITE ((gDelay)-1)
#define MAX_SEMAPHORE_COUNT ((semcount_t)-1) #define MAX_SEMAPHORE_COUNT ((gSemcount)-1)
#define LOW_PRIORITY 10 #define LOW_PRIORITY 10
#define NORMAL_PRIORITY 0 #define NORMAL_PRIORITY 0
#define HIGH_PRIORITY -10 #define HIGH_PRIORITY -10
@ -51,8 +51,8 @@ typedef pthread_mutex_t gfxMutex;
typedef struct gfxSem { typedef struct gfxSem {
pthread_mutex_t mtx; pthread_mutex_t mtx;
pthread_cond_t cond; pthread_cond_t cond;
semcount_t cnt; gSemcount cnt;
semcount_t max; gSemcount max;
} gfxSem; } gfxSem;
/*===========================================================================*/ /*===========================================================================*/
@ -60,17 +60,17 @@ typedef struct gfxSem {
/*===========================================================================*/ /*===========================================================================*/
void gfxHalt(const char *msg); void gfxHalt(const char *msg);
void gfxSleepMilliseconds(delaytime_t ms); void gfxSleepMilliseconds(gDelay ms);
void gfxSleepMicroseconds(delaytime_t ms); void gfxSleepMicroseconds(gDelay ms);
systemticks_t gfxSystemTicks(void); gTicks gfxSystemTicks(void);
void gfxSystemLock(void); void gfxSystemLock(void);
void gfxSystemUnlock(void); void gfxSystemUnlock(void);
void gfxSemInit(gfxSem *psem, semcount_t val, semcount_t limit); void gfxSemInit(gfxSem *psem, gSemcount val, gSemcount limit);
void gfxSemDestroy(gfxSem *psem); void gfxSemDestroy(gfxSem *psem);
gBool gfxSemWait(gfxSem *psem, delaytime_t ms); gBool gfxSemWait(gfxSem *psem, gDelay ms);
void gfxSemSignal(gfxSem *psem); void gfxSemSignal(gfxSem *psem);
gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param); gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param);
threadreturn_t gfxThreadWait(gfxThreadHandle thread); gThreadreturn gfxThreadWait(gfxThreadHandle thread);
#endif /* GFX_USE_OS_OSX */ #endif /* GFX_USE_OS_OSX */
#endif /* _GOS_OSX_H */ #endif /* _GOS_OSX_H */

24
src/gos/gos_qt.cpp
View File

@ -18,7 +18,7 @@ extern "C" void _gosPostInit(void);
class Thread : public QThread class Thread : public QThread
{ {
public: public:
typedef threadreturn_t (*fptr)(void* param); typedef gThreadreturn (*fptr)(void* param);
void setFunction(fptr function, void* param) void setFunction(fptr function, void* param)
{ {
@ -26,7 +26,7 @@ public:
_param = param; _param = param;
} }
threadreturn_t returnValue() gThreadreturn returnValue()
{ {
return _returnValue; return _returnValue;
} }
@ -43,7 +43,7 @@ public:
private: private:
fptr _function; fptr _function;
void* _param; void* _param;
threadreturn_t _returnValue; gThreadreturn _returnValue;
}; };
static QElapsedTimer _systickTimer; static QElapsedTimer _systickTimer;
@ -103,22 +103,22 @@ void gfxYield(void)
QThread::msleep(0); QThread::msleep(0);
} }
void gfxSleepMilliseconds(delaytime_t ms) void gfxSleepMilliseconds(gDelay ms)
{ {
QThread::msleep(ms); QThread::msleep(ms);
} }
void gfxSleepMicroseconds(delaytime_t us) void gfxSleepMicroseconds(gDelay us)
{ {
QThread::usleep(us); QThread::usleep(us);
} }
systemticks_t gfxSystemTicks(void) gTicks gfxSystemTicks(void)
{ {
return _systickTimer.elapsed(); return _systickTimer.elapsed();
} }
systemticks_t gfxMillisecondsToTicks(delaytime_t ms) gTicks gfxMillisecondsToTicks(gDelay ms)
{ {
return ms; return ms;
} }
@ -153,7 +153,7 @@ void gfxMutexExit(gfxMutex *pmutex)
static_cast<QMutex*>(*pmutex)->unlock(); static_cast<QMutex*>(*pmutex)->unlock();
} }
void gfxSemInit(gfxSem *psem, semcount_t val, semcount_t limit) void gfxSemInit(gfxSem *psem, gSemcount val, gSemcount limit)
{ {
*psem = new QSemaphore(limit); *psem = new QSemaphore(limit);
@ -165,7 +165,7 @@ void gfxSemDestroy(gfxSem *psem)
delete static_cast<QSemaphore*>(*psem); delete static_cast<QSemaphore*>(*psem);
} }
gBool gfxSemWait(gfxSem *psem, delaytime_t ms) gBool gfxSemWait(gfxSem *psem, gDelay ms)
{ {
return static_cast<QSemaphore*>(*psem)->tryAcquire(1, ms); return static_cast<QSemaphore*>(*psem)->tryAcquire(1, ms);
} }
@ -185,7 +185,7 @@ void gfxSemSignalI(gfxSem *psem)
static_cast<QSemaphore*>(*psem)->release(1); static_cast<QSemaphore*>(*psem)->release(1);
} }
gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param) gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param)
{ {
Q_UNUSED(stackarea) Q_UNUSED(stackarea)
@ -199,11 +199,11 @@ gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_
return static_cast<gfxThreadHandle>(thread); return static_cast<gfxThreadHandle>(thread);
} }
threadreturn_t gfxThreadWait(gfxThreadHandle thread) gThreadreturn gfxThreadWait(gfxThreadHandle thread)
{ {
Thread* t = static_cast<Thread*>(thread); Thread* t = static_cast<Thread*>(thread);
threadreturn_t returnValue = t->returnValue(); gThreadreturn returnValue = t->returnValue();
t->wait(); t->wait();
t->exit(); t->exit();

32
src/gos/gos_qt.h
View File

@ -10,24 +10,24 @@
#if GFX_USE_OS_QT #if GFX_USE_OS_QT
#define DECLARE_THREAD_FUNCTION(fnName, param) threadreturn_t fnName(void *param) #define DECLARE_THREAD_FUNCTION(fnName, param) gThreadreturn fnName(void *param)
#define DECLARE_THREAD_STACK(name, sz) uint8_t name[0] #define DECLARE_THREAD_STACK(name, sz) uint8_t name[0]
#define THREAD_RETURN(retval) return retval #define THREAD_RETURN(retval) return retval
#define TIME_IMMEDIATE 0 #define TIME_IMMEDIATE 0
#define TIME_INFINITE ((delaytime_t)-1) #define TIME_INFINITE ((gDelay)-1)
#define MAX_SEMAPHORE_COUNT ((semcount_t)(((unsigned long)((semcount_t)(-1))) >> 1)) #define MAX_SEMAPHORE_COUNT ((gSemcount)(((unsigned long)((gSemcount)(-1))) >> 1))
#define LOW_PRIORITY 2 #define LOW_PRIORITY 2
#define NORMAL_PRIORITY 3 #define NORMAL_PRIORITY 3
#define HIGH_PRIORITY 4 #define HIGH_PRIORITY 4
typedef int systemticks_t; typedef int gTicks;
typedef int delaytime_t; typedef int gDelay;
typedef void* gfxMutex; typedef void* gfxMutex;
typedef void* gfxSem; typedef void* gfxSem;
typedef int semcount_t; typedef int gSemcount;
typedef int threadreturn_t; typedef int gThreadreturn;
typedef int threadpriority_t; typedef int gThreadpriority;
typedef void* gfxThreadHandle; typedef void* gfxThreadHandle;
void _gosInit(); void _gosInit();
@ -39,24 +39,24 @@ void* gfxAlloc(size_t sz);
void* gfxRealloc(void *ptr, size_t oldsz, size_t newsz); void* gfxRealloc(void *ptr, size_t oldsz, size_t newsz);
void gfxFree(void* ptr); void gfxFree(void* ptr);
void gfxYield(void); void gfxYield(void);
void gfxSleepMilliseconds(delaytime_t ms); void gfxSleepMilliseconds(gDelay ms);
void gfxSleepMicroseconds(delaytime_t us); void gfxSleepMicroseconds(gDelay us);
systemticks_t gfxSystemTicks(void); gTicks gfxSystemTicks(void);
systemticks_t gfxMillisecondsToTicks(delaytime_t ms); gTicks gfxMillisecondsToTicks(gDelay ms);
void gfxSystemLock(void); void gfxSystemLock(void);
void gfxSystemUnlock(void); void gfxSystemUnlock(void);
void gfxMutexInit(gfxMutex *pmutex); void gfxMutexInit(gfxMutex *pmutex);
void gfxMutexDestroy(gfxMutex *pmutex); void gfxMutexDestroy(gfxMutex *pmutex);
void gfxMutexEnter(gfxMutex *pmutex); void gfxMutexEnter(gfxMutex *pmutex);
void gfxMutexExit(gfxMutex *pmutex); void gfxMutexExit(gfxMutex *pmutex);
void gfxSemInit(gfxSem *psem, semcount_t val, semcount_t limit); void gfxSemInit(gfxSem *psem, gSemcount val, gSemcount limit);
void gfxSemDestroy(gfxSem *psem); void gfxSemDestroy(gfxSem *psem);
gBool gfxSemWait(gfxSem *psem, delaytime_t ms); gBool gfxSemWait(gfxSem *psem, gDelay ms);
gBool gfxSemWaitI(gfxSem *psem); gBool gfxSemWaitI(gfxSem *psem);
void gfxSemSignal(gfxSem *psem); void gfxSemSignal(gfxSem *psem);
void gfxSemSignalI(gfxSem *psem); void gfxSemSignalI(gfxSem *psem);
gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param); gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param);
threadreturn_t gfxThreadWait(gfxThreadHandle thread); gThreadreturn gfxThreadWait(gfxThreadHandle thread);
gfxThreadHandle gfxThreadMe(void); gfxThreadHandle gfxThreadMe(void);
void gfxThreadClose(gfxThreadHandle thread); void gfxThreadClose(gfxThreadHandle thread);

4
src/gos/gos_raw32.c
View File

@ -74,8 +74,8 @@ void _gosDeinit(void)
#endif #endif
#include <stdio.h> #include <stdio.h>
systemticks_t gfxSystemTicks(void) { return GetTickCount(); } gTicks gfxSystemTicks(void) { return GetTickCount(); }
systemticks_t gfxMillisecondsToTicks(delaytime_t ms) { return ms; } gTicks gfxMillisecondsToTicks(gDelay ms) { return ms; }
#endif #endif
/********************************************************* /*********************************************************

4
src/gos/gos_raw32.h
View File

@ -17,8 +17,8 @@
* malloc(), realloc and free() - if GOS_RAW_HEAP_SIZE == 0 * malloc(), realloc and free() - if GOS_RAW_HEAP_SIZE == 0
* *
* You must also define the following routines in your own code so that timing functions will work... * You must also define the following routines in your own code so that timing functions will work...
* systemticks_t gfxSystemTicks(void); * gTicks gfxSystemTicks(void);
* systemticks_t gfxMillisecondsToTicks(delaytime_t ms); * gTicks gfxMillisecondsToTicks(gDelay ms);
*/ */
#ifndef _GOS_RAW32_H #ifndef _GOS_RAW32_H
#define _GOS_RAW32_H #define _GOS_RAW32_H

14
src/gos/gos_rawrtos.c
View File

@ -45,23 +45,23 @@ void _gosDeinit(void)
} }
void gfxSleepMilliseconds(delaytime_t ms) void gfxSleepMilliseconds(gDelay ms)
{ {
systemticks_t ticks = ms*RAW_TICKS_PER_SECOND/1000; gTicks ticks = ms*RAW_TICKS_PER_SECOND/1000;
if(!ticks)ticks = 1; if(!ticks)ticks = 1;
raw_sleep(ticks); raw_sleep(ticks);
} }
void gfxSleepMicroseconds(delaytime_t us) void gfxSleepMicroseconds(gDelay us)
{ {
systemticks_t ticks = (us/1000)*RAW_TICKS_PER_SECOND/1000; gTicks ticks = (us/1000)*RAW_TICKS_PER_SECOND/1000;
if(!ticks)ticks = 1; if(!ticks)ticks = 1;
raw_sleep(ticks); raw_sleep(ticks);
} }
gBool gfxSemWait(gfxSem* psem, delaytime_t ms) gBool gfxSemWait(gfxSem* psem, gDelay ms)
{ {
systemticks_t ticks = ms*RAW_TICKS_PER_SECOND/1000; gTicks ticks = ms*RAW_TICKS_PER_SECOND/1000;
if(!ticks)ticks=1; if(!ticks)ticks=1;
if(raw_semaphore_get((psem), ticks)==RAW_SUCCESS) if(raw_semaphore_get((psem), ticks)==RAW_SUCCESS)
return gTrue; return gTrue;
@ -75,7 +75,7 @@ gBool gfxSemWaitI(gfxSem* psem)
return gFalse; return gFalse;
} }
gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param) gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param)
{ {
RAW_U16 ret; RAW_U16 ret;
gfxThreadHandle taskobj; gfxThreadHandle taskobj;

20
src/gos/gos_rawrtos.h
View File

@ -7,11 +7,11 @@
#define TIME_IMMEDIATE (RAW_NO_WAIT) #define TIME_IMMEDIATE (RAW_NO_WAIT)
#define TIME_INFINITE (RAW_WAIT_FOREVER) #define TIME_INFINITE (RAW_WAIT_FOREVER)
typedef uint32_t delaytime_t; typedef uint32_t gDelay;
typedef RAW_TICK_TYPE systemticks_t; typedef RAW_TICK_TYPE gTicks;
typedef int32_t semcount_t; typedef int32_t gSemcount;
typedef uint32_t threadreturn_t; typedef uint32_t gThreadreturn;
typedef RAW_U8 threadpriority_t; typedef RAW_U8 gThreadpriority;
#define MAX_SEMAPHORE_COUNT RAW_SEMAPHORE_COUNT #define MAX_SEMAPHORE_COUNT RAW_SEMAPHORE_COUNT
#define LOW_PRIORITY (CONFIG_RAW_PRIO_MAX-2) #define LOW_PRIORITY (CONFIG_RAW_PRIO_MAX-2)
@ -22,7 +22,7 @@ typedef RAW_SEMAPHORE gfxSem;
typedef RAW_MUTEX gfxMutex; typedef RAW_MUTEX gfxMutex;
typedef RAW_TASK_OBJ* gfxThreadHandle; typedef RAW_TASK_OBJ* gfxThreadHandle;
#define DECLARE_THREAD_FUNCTION(fnName, param) threadreturn_t fnName(void *param) #define DECLARE_THREAD_FUNCTION(fnName, param) gThreadreturn fnName(void *param)
#define DECLARE_THREAD_STACK(name, sz) PORT_STACK name[(sz) & ~3]; #define DECLARE_THREAD_STACK(name, sz) PORT_STACK name[(sz) & ~3];
#define THREAD_RETURN(retval) return retval #define THREAD_RETURN(retval) return retval
@ -63,11 +63,11 @@ extern RAW_U16 raw_semaphore_delete(RAW_SEMAPHORE *semaphore_ptr);
extern RAW_U16 raw_semaphore_get(RAW_SEMAPHORE *semaphore_ptr, RAW_TICK_TYPE wait_option); extern RAW_U16 raw_semaphore_get(RAW_SEMAPHORE *semaphore_ptr, RAW_TICK_TYPE wait_option);
extern RAW_U16 raw_semaphore_put(RAW_SEMAPHORE *semaphore_ptr); extern RAW_U16 raw_semaphore_put(RAW_SEMAPHORE *semaphore_ptr);
void gfxSleepMilliseconds(delaytime_t ms); void gfxSleepMilliseconds(gDelay ms);
void gfxSleepMicroseconds(delaytime_t us); void gfxSleepMicroseconds(gDelay us);
gBool gfxSemWait(gfxSem* psem, delaytime_t ms); gBool gfxSemWait(gfxSem* psem, gDelay ms);
gBool gfxSemWaitI(gfxSem* psem); gBool gfxSemWaitI(gfxSem* psem);
gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param); gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param);
#endif #endif

10
src/gos/gos_win32.c
View File

@ -37,7 +37,7 @@ void gfxHalt(const char *msg) {
ExitProcess(1); ExitProcess(1);
} }
void gfxSleepMicroseconds(delaytime_t ms) { void gfxSleepMicroseconds(gDelay ms) {
static LARGE_INTEGER pcfreq; static LARGE_INTEGER pcfreq;
static int initflag; static int initflag;
LARGE_INTEGER t1, t2, tdiff; LARGE_INTEGER t1, t2, tdiff;
@ -74,7 +74,7 @@ void gfxSystemUnlock(void) {
ReleaseMutex(SystemMutex); ReleaseMutex(SystemMutex);
} }
gBool gfxSemWait(gfxSem *psem, delaytime_t ms) { gBool gfxSemWait(gfxSem *psem, gDelay ms) {
return WaitForSingleObject(*psem, ms) == WAIT_OBJECT_0; return WaitForSingleObject(*psem, ms) == WAIT_OBJECT_0;
} }
@ -87,7 +87,7 @@ typedef LONG (__stdcall *_NtQuerySemaphore)(
); );
/* - Left here simply because of its undocumented cleverness... /* - Left here simply because of its undocumented cleverness...
semcount_t gfxSemCounter(gfxSem *pSem) { gSemcount gfxSemCounter(gfxSem *pSem) {
static _NtQuerySemaphore NtQuerySemaphore; static _NtQuerySemaphore NtQuerySemaphore;
struct _SEMAPHORE_BASIC_INFORMATION { struct _SEMAPHORE_BASIC_INFORMATION {
ULONG CurrentCount; ULONG CurrentCount;
@ -103,7 +103,7 @@ semcount_t gfxSemCounter(gfxSem *pSem) {
} }
*/ */
gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION(*fn,p), void *param) { gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION(*fn,p), void *param) {
(void) stackarea; (void) stackarea;
HANDLE thd; HANDLE thd;
@ -116,7 +116,7 @@ gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_
return thd; return thd;
} }
threadreturn_t gfxThreadWait(gfxThreadHandle thread) { gThreadreturn gfxThreadWait(gfxThreadHandle thread) {
DWORD ret; DWORD ret;
WaitForSingleObject(thread, INFINITE); WaitForSingleObject(thread, INFINITE);

22
src/gos/gos_win32.h
View File

@ -25,19 +25,19 @@
#include <malloc.h> #include <malloc.h>
typedef DWORD delaytime_t; typedef DWORD gDelay;
typedef DWORD systemticks_t; typedef DWORD gTicks;
typedef LONG semcount_t; typedef LONG gSemcount;
typedef DWORD threadreturn_t; typedef DWORD gThreadreturn;
typedef int threadpriority_t; typedef int gThreadpriority;
#define DECLARE_THREAD_FUNCTION(fnName, param) threadreturn_t (WINAPI fnName)(void *param) #define DECLARE_THREAD_FUNCTION(fnName, param) gThreadreturn (WINAPI fnName)(void *param)
#define DECLARE_THREAD_STACK(name, sz) uint8_t name[1]; #define DECLARE_THREAD_STACK(name, sz) uint8_t name[1];
#define THREAD_RETURN(retval) return retval #define THREAD_RETURN(retval) return retval
#define TIME_IMMEDIATE 0 #define TIME_IMMEDIATE 0
#define TIME_INFINITE INFINITE #define TIME_INFINITE INFINITE
#define MAX_SEMAPHORE_COUNT ((semcount_t)(((unsigned long)((semcount_t)(-1))) >> 1)) #define MAX_SEMAPHORE_COUNT ((gSemcount)(((unsigned long)((gSemcount)(-1))) >> 1))
#define LOW_PRIORITY THREAD_PRIORITY_BELOW_NORMAL #define LOW_PRIORITY THREAD_PRIORITY_BELOW_NORMAL
#define NORMAL_PRIORITY THREAD_PRIORITY_NORMAL #define NORMAL_PRIORITY THREAD_PRIORITY_NORMAL
#define HIGH_PRIORITY THREAD_PRIORITY_ABOVE_NORMAL #define HIGH_PRIORITY THREAD_PRIORITY_ABOVE_NORMAL
@ -71,12 +71,12 @@ typedef HANDLE gfxThreadHandle;
/*===========================================================================*/ /*===========================================================================*/
void gfxHalt(const char *msg); void gfxHalt(const char *msg);
void gfxSleepMicroseconds(delaytime_t ms); void gfxSleepMicroseconds(gDelay ms);
gBool gfxSemWait(gfxSem *psem, delaytime_t ms); gBool gfxSemWait(gfxSem *psem, gDelay ms);
void gfxSystemLock(void); void gfxSystemLock(void);
void gfxSystemUnlock(void); void gfxSystemUnlock(void);
gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION(*fn,p), void *param); gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION(*fn,p), void *param);
threadreturn_t gfxThreadWait(gfxThreadHandle thread); gThreadreturn gfxThreadWait(gfxThreadHandle thread);
#endif /* GFX_USE_OS_WIN32 */ #endif /* GFX_USE_OS_WIN32 */
#endif /* _GOS_WIN32_H */ #endif /* _GOS_WIN32_H */

24
src/gos/gos_x_threads.c
View File

@ -45,13 +45,13 @@ void gfxMutexExit(gfxMutex *pmutex) {
pmutex[0] = 0; pmutex[0] = 0;
} }
void gfxSemInit(gfxSem *psem, semcount_t val, semcount_t limit) { void gfxSemInit(gfxSem *psem, gSemcount val, gSemcount limit) {
psem->cnt = val; psem->cnt = val;
psem->limit = limit; psem->limit = limit;
} }
gBool gfxSemWait(gfxSem *psem, delaytime_t ms) { gBool gfxSemWait(gfxSem *psem, gDelay ms) {
systemticks_t starttm, delay; gTicks starttm, delay;
// Convert our delay to ticks // Convert our delay to ticks
starttm = 0; starttm = 0;
@ -112,8 +112,8 @@ void gfxSemSignalI(gfxSem *psem) {
* Sleep functions * Sleep functions
*********************************************************/ *********************************************************/
void gfxSleepMilliseconds(delaytime_t ms) { void gfxSleepMilliseconds(gDelay ms) {
systemticks_t starttm, delay; gTicks starttm, delay;
// Safety first // Safety first
switch (ms) { switch (ms) {
@ -134,8 +134,8 @@ void gfxSleepMilliseconds(delaytime_t ms) {
} while (gfxSystemTicks() - starttm < delay); } while (gfxSystemTicks() - starttm < delay);
} }
void gfxSleepMicroseconds(delaytime_t ms) { void gfxSleepMicroseconds(gDelay ms) {
systemticks_t starttm, delay; gTicks starttm, delay;
// Safety first // Safety first
switch (ms) { switch (ms) {
@ -176,7 +176,7 @@ typedef struct thread {
#define FLG_THD_DEAD 0x0004 #define FLG_THD_DEAD 0x0004
#define FLG_THD_WAIT 0x0008 #define FLG_THD_WAIT 0x0008
size_t size; // Size of the thread stack (including this structure) size_t size; // Size of the thread stack (including this structure)
threadreturn_t (*fn)(void *param); // Thread function gThreadreturn (*fn)(void *param); // Thread function
void * param; // Parameter for the thread function void * param; // Parameter for the thread function
void * cxt; // The current thread context. void * cxt; // The current thread context.
} thread; } thread;
@ -485,7 +485,7 @@ void gfxYield(void) {
} }
// This routine is not currently public - but it could be. // This routine is not currently public - but it could be.
void gfxThreadExit(threadreturn_t ret) { void gfxThreadExit(gThreadreturn ret) {
thread *me; thread *me;
// Save the results in case someone is waiting // Save the results in case someone is waiting
@ -508,7 +508,7 @@ void gfxThreadExit(threadreturn_t ret) {
// We never get back here as we didn't re-queue ourselves // We never get back here as we didn't re-queue ourselves
} }
gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param) { gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param) {
thread * t; thread * t;
thread * me; thread * me;
(void) prio; (void) prio;
@ -543,7 +543,7 @@ gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_
return t; return t;
} }
threadreturn_t gfxThreadWait(gfxThreadHandle th) { gThreadreturn gfxThreadWait(gfxThreadHandle th) {
thread * t; thread * t;
t = th; t = th;
@ -565,7 +565,7 @@ threadreturn_t gfxThreadWait(gfxThreadHandle th) {
gfxFree(t); gfxFree(t);
// Return the status left by the dead process // Return the status left by the dead process
return (threadreturn_t)t->param; return (gThreadreturn)t->param;
} }
#endif /* GFX_USE_OS_RAW32 */ #endif /* GFX_USE_OS_RAW32 */

40
src/gos/gos_x_threads.h
View File

@ -16,46 +16,46 @@
* memcpy() - for heap and threading * memcpy() - for heap and threading
* *
* You must also define the following routines in your own code so that timing functions will work... * You must also define the following routines in your own code so that timing functions will work...
* systemticks_t gfxSystemTicks(void); * gTicks gfxSystemTicks(void);
* systemticks_t gfxMillisecondsToTicks(delaytime_t ms); * gTicks gfxMillisecondsToTicks(gDelay ms);
*/ */
#ifndef _GOS_X_THREADS_H #ifndef _GOS_X_THREADS_H
#define _GOS_X_THREADS_H #define _GOS_X_THREADS_H
#if GOS_NEED_X_THREADS #if GOS_NEED_X_THREADS
typedef uint32_t delaytime_t; typedef uint32_t gDelay;
typedef uint32_t systemticks_t; typedef uint32_t gTicks;
typedef short semcount_t; typedef short gSemcount;
typedef int threadreturn_t; typedef int gThreadreturn;
typedef int threadpriority_t; typedef int gThreadpriority;
#define DECLARE_THREAD_FUNCTION(fnName, param) threadreturn_t fnName(void *param) #define DECLARE_THREAD_FUNCTION(fnName, param) gThreadreturn fnName(void *param)
#define DECLARE_THREAD_STACK(name, sz) uint8_t name[(sz) & ~3]; #define DECLARE_THREAD_STACK(name, sz) uint8_t name[(sz) & ~3];
#define THREAD_RETURN(retval) return retval #define THREAD_RETURN(retval) return retval
#define TIME_IMMEDIATE 0 #define TIME_IMMEDIATE 0
#define TIME_INFINITE ((delaytime_t)-1) #define TIME_INFINITE ((gDelay)-1)
#define MAX_SEMAPHORE_COUNT 0x7FFF #define MAX_SEMAPHORE_COUNT 0x7FFF
#define LOW_PRIORITY 0 #define LOW_PRIORITY 0
#define NORMAL_PRIORITY 1 #define NORMAL_PRIORITY 1
#define HIGH_PRIORITY 2 #define HIGH_PRIORITY 2
typedef struct { typedef struct {
semcount_t cnt; gSemcount cnt;
semcount_t limit; gSemcount limit;
} gfxSem; } gfxSem;
typedef uint32_t gfxMutex; typedef uint32_t gfxMutex;
typedef void * gfxThreadHandle; typedef void * gfxThreadHandle;
// Required timing functions - supplied by the user or the operating system // Required timing functions - supplied by the user or the operating system
systemticks_t gfxSystemTicks(void); gTicks gfxSystemTicks(void);
systemticks_t gfxMillisecondsToTicks(delaytime_t ms); gTicks gfxMillisecondsToTicks(gDelay ms);
// Sleep Functions // Sleep Functions
void gfxSleepMilliseconds(delaytime_t ms); void gfxSleepMilliseconds(gDelay ms);
void gfxSleepMicroseconds(delaytime_t ms); void gfxSleepMicroseconds(gDelay ms);
void gfxYield(void); void gfxYield(void);
// System Locking // System Locking
@ -69,24 +69,24 @@ void gfxMutexEnter(gfxMutex *pmutex);
void gfxMutexExit(gfxMutex *pmutex); void gfxMutexExit(gfxMutex *pmutex);
// Semaphores // Semaphores
void gfxSemInit(gfxSem *psem, semcount_t val, semcount_t limit); void gfxSemInit(gfxSem *psem, gSemcount val, gSemcount limit);
#define gfxSemDestroy(psem) #define gfxSemDestroy(psem)
gBool gfxSemWait(gfxSem *psem, delaytime_t ms); gBool gfxSemWait(gfxSem *psem, gDelay ms);
gBool gfxSemWaitI(gfxSem *psem); gBool gfxSemWaitI(gfxSem *psem);
void gfxSemSignal(gfxSem *psem); void gfxSemSignal(gfxSem *psem);
void gfxSemSignalI(gfxSem *psem); void gfxSemSignalI(gfxSem *psem);
// Threads // Threads
gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, threadpriority_t prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param); gfxThreadHandle gfxThreadCreate(void *stackarea, size_t stacksz, gThreadpriority prio, DECLARE_THREAD_FUNCTION((*fn),p), void *param);
#define gfxThreadClose(thread) #define gfxThreadClose(thread)
threadreturn_t gfxThreadWait(gfxThreadHandle thread); gThreadreturn gfxThreadWait(gfxThreadHandle thread);
gfxThreadHandle gfxThreadMe(void); gfxThreadHandle gfxThreadMe(void);
/** The following is not part of the public ugfx API as some operating systems /** The following is not part of the public ugfx API as some operating systems
* simply do not provide this capability. * simply do not provide this capability.
* For RAW32 we need it anyway so we might as well declare it here. * For RAW32 we need it anyway so we might as well declare it here.
*/ */
void gfxThreadExit(threadreturn_t ret); void gfxThreadExit(gThreadreturn ret);
#endif /* GOS_NEED_X_THREADS */ #endif /* GOS_NEED_X_THREADS */
#endif /* _GOS_X_THREADS_H */ #endif /* _GOS_X_THREADS_H */

2
src/gos/gos_zephyr.c
View File

@ -9,7 +9,7 @@
#if GFX_USE_OS_ZEPHYR #if GFX_USE_OS_ZEPHYR
systemticks_t gfxSystemTicks(void) gTicks gfxSystemTicks(void)
{ {
s32_t ms = k_uptime_get_32(); s32_t ms = k_uptime_get_32();
return CONFIG_SYS_CLOCK_TICKS_PER_SEC*ms/1000; return CONFIG_SYS_CLOCK_TICKS_PER_SEC*ms/1000;

16
src/gos/gos_zephyr.h
View File

@ -16,14 +16,14 @@
/* Type definitions */ /* Type definitions */
/*===========================================================================*/ /*===========================================================================*/
typedef s32_t delaytime_t; typedef s32_t gDelay;
typedef u32_t systemticks_t; typedef u32_t gTicks;
typedef u32_t semcount_t; typedef u32_t gSemcount;
typedef void threadreturn_t; typedef void gThreadreturn;
typedef int threadpriority_t; typedef int gThreadpriority;
#define DECLARE_THREAD_FUNCTION(fnName, param)\ #define DECLARE_THREAD_FUNCTION(fnName, param)\
threadreturn_t fnName(void* param, void* p2, void* p3) gThreadreturn fnName(void* param, void* p2, void* p3)
#define DECLARE_THREAD_STACK(name, sz)\ #define DECLARE_THREAD_STACK(name, sz)\
K_THREAD_STACK_DEFINE(name, sz) K_THREAD_STACK_DEFINE(name, sz)
@ -32,7 +32,7 @@ typedef int threadpriority_t;
#define TIME_IMMEDIATE K_NO_WAIT #define TIME_IMMEDIATE K_NO_WAIT
#define TIME_INFINITE K_FOREVER #define TIME_INFINITE K_FOREVER
#define MAX_SEMAPHORE_COUNT ((semcount_t)(((unsigned long)((semcount_t)(-1))) >> 1)) #define MAX_SEMAPHORE_COUNT ((gSemcount)(((unsigned long)((gSemcount)(-1))) >> 1))
#define LOW_PRIORITY CONFIG_NUM_PREEMPT_PRIORITIES-1 #define LOW_PRIORITY CONFIG_NUM_PREEMPT_PRIORITIES-1
#define NORMAL_PRIORITY 1 #define NORMAL_PRIORITY 1
#define HIGH_PRIORITY 0 #define HIGH_PRIORITY 0
@ -59,7 +59,7 @@ typedef k_tid_t gfxThreadHandle;
#define gfxSleepMilliseconds(ms) k_sleep(ms) #define gfxSleepMilliseconds(ms) k_sleep(ms)
#define gfxSleepMicroseconds(us) do{}while(0) #define gfxSleepMicroseconds(us) do{}while(0)
#define gfxMillisecondsToTicks(ms) CONFIG_SYS_CLOCK_TICKS_PER_SEC*ms/1000 #define gfxMillisecondsToTicks(ms) CONFIG_SYS_CLOCK_TICKS_PER_SEC*ms/1000
systemticks_t gfxSystemTicks(); gTicks gfxSystemTicks();
#define gfxSystemLock() k_sched_lock() #define gfxSystemLock() k_sched_lock()
#define gfxSystemUnlock() k_sched_unlock() #define gfxSystemUnlock() k_sched_unlock()

12
src/gqueue/gqueue.c
View File

@ -163,7 +163,7 @@ void _gqueueDeinit(void)
gfxSemDestroy(&pqueue->sem); gfxSemDestroy(&pqueue->sem);
} }
gfxQueueGSyncItem *gfxQueueGSyncGet(gfxQueueGSync *pqueue, delaytime_t ms) { gfxQueueGSyncItem *gfxQueueGSyncGet(gfxQueueGSync *pqueue, gDelay ms) {
gfxQueueGSyncItem *pi; gfxQueueGSyncItem *pi;
if (!gfxSemWait(&pqueue->sem, ms)) if (!gfxSemWait(&pqueue->sem, ms))
@ -302,7 +302,7 @@ void _gqueueDeinit(void)
gfxSemDestroy(&pqueue->sem); gfxSemDestroy(&pqueue->sem);
} }
gfxQueueFSyncItem *gfxQueueFSyncGet(gfxQueueFSync *pqueue, delaytime_t ms) { gfxQueueFSyncItem *gfxQueueFSyncGet(gfxQueueFSync *pqueue, gDelay ms) {
gfxQueueFSyncItem *pi; gfxQueueFSyncItem *pi;
if (!gfxSemWait(&pqueue->sem, ms)) if (!gfxSemWait(&pqueue->sem, ms))
@ -320,7 +320,7 @@ void _gqueueDeinit(void)
return pi; return pi;
} }
gBool gfxQueueFSyncPut(gfxQueueFSync *pqueue, gfxQueueFSyncItem *pitem, delaytime_t ms) { gBool gfxQueueFSyncPut(gfxQueueFSync *pqueue, gfxQueueFSyncItem *pitem, gDelay ms) {
if (!pitem) return; // Safety if (!pitem) return; // Safety
gfxSemInit(&pitem->sem, 0, 1); gfxSemInit(&pitem->sem, 0, 1);
pitem->next = 0; pitem->next = 0;
@ -339,7 +339,7 @@ void _gqueueDeinit(void)
return gfxSemWait(&pitem->sem, ms); return gfxSemWait(&pitem->sem, ms);
} }
gBool gfxQueueFSyncPush(gfxQueueFSync *pqueue, gfxQueueFSyncItem *pitem, delaytime_t ms) { gBool gfxQueueFSyncPush(gfxQueueFSync *pqueue, gfxQueueFSyncItem *pitem, gDelay ms) {
if (!pitem) return; // Safety if (!pitem) return; // Safety
gfxSemInit(&pitem->sem, 0, 1); gfxSemInit(&pitem->sem, 0, 1);
@ -355,7 +355,7 @@ void _gqueueDeinit(void)
return gfxSemWait(&pitem->sem, ms); return gfxSemWait(&pitem->sem, ms);
} }
gBool gfxQueueFSyncInsert(gfxQueueFSync *pqueue, gfxQueueFSyncItem *pitem, gfxQueueASyncItem *pafter, delaytime_t ms) { gBool gfxQueueFSyncInsert(gfxQueueFSync *pqueue, gfxQueueFSyncItem *pitem, gfxQueueASyncItem *pafter, gDelay ms) {
if (!pitem) return; // Safety if (!pitem) return; // Safety
gfxSemInit(&pitem->sem, 0, 1); gfxSemInit(&pitem->sem, 0, 1);
@ -454,7 +454,7 @@ void _gqueueDeinit(void)
void gfxBufferRelease(GDataBuffer *pd) { gfxQueueGSyncPut(&bufferFreeList, (gfxQueueGSyncItem *)pd); } void gfxBufferRelease(GDataBuffer *pd) { gfxQueueGSyncPut(&bufferFreeList, (gfxQueueGSyncItem *)pd); }
void gfxBufferReleaseI(GDataBuffer *pd) { gfxQueueGSyncPutI(&bufferFreeList, (gfxQueueGSyncItem *)pd); } void gfxBufferReleaseI(GDataBuffer *pd) { gfxQueueGSyncPutI(&bufferFreeList, (gfxQueueGSyncItem *)pd); }
GDataBuffer *gfxBufferGet(delaytime_t ms) { return (GDataBuffer *)gfxQueueGSyncGet(&bufferFreeList, ms); } GDataBuffer *gfxBufferGet(gDelay ms) { return (GDataBuffer *)gfxQueueGSyncGet(&bufferFreeList, ms); }
GDataBuffer *gfxBufferGetI(void) { return (GDataBuffer *)gfxQueueGSyncGetI(&bufferFreeList); } GDataBuffer *gfxBufferGetI(void) { return (GDataBuffer *)gfxQueueGSyncGetI(&bufferFreeList); }
gBool gfxBufferIsAvailable(void) { return bufferFreeList.head != 0; } gBool gfxBufferIsAvailable(void) { return bufferFreeList.head != 0; }

12
src/gqueue/gqueue.h
View File

@ -133,9 +133,9 @@ void gfxQueueFSyncDeinit(gfxQueueFSync *pqueue);
*/ */
gfxQueueASyncItem *gfxQueueASyncGet(gfxQueueASync *pqueue); gfxQueueASyncItem *gfxQueueASyncGet(gfxQueueASync *pqueue);
gfxQueueASyncItem *gfxQueueASyncGetI(gfxQueueASync *pqueue); gfxQueueASyncItem *gfxQueueASyncGetI(gfxQueueASync *pqueue);
gfxQueueGSyncItem *gfxQueueGSyncGet(gfxQueueGSync *pqueue, delaytime_t ms); gfxQueueGSyncItem *gfxQueueGSyncGet(gfxQueueGSync *pqueue, gDelay ms);
gfxQueueGSyncItem *gfxQueueGSyncGetI(gfxQueueGSync *pqueue); gfxQueueGSyncItem *gfxQueueGSyncGetI(gfxQueueGSync *pqueue);
gfxQueueFSyncItem *gfxQueueFSyncGet(gfxQueueFSync *pqueue, delaytime_t ms); gfxQueueFSyncItem *gfxQueueFSyncGet(gfxQueueFSync *pqueue, gDelay ms);
/** @} */ /** @} */
/** /**
@ -159,7 +159,7 @@ void gfxQueueASyncPut(gfxQueueASync *pqueue, gfxQueueASyncItem *pitem);
void gfxQueueASyncPutI(gfxQueueASync *pqueue, gfxQueueASyncItem *pitem); void gfxQueueASyncPutI(gfxQueueASync *pqueue, gfxQueueASyncItem *pitem);
void gfxQueueGSyncPut(gfxQueueGSync *pqueue, gfxQueueGSyncItem *pitem); void gfxQueueGSyncPut(gfxQueueGSync *pqueue, gfxQueueGSyncItem *pitem);
void gfxQueueGSyncPutI(gfxQueueGSync *pqueue, gfxQueueGSyncItem *pitem); void gfxQueueGSyncPutI(gfxQueueGSync *pqueue, gfxQueueGSyncItem *pitem);
gBool gfxQueueFSyncPut(gfxQueueFSync *pqueue, gfxQueueFSyncItem *pitem, delaytime_t ms); gBool gfxQueueFSyncPut(gfxQueueFSync *pqueue, gfxQueueFSyncItem *pitem, gDelay ms);
/** @} */ /** @} */
/** /**
@ -197,7 +197,7 @@ void gfxQueueASyncPush(gfxQueueASync *pqueue, gfxQueueASyncItem *pitem);
void gfxQueueASyncPushI(gfxQueueASync *pqueue, gfxQueueASyncItem *pitem); void gfxQueueASyncPushI(gfxQueueASync *pqueue, gfxQueueASyncItem *pitem);
void gfxQueueGSyncPush(gfxQueueGSync *pqueue, gfxQueueGSyncItem *pitem); void gfxQueueGSyncPush(gfxQueueGSync *pqueue, gfxQueueGSyncItem *pitem);
void gfxQueueGSyncPushI(gfxQueueGSync *pqueue, gfxQueueGSyncItem *pitem); void gfxQueueGSyncPushI(gfxQueueGSync *pqueue, gfxQueueGSyncItem *pitem);
gBool gfxQueueFSyncPush(gfxQueueFSync *pqueue, gfxQueueFSyncItem *pitem, delaytime_t ms); gBool gfxQueueFSyncPush(gfxQueueFSync *pqueue, gfxQueueFSyncItem *pitem, gDelay ms);
/** @} */ /** @} */
/** /**
@ -223,7 +223,7 @@ void gfxQueueASyncInsert(gfxQueueASync *pqueue, gfxQueueASyncItem *pitem, gfxQue
void gfxQueueASyncInsertI(gfxQueueASync *pqueue, gfxQueueASyncItem *pitem, gfxQueueASyncItem *pafter); void gfxQueueASyncInsertI(gfxQueueASync *pqueue, gfxQueueASyncItem *pitem, gfxQueueASyncItem *pafter);
void gfxQueueGSyncInsert(gfxQueueGSync *pqueue, gfxQueueGSyncItem *pitem, gfxQueueASyncItem *pafter); void gfxQueueGSyncInsert(gfxQueueGSync *pqueue, gfxQueueGSyncItem *pitem, gfxQueueASyncItem *pafter);
void gfxQueueGSyncInsertI(gfxQueueGSync *pqueue, gfxQueueGSyncItem *pitem, gfxQueueASyncItem *pafter); void gfxQueueGSyncInsertI(gfxQueueGSync *pqueue, gfxQueueGSyncItem *pitem, gfxQueueASyncItem *pafter);
gBool gfxQueueFSyncInsert(gfxQueueFSync *pqueue, gfxQueueFSyncItem *pitem, gfxQueueASyncItem *pafter, delaytime_t ms); gBool gfxQueueFSyncInsert(gfxQueueFSync *pqueue, gfxQueueFSyncItem *pitem, gfxQueueASyncItem *pafter, gDelay ms);
/** @} */ /** @} */
/** /**
@ -376,7 +376,7 @@ gBool gfxBufferIsAvailable(void);
* @api * @api
* @{ * @{
*/ */
GDataBuffer *gfxBufferGet(delaytime_t ms); GDataBuffer *gfxBufferGet(gDelay ms);
GDataBuffer *gfxBufferGetI(void); GDataBuffer *gfxBufferGetI(void);
/** @} */ /** @} */

10
src/gtimer/gtimer.c
View File

@ -22,7 +22,7 @@ static gfxMutex mutex;
static gfxThreadHandle hThread = 0; static gfxThreadHandle hThread = 0;
static GTimer *pTimerHead = 0; static GTimer *pTimerHead = 0;
static gfxSem waitsem; static gfxSem waitsem;
static systemticks_t ticks2ms; static gTicks ticks2ms;
static DECLARE_THREAD_STACK(waTimerThread, GTIMER_THREAD_WORKAREA_SIZE); static DECLARE_THREAD_STACK(waTimerThread, GTIMER_THREAD_WORKAREA_SIZE);
/*===========================================================================*/ /*===========================================================================*/
@ -31,9 +31,9 @@ static DECLARE_THREAD_STACK(waTimerThread, GTIMER_THREAD_WORKAREA_SIZE);
static DECLARE_THREAD_FUNCTION(GTimerThreadHandler, arg) { static DECLARE_THREAD_FUNCTION(GTimerThreadHandler, arg) {
GTimer *pt; GTimer *pt;
systemticks_t tm; gTicks tm;
systemticks_t nxtTimeout; gTicks nxtTimeout;
systemticks_t lastTime; gTicks lastTime;
GTimerFunction fn; GTimerFunction fn;
void *param; void *param;
(void) arg; (void) arg;
@ -136,7 +136,7 @@ void gtimerDeinit(GTimer* pt)
gtimerStop(pt); gtimerStop(pt);
} }
void gtimerStart(GTimer *pt, GTimerFunction fn, void *param, gBool periodic, delaytime_t millisec) { void gtimerStart(GTimer *pt, GTimerFunction fn, void *param, gBool periodic, gDelay millisec) {
gfxMutexEnter(&mutex); gfxMutexEnter(&mutex);
// Start our thread if not already going // Start our thread if not already going

6
src/gtimer/gtimer.h
View File

@ -52,8 +52,8 @@ typedef void (*GTimerFunction)(void *param);
typedef struct GTimer_t { typedef struct GTimer_t {
GTimerFunction fn; GTimerFunction fn;
void *param; void *param;
systemticks_t when; gTicks when;
systemticks_t period; gTicks period;
uint16_t flags; uint16_t flags;
struct GTimer_t *next; struct GTimer_t *next;
struct GTimer_t *prev; struct GTimer_t *prev;
@ -110,7 +110,7 @@ void gtimerDeinit(GTimer* pt);
* *
* @api * @api
*/ */
void gtimerStart(GTimer *pt, GTimerFunction fn, void *param, gBool periodic, delaytime_t millisec); void gtimerStart(GTimer *pt, GTimerFunction fn, void *param, gBool periodic, gDelay millisec);
/** /**
* @brief Stop a timer (periodic or otherwise) * @brief Stop a timer (periodic or otherwise)

2
src/gwin/gwin_image.c
View File

@ -37,7 +37,7 @@ static void ImageRedraw(GHandle gh) {
gCoord x, y, w, h, dx, dy; gCoord x, y, w, h, dx, dy;
gColor bg; gColor bg;
#if GWIN_NEED_IMAGE_ANIMATION #if GWIN_NEED_IMAGE_ANIMATION
delaytime_t delay; gDelay delay;
#endif #endif
// The default display area // The default display area

2
src/gwin/gwin_progressbar.c
View File

@ -195,7 +195,7 @@ void gwinProgressbarDecrement(GHandle gh) {
#undef gsw #undef gsw
} }
void gwinProgressbarStart(GHandle gh, delaytime_t delay) { void gwinProgressbarStart(GHandle gh, gDelay delay) {
#define gsw ((GProgressbarObject *)gh) #define gsw ((GProgressbarObject *)gh)
if (gh->vmt != (gwinVMT *)&progressbarVMT) if (gh->vmt != (gwinVMT *)&progressbarVMT)

2
src/gwin/gwin_progressbar.h
View File

@ -159,7 +159,7 @@ void gwinProgressbarDecrement(GHandle gh);
* *
* @api * @api
*/ */
void gwinProgressbarStart(GHandle gh, delaytime_t delay); void gwinProgressbarStart(GHandle gh, gDelay delay);
/** /**
* @brief Stop the timer which is started by @p gwinProgressbarStart() * @brief Stop the timer which is started by @p gwinProgressbarStart()