diff --git a/Makefile b/Makefile index 59ef95f..4a8cfcf 100755 --- a/Makefile +++ b/Makefile @@ -1,7 +1,7 @@ # KallistiOS ##version## # # libkmg Makefile -# Copyright (c)2003 Dan Potter +# Copyright (c)2003 Megan Potter TARGET = libkmg.a OBJS = kmg.o @@ -13,5 +13,5 @@ include $(KOS_BASE)/addons/Makefile.prefab # creates the kos link to the headers create_kos_link: - rm -f ../include/kmg - ln -s ../libkmg/include ../include/kmg + rm -f $(KOS_PORTS)/include/kmg + ln -s $(CURDIR)/include $(KOS_PORTS)/include/kmg diff --git a/include/kmg.h b/include/kmg.h index ed8f886..21d4ea0 100644 --- a/include/kmg.h +++ b/include/kmg.h @@ -1,77 +1,68 @@ /* KallistiOS ##version## kmg/kmg.h - Copyrigh (C)2003 Dan Potter + Copyrigh (C)2003 Megan Potter */ #ifndef __KMG_KMG_H #define __KMG_KMG_H #ifdef _arch_dreamcast -# include - __BEGIN_DECLS - -# include -#else - -#ifdef NEED_KOS_TYPES -typedef unsigned char uint8; -typedef unsigned short uint16; -typedef unsigned long uint32; -#endif - +# include + __BEGIN_DECLS #endif +#include /* Header for KMG files. This isn't particularly meant to be future-proof since generally you'll build your textures into this format and then pair that data with an executable build. For safety though, we go ahead and put a version number anyway. All fields are _little endian_. */ typedef struct kmg_header { - uint32 magic; /* Magic code */ - uint32 version; /* Version code */ - uint32 platform; /* Platform specifier (major format) */ - uint32 format; /* Image (minor) format spec */ - uint32 width; /* Image width */ - uint32 height; /* Image height */ - uint32 byte_count; /* Image's data size in bytes */ - uint8 padding[36]; /* Pad to a 64-byte header (all zeros) */ + uint32_t magic; /* Magic code */ + uint32_t version; /* Version code */ + uint32_t platform; /* Platform specifier (major format) */ + uint32_t format; /* Image (minor) format spec */ + uint32_t width; /* Image width */ + uint32_t height; /* Image height */ + uint32_t byte_count; /* Image's data size in bytes */ + uint8_t padding[36]; /* Pad to a 64-byte header (all zeros) */ } kmg_header_t; /* Magic code -- every KMG will start with one of these. */ -#define KMG_MAGIC 0x00474d4b /* 'KMG\0' */ +#define KMG_MAGIC 0x00474d4b /* 'KMG\0' */ /* Version specifier -- for this version of the lib. A new version means the files are incompatible. */ -#define KMG_VERSION 1 +#define KMG_VERSION 1 /* Platform specifiers */ -#define KMG_PLAT_DC 1 -#define KMG_PLAT_GBA 2 -#define KMG_PLAT_PS2 3 +#define KMG_PLAT_DC 1 +#define KMG_PLAT_GBA 2 +#define KMG_PLAT_PS2 3 /* Format specifiers for DC */ -#define KMG_DCFMT_4BPP_PAL 0x01 /* Paletted formats */ -#define KMG_DCFMT_8BPP_PAL 0x02 -#define KMG_DCFMT_RGB565 0x03 /* True-color formats */ -#define KMG_DCFMT_ARGB4444 0x04 -#define KMG_DCFMT_ARGB1555 0x05 -#define KMG_DCFMT_YUV422 0x06 -#define KMG_DCFMT_BUMP 0x07 -#define KMG_DCFMT_MASK 0xff - -#define KMG_DCFMT_VQ 0x0100 /* VQ-encoded (incl codebook) */ -#define KMG_DCFMT_TWIDDLED 0x0200 /* Pre-twiddled */ -#define KMG_DCFMT_MIPMAP 0x0400 /* Includes mipmaps */ +#define KMG_DCFMT_4BPP_PAL 0x01 /* Paletted formats */ +#define KMG_DCFMT_8BPP_PAL 0x02 +#define KMG_DCFMT_RGB565 0x03 /* True-color formats */ +#define KMG_DCFMT_ARGB4444 0x04 +#define KMG_DCFMT_ARGB1555 0x05 +#define KMG_DCFMT_YUV422 0x06 +#define KMG_DCFMT_BUMP 0x07 +#define KMG_DCFMT_MASK 0xff + +#define KMG_DCFMT_VQ 0x0100 /* VQ-encoded (incl codebook) */ +#define KMG_DCFMT_TWIDDLED 0x0200 /* Pre-twiddled */ +#define KMG_DCFMT_MIPMAP 0x0400 /* Includes mipmaps */ #ifdef _arch_dreamcast - /* Call to load a KMG file from the VFS. */ - int kmg_to_img(const char * fn, kos_img_t * rv); + /* Call to load a KMG file from the VFS. */ + int kmg_to_img(const char *fn, kos_img_t *rv); - __END_DECLS + __END_DECLS #endif -#endif /* __KMG_KMG_H */ +#endif /* __KMG_KMG_H */ diff --git a/kmg.c b/kmg.c index b986a1f..4377fe0 100644 --- a/kmg.c +++ b/kmg.c @@ -3,7 +3,7 @@ KOS image format loader library kmg.c - Copyright (C)2003 Dan Potter + Copyright (C)2003 Megan Potter */ @@ -21,116 +21,116 @@ Note also that the allocated buffer for the image will be 32-byte aligned so you can DMA the textures straight to VRAM. */ -int kmg_to_img(const char * fn, kos_img_t * rv) { - file_t f; - kmg_header_t hdr; - int dep; - void * map; - - assert( rv != NULL ); - - /* Open the file */ - f = fs_open(fn, O_RDONLY); - if (f == FILEHND_INVALID) { - dbglog(DBG_ERROR, "kmg_to_img: can't open file '%s'\n", fn); - return -1; - } - - /* Read the header */ - if (fs_read(f, &hdr, sizeof(hdr)) != sizeof(hdr)) { - fs_close(f); - dbglog(DBG_ERROR, "kmg_to_img: can't read header from file '%s'\n", fn); - return -2; - } - - /* Verify a few things */ - if (hdr.magic != KMG_MAGIC || hdr.version != KMG_VERSION || - hdr.platform != KMG_PLAT_DC) - { - fs_close(f); - dbglog(DBG_ERROR, "kmg_to_img: file '%s' is incompatible:\n" - " magic %08lx version %d platform %d\n", - fn, hdr.magic, (int)hdr.version, (int)hdr.platform); - return -3; - } - - /* See if we can mmap the thing. If so, then we'll just make it - a non-owned buffer that way and save some transfers. */ - map = fs_mmap(f); - if (map) { - rv->data = ((uint8 *)map) + sizeof(hdr); - } - - /* Setup the kimg struct */ - rv->w = hdr.width; - rv->h = hdr.height; - - dep = 0; - if (hdr.format & KMG_DCFMT_VQ) - dep |= PVR_TXRLOAD_FMT_VQ; - if (hdr.format & KMG_DCFMT_TWIDDLED) - dep |= PVR_TXRLOAD_FMT_TWIDDLED; - - switch (hdr.format & KMG_DCFMT_MASK) { - case KMG_DCFMT_RGB565: - rv->fmt = KOS_IMG_FMT(KOS_IMG_FMT_RGB565, dep); - break; - - case KMG_DCFMT_ARGB4444: - rv->fmt = KOS_IMG_FMT(KOS_IMG_FMT_ARGB4444, dep); - break; - - case KMG_DCFMT_ARGB1555: - rv->fmt = KOS_IMG_FMT(KOS_IMG_FMT_ARGB1555, dep); - break; - - case KMG_DCFMT_YUV422: - rv->fmt = KOS_IMG_FMT(KOS_IMG_FMT_YUV422, dep); - break; - - case KMG_DCFMT_BUMP: - /* XXX */ - rv->fmt = KOS_IMG_FMT(KOS_IMG_FMT_RGB565, dep); - break; - - case KMG_DCFMT_4BPP_PAL: - case KMG_DCFMT_8BPP_PAL: - default: - assert_msg( 0, "currently-unsupported KMG pixel format" ); - fs_close(f); - free(rv->data); - return -5; - } - - rv->byte_count = hdr.byte_count; - - /* And load the rest of it if necessary */ - if (map) { - rv->fmt = KOS_IMG_FMT(KOS_IMG_FMT_I(rv->fmt) | KOS_IMG_NOT_OWNER, - KOS_IMG_FMT_D(rv->fmt)); - } else { - rv->data = malloc(hdr.byte_count); - if (!rv->data) { - dbglog(DBG_ERROR, "kmg_to_img: can't malloc(%d) while loading '%s'\n", - (int)hdr.byte_count, fn); - fs_close(f); - return -4; - } - if (fs_read(f, rv->data, rv->byte_count) != rv->byte_count) { - dbglog(DBG_ERROR, "kmg_to_img: can't read %d bytes while loading '%s'\n", - (int)hdr.byte_count, fn); - fs_close(f); - free(rv->data); - return -6; - } - } - - /* Ok, all done */ - fs_close(f); - - /* If the byte count is not a multiple of 32, bump it up as well. - This is for DMA/SQ usage. */ - rv->byte_count = (rv->byte_count + 31) & ~31; - - return 0; +int kmg_to_img(const char *fn, kos_img_t *rv) { + file_t f; + kmg_header_t hdr; + int dep; + void *map; + + assert( rv != NULL ); + + /* Open the file */ + f = fs_open(fn, O_RDONLY); + if (f == FILEHND_INVALID) { + dbglog(DBG_ERROR, "kmg_to_img: can't open file '%s'\n", fn); + return -1; + } + + /* Read the header */ + if (fs_read(f, &hdr, sizeof(hdr)) != sizeof(hdr)) { + fs_close(f); + dbglog(DBG_ERROR, "kmg_to_img: can't read header from file '%s'\n", fn); + return -2; + } + + /* Verify a few things */ + if (hdr.magic != KMG_MAGIC || hdr.version != KMG_VERSION || + hdr.platform != KMG_PLAT_DC) + { + fs_close(f); + dbglog(DBG_ERROR, "kmg_to_img: file '%s' is incompatible:\n" + " magic %08lx version %d platform %d\n", + fn, hdr.magic, (int)hdr.version, (int)hdr.platform); + return -3; + } + + /* See if we can mmap the thing. If so, then we'll just make it + a non-owned buffer that way and save some transfers. */ + map = fs_mmap(f); + if (map) { + rv->data = ((uint8_t *)map) + sizeof(hdr); + } + + /* Setup the kimg struct */ + rv->w = hdr.width; + rv->h = hdr.height; + + dep = 0; + if (hdr.format & KMG_DCFMT_VQ) + dep |= PVR_TXRLOAD_FMT_VQ; + if (hdr.format & KMG_DCFMT_TWIDDLED) + dep |= PVR_TXRLOAD_FMT_TWIDDLED; + + switch (hdr.format & KMG_DCFMT_MASK) { + case KMG_DCFMT_RGB565: + rv->fmt = KOS_IMG_FMT(KOS_IMG_FMT_RGB565, dep); + break; + + case KMG_DCFMT_ARGB4444: + rv->fmt = KOS_IMG_FMT(KOS_IMG_FMT_ARGB4444, dep); + break; + + case KMG_DCFMT_ARGB1555: + rv->fmt = KOS_IMG_FMT(KOS_IMG_FMT_ARGB1555, dep); + break; + + case KMG_DCFMT_YUV422: + rv->fmt = KOS_IMG_FMT(KOS_IMG_FMT_YUV422, dep); + break; + + case KMG_DCFMT_BUMP: + /* XXX */ + rv->fmt = KOS_IMG_FMT(KOS_IMG_FMT_RGB565, dep); + break; + + case KMG_DCFMT_4BPP_PAL: + case KMG_DCFMT_8BPP_PAL: + default: + assert_msg( 0, "currently-unsupported KMG pixel format" ); + fs_close(f); + free(rv->data); + return -5; + } + + rv->byte_count = hdr.byte_count; + + /* And load the rest of it if necessary */ + if (map) { + rv->fmt = KOS_IMG_FMT(KOS_IMG_FMT_I(rv->fmt) | KOS_IMG_NOT_OWNER, + KOS_IMG_FMT_D(rv->fmt)); + } else { + rv->data = malloc(hdr.byte_count); + if (!rv->data) { + dbglog(DBG_ERROR, "kmg_to_img: can't malloc(%d) while loading '%s'\n", + (int)hdr.byte_count, fn); + fs_close(f); + return -4; + } + if (fs_read(f, rv->data, rv->byte_count) != rv->byte_count) { + dbglog(DBG_ERROR, "kmg_to_img: can't read %d bytes while loading '%s'\n", + (int)hdr.byte_count, fn); + fs_close(f); + free(rv->data); + return -6; + } + } + + /* Ok, all done */ + fs_close(f); + + /* If the byte count is not a multiple of 32, bump it up as well. + This is for DMA/SQ usage. */ + rv->byte_count = (rv->byte_count + 31) & ~31; + + return 0; } diff --git a/module_main.c b/module_main.c index f94fcbc..754969d 100644 --- a/module_main.c +++ b/module_main.c @@ -1,13 +1,13 @@ /* KallistiOS ##version## module_main.c - Copyright (C)2003 Dan Potter + Copyright (C)2003 Megan Potter */ - + #include #include -const char * lib_get_name() { - return "imgloader.kmg"; +const char *lib_get_name(void) { + return "imgloader.kmg"; }