sergiotarxz/nuttx-apps
sergiotarxz/nuttx-apps
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

libwld: Now compiles without errors or warnings

Browse Source
This commit is contained in:
Gregory Nutt 2016-11-10 13:48:43 -06:00
parent 6bad8f7676
commit b1fea5ec10
12 changed files with 185 additions and 198 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
graphics/traveler/tools/libwld/wld_bitmaps.c
View File

@ -58,7 +58,7 @@ wld_bitmap_t *g_odd_bitmaps[MAX_BITMAPS];
/* This is the palette to use for the selected world */
#if MSWINDOWS
RGBColor worldPalette[256];
color_rgb_t worldPalette[256];
#endif
/* This is the maximum value + 1 of a texture code. */

15
graphics/traveler/tools/libwld/wld_bitmaps.h
View File

@ -78,20 +78,15 @@ enum
* Public Type Definitions
*************************************************************************/
typedef struct rgb_color_t
{
uint8_t red; /* red component of color 0-63 */
uint8_t green; /* green component of color 0-63 */
uint8_t blue; /* blue component of color 0-63 */
} RGBColor;
typedef struct
struct wld_bitmap_s
{
uint16_t w;
uint16_t h;
uint8_t log2h;
trv_pixel_t *bm;
} wld_bitmap_t;
};
typedef struct wld_bitmap_s wld_bitmap_t;
/*************************************************************************
* Global Variables
@ -109,7 +104,7 @@ extern wld_bitmap_t *g_odd_bitmaps[MAX_BITMAPS];
/* This is the palette to use for the selected world */
#if MSWINDOWS
extern RGBColor worldPalette[256];
extern color_rgb_t worldPalette[256];
#endif
/* This is the maximum value + 1 of a texture code */

38
graphics/traveler/tools/libwld/wld_graphicfile.h
View File

@ -45,6 +45,8 @@
* Included files
*************************************************************************/
#include "wld_color.h"
/*************************************************************************
* Compilation switches
*************************************************************************/
@ -64,47 +66,45 @@
* Public Type Definitions
************************************************************************/
typedef enum
enum graphic_file_format_e
{
formatGIF87,
formatGIF89,
formatPPM,
formatPCX,
formatUnknown
} graphic_file_format_t;
};
typedef enum
typedef enum graphic_file_format_e graphic_file_format_t;
enum graphic_file_enum_e
{
gfTrueColor,
gfPaletted
} graphic_file_enum_t;
};
typedef struct
typedef enum graphic_file_enum_e graphic_file_enum_t;
struct graphic_file_e
{
graphic_file_enum_t type;
uint16_t height, width;
int palette_entries;
long transparent_entry;
RGBColor *palette;
color_rgb_t *palette;
uint8_t *bitmap;
} graphic_file_t;
};
typedef struct graphic_file_e graphic_file_t;
/*************************************************************************
* Global Function Prototypes
*************************************************************************/
/*************************************************************************
* Global Variables
*************************************************************************/
/*************************************************************************
* Private Variables
* Public Function Prototypes
*************************************************************************/
graphic_file_t *wld_new_graphicfile(void);
void wld_free_graphicfile(graphic_file_t *gFile);
RGBColor wld_graphicfile_pixel(graphic_file_t *gFile,
int x, int y);
void wld_free_graphicfile(graphic_file_t *gFile);
color_rgb_t wld_graphicfile_pixel(graphic_file_t *gFile,
int x, int y);
graphic_file_t *wld_readgraphic_file(char *filename);
#endif /* __ASTGRAPHICFILE_H */

4
graphics/traveler/tools/libwld/wld_graphicfilepixel.c
View File

@ -50,7 +50,7 @@
* Description:
************************************************************************/
RGBColor wld_graphicfile_pixel(graphic_file_t *gfile, int x, int y)
color_rgb_t wld_graphicfile_pixel(graphic_file_t *gfile, int x, int y)
{
if (gfile->type == gfPaletted)
{
@ -62,7 +62,7 @@ RGBColor wld_graphicfile_pixel(graphic_file_t *gfile, int x, int y)
else
{
unsigned char *pixel = gfile->bitmap + (y * gfile->width + x) * 3;
RGBColor rgb;
color_rgb_t rgb;
rgb.red = *pixel++;
rgb.green = *pixel++;

47
graphics/traveler/tools/libwld/wld_loadbitmapfile.c
View File

@ -129,12 +129,12 @@ static bool wld_read_filename(FILE * fp, char *fileName)
static uint8_t wld_load_bitmaps(FILE * fp)
{
#if MSWINDOWS
volatile pcxPicture workPCX;
RGBColor *palette;
volatile pcx_picture_t pcx;
color_rgb_t *palette;
#endif
uint16_t bMapIndex;
uint16_t mapndx;
uint8_t result = BMAP_SUCCESS;
uint8_t graphicsFileName[FILE_NAME_SIZE];
char filename[FILE_NAME_SIZE];
/* Discard any bitmaps that we may currently have buffered */
@ -160,13 +160,12 @@ static uint8_t wld_load_bitmaps(FILE * fp)
/* Load each bitmap file */
for (bMapIndex = 0;
((bMapIndex < g_nbitmaps) && (result == BMAP_SUCCESS)); bMapIndex++)
for (mapndx = 0; (mapndx < g_nbitmaps && result == BMAP_SUCCESS); mapndx++)
{
/* Load the even bitmap */
/* Get the name of the file which contains the even bitmap */
if (!wld_read_filename(fp, graphicsFileName))
if (!wld_read_filename(fp, filename))
{
return BMAP_BML_READ_ERROR;
}
@ -174,7 +173,7 @@ static uint8_t wld_load_bitmaps(FILE * fp)
#if MSWINDOWS
/* Setup to load the PCX bitmap from the file for the event bitmap */
result = wld_pcx_init(&workPCX, BITMAP_HEIGHT, BITMAP_WIDTH,
result = wld_pcx_init(&pcx, BITMAP_HEIGHT, BITMAP_WIDTH,
palette, NULL);
if (result)
{
@ -183,14 +182,14 @@ static uint8_t wld_load_bitmaps(FILE * fp)
/* Put the bitmap buffer into the evenBitmap list */
g_even_bitmaps[bMapIndex].w = BITMAP_WIDTH;
g_even_bitmaps[bMapIndex].h = BITMAP_HEIGHT;
g_even_bitmaps[bMapIndex].log2h = BITMAP_LOG2H;
g_even_bitmaps[bMapIndex].bm = workPCX.buffer;
g_even_bitmaps[mapndx].w = BITMAP_WIDTH;
g_even_bitmaps[mapndx].h = BITMAP_HEIGHT;
g_even_bitmaps[mapndx].log2h = BITMAP_LOG2H;
g_even_bitmaps[mapndx].bm = pcx.buffer;
/* Load the PCX bitmap from the file for the event bitmap */
result = wld_loadpcx(graphicsFileName, &workPCX);
result = wld_loadpcx(filename, &pcx);
if (result)
{
return result;
@ -201,8 +200,8 @@ static uint8_t wld_load_bitmaps(FILE * fp)
palette = NULL;
#else
g_even_bitmaps[bMapIndex] = wld_read_texturefile(graphicsFileName);
if (!g_even_bitmaps[bMapIndex])
g_even_bitmaps[mapndx] = wld_read_texturefile(filename);
if (!g_even_bitmaps[mapndx])
{
return BMAP_BML_READ_ERROR;
}
@ -211,7 +210,7 @@ static uint8_t wld_load_bitmaps(FILE * fp)
/* Load the odd bitmap */
/* Get the name of the file which contains the odd bitmap */
if (!wld_read_filename(fp, graphicsFileName))
if (!wld_read_filename(fp, filename))
{
return BMAP_BML_READ_ERROR;
}
@ -220,7 +219,7 @@ static uint8_t wld_load_bitmaps(FILE * fp)
# if MSWINDOWS
/* Setup to load the PCX bitmap from the file for the odd bitmap */
result = wld_pcx_init(&workPCX, BITMAP_HEIGHT, BITMAP_WIDTH,
result = wld_pcx_init(&pcx, BITMAP_HEIGHT, BITMAP_WIDTH,
palette, NULL);
if (result)
{
@ -229,17 +228,17 @@ static uint8_t wld_load_bitmaps(FILE * fp)
/* Put the bitmap buffer into the oddBitmap list */
g_odd_bitmaps[bMapIndex].w = BITMAP_WIDTH;
g_odd_bitmaps[bMapIndex].h = BITMAP_HEIGHT;
g_odd_bitmaps[bMapIndex].log2h = BITMAP_LOG2H;
g_odd_bitmaps[bMapIndex].bm = workPCX.buffer;
g_odd_bitmaps[mapndx].w = BITMAP_WIDTH;
g_odd_bitmaps[mapndx].h = BITMAP_HEIGHT;
g_odd_bitmaps[mapndx].log2h = BITMAP_LOG2H;
g_odd_bitmaps[mapndx].bm = pcx.buffer;
/* Load the PCX bitmap from the file for the odd bitmap */
result = wld_loadpcx(graphicsFileName, &workPCX);
result = wld_loadpcx(filename, &pcx);
# else
g_odd_bitmaps[bMapIndex] = wld_read_texturefile(graphicsFileName);
if (!g_odd_bitmaps[bMapIndex])
g_odd_bitmaps[mapndx] = wld_read_texturefile(filename);
if (!g_odd_bitmaps[mapndx])
{
return BMAP_BML_READ_ERROR;
}

6
graphics/traveler/tools/libwld/wld_loadgif.c
View File

@ -254,9 +254,9 @@ graphic_file_t *wld_LoadGIF(FILE * fp, char *fname)
if (fread(ptr, filesize, 1, fp) != 1)
wld_fatal_error("GIF data read failed");
if (strncmp(ptr, id87, 6))
if (strncmp((char *)ptr, id87, 6))
{
if (strncmp(ptr, id89, 6))
if (strncmp((char *)ptr, id89, 6))
{
wld_fatal_error("not a GIF file");
}
@ -367,7 +367,7 @@ graphic_file_t *wld_LoadGIF(FILE * fp, char *fname)
Width, Height, (Interlace) ? "" : "non-");
gfile = wld_new_graphicfile();
gfile->palette = (RGBColor *) wld_malloc(sizeof(RGBColor) * ColorMapSize);
gfile->palette = (color_rgb_t *) wld_malloc(sizeof(color_rgb_t) * ColorMapSize);
for (i = 0; i < ColorMapSize; i++)
{
gfile->palette[i].red = Red[i];

223
graphics/traveler/tools/libwld/wld_loadpcx.c
View File

@ -1,5 +1,6 @@
/****************************************************************************
* apps/graphics/traveler/tools/libwld/wld_loadpcx.c
* This file contains the logic which loads a PCX file.
*
* Copyright (C) 2016 Gregory Nutt. All rights reserved.
* Author: Gregory Nutt <gnutt@nuttx.org>
@ -33,15 +34,6 @@
*
****************************************************************************/
/*************************************************************************
* FILE: wld_loadpcx.c
* DESCRIPTION: This file contains the logic which loads a PCX file.
*************************************************************************/
/*************************************************************************
* Compilation Options
*************************************************************************/
/*************************************************************************
* Included files
*************************************************************************/
@ -56,130 +48,25 @@
#endif
#include "wld_pcx.h"
/*************************************************************************
* Definitions
*************************************************************************/
/*************************************************************************
* Private Type Definitions
************************************************************************/
/*************************************************************************
* Private Function Prototypes
*************************************************************************/
static void wld_loadpcxHeader(FILE * fp, pcxHeader * header);
static void wld_loadpcxHeader(FILE * fp, pcx_header_t * header);
static void wld_loadpcxData(FILE * fp, int32_t imagSize, uint8_t * imageBuffer);
static void wld_loadpcxPalette(FILE * fp, RGBColor * palette);
static void wld_loadpcxPalette(FILE * fp, color_rgb_t * palette);
/*************************************************************************
* Global Variables
* Private Functions
*************************************************************************/
/*************************************************************************
* Private Variables
*************************************************************************/
/*************************************************************************
* Name: wld_loadpcx
* Description:
* This function loads a pcx file into a picture structure, the actual image
* data for the pcx file is decompressed and expanded into a secondary buffer
* within the picture structure, the separate images can be grabbed from this
* buffer later. also the header and palette are loaded
************************************************************************/
#if MSWINDOWS
uint8_t wld_loadpcx(char *filename, pcxPicturePtr image)
{
FILE *fp, *fopen();
uint16_t imageWidth, imageHeight;
uint32_t imageSize;
/* Open the file */
fp = fopen(filename, "rb");
if (!fp)
{
return PCX_OPEN_ERROR;
}
/* Load the PCX Header */
wld_loadpcxHeader(fp, &image->header);
/* Load the PCX data */
if (image->buffer)
{
imageWidth = image->header.width - image->header.x + 1;
imageHeight = image->header.height - image->header.y + 1;
imageSize = imageHeight * imageWidth;
wld_loadpcxData(fp, imageSize, image->buffer);
}
/* Load the PCX palette */
if (image->palette)
{
wld_loadpcxPalette(fp, &image->palette);
}
fclose(fp);
return PCX_SUCCESS;
}
#else
graphic_file_t *wld_loadpcx(FILE * fp, char *filename)
{
pcxHeader header;
trv_pixel_t *buffer;
graphic_file_t *gFile;
RGBColor *palette;
uint16_t imageWidth, imageHeight;
uint32_t imageSize;
/* Load the PCX Header */
wld_loadpcxHeader(fp, &header);
/* Allocate Space to hold the image data */
imageWidth = header.width - header.x + 1;
imageHeight = header.height - header.y + 1;
imageSize = imageHeight * imageWidth * sizeof(trv_pixel_t);
buffer = (trv_pixel_t *) wld_malloc(imageSize + 1);
/* Load the PCX data into the buffer */
wld_loadpcxData(fp, imageSize, (uint8_t *) buffer);
/* Allocate space to hold the PCX palette */
palette = (RGBColor *) wld_malloc(sizeof(RGBColor) * 256);
/* Load the PCX palette */
wld_loadpcxPalette(fp, palette);
/* Now save the resulting data in a graphic_file_t structure */
gFile = wld_new_graphicfile();
gFile->type = gfPaletted;
gFile->palette = palette;
gFile->width = imageWidth;
gFile->height = imageHeight;
gFile->bitmap = buffer;
return gFile;
}
#endif
/*************************************************************************
* Name: wld_loadpcxHeader
* Description:
************************************************************************/
static void wld_loadpcxHeader(FILE * fp, pcxHeader * header)
static void wld_loadpcxHeader(FILE * fp, pcx_header_t * header)
{
uint8_t *tempBuffer;
int i;
@ -245,7 +132,7 @@ static void wld_loadpcxData(FILE * fp, int32_t imageSize, uint8_t * imageBuffer)
* Description:
************************************************************************/
static void wld_loadpcxPalette(FILE * fp, RGBColor * palette)
static void wld_loadpcxPalette(FILE * fp, color_rgb_t * palette)
{
int i;
@ -270,3 +157,101 @@ static void wld_loadpcxPalette(FILE * fp, RGBColor * palette)
#endif
}
}
/*************************************************************************
* Public Functions
*************************************************************************/
/*************************************************************************
* Name: wld_loadpcx
* Description:
* This function loads a pcx file into a picture structure, the actual image
* data for the pcx file is decompressed and expanded into a secondary buffer
* within the picture structure, the separate images can be grabbed from this
* buffer later. also the header and palette are loaded
************************************************************************/
#if MSWINDOWS
uint8_t wld_loadpcx(char *filename, pcxPicturePtr image)
{
FILE *fp, *fopen();
uint16_t imageWidth, imageHeight;
uint32_t imageSize;
/* Open the file */
fp = fopen(filename, "rb");
if (!fp)
{
return PCX_OPEN_ERROR;
}
/* Load the PCX Header */
wld_loadpcxHeader(fp, &image->header);
/* Load the PCX data */
if (image->buffer)
{
imageWidth = image->header.width - image->header.x + 1;
imageHeight = image->header.height - image->header.y + 1;
imageSize = imageHeight * imageWidth;
wld_loadpcxData(fp, imageSize, image->buffer);
}
/* Load the PCX palette */
if (image->palette)
{
wld_loadpcxPalette(fp, &image->palette);
}
fclose(fp);
return PCX_SUCCESS;
}
#else
graphic_file_t *wld_loadpcx(FILE * fp, char *filename)
{
pcx_header_t header;
trv_pixel_t *buffer;
graphic_file_t *gFile;
color_rgb_t *palette;
uint16_t imageWidth, imageHeight;
uint32_t imageSize;
/* Load the PCX Header */
wld_loadpcxHeader(fp, &header);
/* Allocate Space to hold the image data */
imageWidth = header.width - header.x + 1;
imageHeight = header.height - header.y + 1;
imageSize = imageHeight * imageWidth * sizeof(trv_pixel_t);
buffer = (trv_pixel_t *) wld_malloc(imageSize + 1);
/* Load the PCX data into the buffer */
wld_loadpcxData(fp, imageSize, (uint8_t *) buffer);
/* Allocate space to hold the PCX palette */
palette = (color_rgb_t *) wld_malloc(sizeof(color_rgb_t) * 256);
/* Load the PCX palette */
wld_loadpcxPalette(fp, palette);
/* Now save the resulting data in a graphic_file_t structure */
gFile = wld_new_graphicfile();
gFile->type = gfPaletted;
gFile->palette = palette;
gFile->width = imageWidth;
gFile->height = imageHeight;
gFile->bitmap = buffer;
return gFile;
}
#endif

2
graphics/traveler/tools/libwld/wld_lum2pixel.c
View File

@ -225,7 +225,7 @@ trv_pixel_t wld_color_lum2pixel(color_lum_t * lum)
* to a wider representation.
*/
return TRV_UVLUM2NDX(uvndx, lumndx);
return WLD_UVLUM2NDX(uvndx, lumndx);
#else
color_rgb_t rgb;

24
graphics/traveler/tools/libwld/wld_pcx.h
View File

@ -63,7 +63,7 @@ enum
};
#endif
typedef struct pcx_header_t
struct pcx_header_s
{
char manufacturer;
char version;
@ -79,17 +79,23 @@ typedef struct pcx_header_t
int16_t bytes_per_line;
int16_t palette_type;
char padding[58];
} pcxHeader, *pcxHeaderPtr;
};
typedef struct pcx_header_s pcx_header_t;
typedef struct pcx_header_s *pcx_pheader_t;
#define SIZEOF_PCX_HEADER 128
#if MSWINDOWS
typedef struct pcx_picture_t
struct pcx_picture_t
{
pcxHeader header;
pcx_header_t header;
uint8_t *buffer;
RGBColor *palette;
} pcxPicture, *pcxPicturePtr;
color_rgb_t *palette;
};
typedef struct pcx_picture_t
typedef struct pcx_ppicture_t
#endif
/*************************************************************************
@ -97,9 +103,9 @@ typedef struct pcx_picture_t
*************************************************************************/
#if MSWINDOWS
uint8_t wld_pcx_init(pcxPicturePtr image, uint16_t height, uint16_t width,
RGBColor *palette, uint8_t *buffer);
uint8_t wld_loadpcx(char *filename, pcxPicturePtr image);
uint8_t wld_pcx_init(pcxppicture_t image, uint16_t height, uint16_t width,
color_rgb_t *palette, uint8_t *buffer);
uint8_t wld_loadpcx(char *filename, pcxppicture_t image);
#else
graphic_file_t *wld_loadpcx(FILE *fp, char *filename);
#endif

2
graphics/traveler/tools/libwld/wld_pcxinit.c
View File

@ -57,7 +57,7 @@
************************************************************************/
uint8_t wld_pcx_init(pcxPicturePtr image, uint16_t height, uint16_t width,
RGBColor * palette, uint8_t * buffer)
color_rgb_t * palette, uint8_t * buffer)
{
image->palette = palette;

9
graphics/traveler/tools/libwld/wld_pixel2lum.c
View File

@ -46,11 +46,9 @@
#include "wld_color.h"
/*************************************************************************
* Private Data
* Public Functions
*************************************************************************/
static float g_cube2pixel = (float)TRV_PIXEL_MAX / (float)(RGB_CUBE_SIZE - 1);
/*************************************************************************
* Function: wld_pixel2lum
* Description: Convert a pixel value into RGB-Luminance value.
@ -68,8 +66,9 @@ void wld_pixel2lum(trv_pixel_t pixel_value, color_lum_t * lum)
/* Get the luminance associated with the RGB value */
lum->luminance = sqrt(lum->red * lum->red +
lum->green * lum->green + lum->blue * lum->blue);
lum->luminance = sqrt(lum->red * lum->red +
lum->green * lum->green +
lum->blue * lum->blue);
/* Convert the RGB Component into unit vector + luminance */

11
graphics/traveler/tools/libwld/wld_readtexturefile.c
View File

@ -41,8 +41,10 @@
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include "trv_types.h"
#include "wld_bitmaps.h"
#include "wld_color.h"
#include "wld_mem.h"
#include "wld_graphicfile.h"
#include "wld_utils.h"
@ -126,16 +128,17 @@ static wld_bitmap_t *wld_new_texture(uint16_t width, uint16_t height)
static void wld_quantize_texture(graphic_file_t * gFile, wld_bitmap_t * t)
{
RGBColor pixel;
trv_pixel_t *destPixel = t->bm;
int x, y;
color_rgb_t pixel;
trv_pixel_t *dest = t->bm;
int x;
int y;
for (x = gFile->width - 1; x >= 0; x--)
{
for (y = gFile->height - 1; y >= 0; y--)
{
pixel = wld_graphicfile_pixel(gFile, x, y);
*destPixel++ = wld_Rgb2Pixel(&pixel);
*dest++ = wld_rgb2pixel(&pixel);
}
}
}