From bb1e653309a614cc2f19e79043780b06c3f525b4 Mon Sep 17 00:00:00 2001 From: Jay Oster Date: Sat, 28 Jun 2014 22:10:11 -0700 Subject: [PATCH] Initial Commit: v0.186 --- .gitignore | 15 + ALT64.INI | 32 + Makefile | 38 + README | 56 + chksum64.c | 106 + disk.c | 711 ++++ disk.h | 29 + doc/functions.txt | 104 + errors.h | 70 + everdrive.c | 596 +++ everdrive.h | 125 + fat.c | 1931 +++++++++ fat.h | 128 + filesystem/bamboo.wav | Bin 0 -> 122156 bytes filesystem/done.wav | Bin 0 -> 36356 bytes filesystem/ed64_mono.wav | Bin 0 -> 154510 bytes filesystem/n64controller.sprite | Bin 0 -> 307208 bytes filesystem/sprites/background.sprite | Bin 0 -> 307208 bytes filesystem/sprites/splash.sprite | Bin 0 -> 307208 bytes filesystem/warning.wav | Bin 0 -> 14472 bytes font_patch/font.h | 275 ++ font_patch/info.txt | 1 + header.ed64 | Bin 0 -> 4096 bytes ini.c | 301 ++ ini.h | 77 + mem.c | 160 + mem.h | 39 + menu.c | 5784 ++++++++++++++++++++++++++ menu.h | 108 + mp3.c | 446 ++ sram.c | 127 + sram.h | 32 + stb_image.c | 4940 ++++++++++++++++++++++ stb_truetype.h | 1807 ++++++++ strlib.c | 43 + strlib.h | 24 + sys.c | 359 ++ sys.h | 61 + types.h | 36 + upload.sh | 15 + usb.c | 180 + usb.h | 16 + utils.c | 1640 ++++++++ utils.h | 170 + 44 files changed, 20582 insertions(+) create mode 100644 .gitignore create mode 100644 ALT64.INI create mode 100644 Makefile create mode 100644 README create mode 100644 chksum64.c create mode 100644 disk.c create mode 100644 disk.h create mode 100644 doc/functions.txt create mode 100644 errors.h create mode 100644 everdrive.c create mode 100644 everdrive.h create mode 100644 fat.c create mode 100644 fat.h create mode 100644 filesystem/bamboo.wav create mode 100644 filesystem/done.wav create mode 100644 filesystem/ed64_mono.wav create mode 100644 filesystem/n64controller.sprite create mode 100644 filesystem/sprites/background.sprite create mode 100644 filesystem/sprites/splash.sprite create mode 100644 filesystem/warning.wav create mode 100644 font_patch/font.h create mode 100644 font_patch/info.txt create mode 100644 header.ed64 create mode 100644 ini.c create mode 100644 ini.h create mode 100644 mem.c create mode 100644 mem.h create mode 100644 menu.c create mode 100644 menu.h create mode 100644 mp3.c create mode 100644 sram.c create mode 100644 sram.h create mode 100644 stb_image.c create mode 100644 stb_truetype.h create mode 100644 strlib.c create mode 100644 strlib.h create mode 100644 sys.c create mode 100644 sys.h create mode 100644 types.h create mode 100755 upload.sh create mode 100644 usb.c create mode 100644 usb.h create mode 100644 utils.c create mode 100644 utils.h diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..cea8197 --- /dev/null +++ b/.gitignore @@ -0,0 +1,15 @@ +## Build files +*.v64 +*.elf +*.o +*.bin +*.dfs + +## OSX junk +.DS_Store +.Trashes +._* + +## Temporary files +*.tmp +*~ diff --git a/ALT64.INI b/ALT64.INI new file mode 100644 index 0000000..9b9ed3e --- /dev/null +++ b/ALT64.INI @@ -0,0 +1,32 @@ +; alt64 config file + +[ed64] ; Menu config +build=18 ; Release build nr +border_color_1=FFFFFFFF ; 0x00000080 RGBT +border_color_2=3F3F3FFF ; 0x3F3F3FFF RGBT 00000060 w light +box_color=000000B6 ; 0x00000080 RGBT +selection_color=80008070 ; 80008070 RGBT 6495ED60 +list_font_color=CDC9C940 ; 80008070 RGBT 6495ED60 +list_dir_font_color=FFFFE040 ; 80008070 RGBT 6495ED60 +selection_font_color=FFB90FFF ; 80008070 RGBT 6495ED60 +text_offset=0 ; shift menu horizontal e.g. -1 +cd_behaviour=1 ; 0=first entry 1=last entry +scroll_behaviour=0 ; 0=page-system 1=classic +quick_boot=1 ; 'START' boots last rom +sound_on=1 ; sounds 1=on 0=off +page_display=1 ; display page +tv_mode=1 ; 1=ntsc 2=pal 3=mpal 0=force_off +enable_colored_list=1 ; 1=enable 0=disalbe +ext_type=0 ; 0=classic 1=OS64 +sd_speed=2 ; 1=25MHz 2=50MHz +background_image=background.png ; backgrund png image 320x240 32bit +hide_sysfolder=0 ; 1=hide 0=don't hide +mempak_path=/MEMPAKS/ ; surround with slashes +save_path=SDSAVE ; save directory inside ED64 + +[user] +name = saturnu ; Username + +[gblite] +save_path=/ED64/SDSAVE/ ; save directory surround with slashes +tv_mode=0 ; 1=ntsc 2=pal 3=mpal 0=force_off diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..a82f20b --- /dev/null +++ b/Makefile @@ -0,0 +1,38 @@ +ROOTDIR = $(N64_INST) +GCCN64PREFIX = $(ROOTDIR)/bin/mips64-elf- +CHKSUM64PATH = $(ROOTDIR)/bin/chksum64 +MKDFSPATH = $(ROOTDIR)/bin/mkdfs +HEADERPATH = $(ROOTDIR)/lib +N64TOOL = $(ROOTDIR)/bin/n64tool +HEADERNAME = header + + +LINK_FLAGS = -G4 -L$(ROOTDIR)/toolchain_font/lib -L$(ROOTDIR)/mips64-elf/lib -ldragon -L$(ROOTDIR)/toolchain_font/lib -lmikmod -lmad -lc -lm -ldragonsys -lnosys $(LIBS) -Tn64ld.x +PROG_NAME = menu +CFLAGS = -std=gnu99 -march=vr4300 -mtune=vr4300 -G4 -I$(ROOTDIR)/toolchain_font/include -I$(ROOTDIR)/mips64-elf/include -lpthread -lrt -D_REENTRANT -DUSE_TRUETYPE +ASFLAGS = -mtune=vr4300 -march=vr4300 +CC = $(GCCN64PREFIX)gcc +AS = $(GCCN64PREFIX)as +LD = $(GCCN64PREFIX)ld +OBJCOPY = $(GCCN64PREFIX)objcopy +OBJS = $(PROG_NAME).o everdrive.o fat.o disk.o mem.o sys.o ini.o strlib.o utils.o sram.o stb_image.o chksum64.o mp3.o + +$(PROG_NAME).v64: $(PROG_NAME).elf test.dfs + $(OBJCOPY) $(PROG_NAME).elf $(PROG_NAME).bin -O binary + rm -f $(PROG_NAME).v64 + $(N64TOOL) -l 4M -t "EverDrive OS" -h ./header.ed64 -o OS64.v64 $(PROG_NAME).bin -s 1M test.dfs + $(CHKSUM64PATH) OS64.v64 + +$(PROG_NAME).elf : $(OBJS) + $(LD) -o $(PROG_NAME).elf $(OBJS) $(LINK_FLAGS) + +copy: $(PROG_NAME).v64 + sh upload.sh + +test.dfs: + $(MKDFSPATH) test.dfs ./filesystem/ + +all: $(PROG_NAME).v64 + +clean: + rm -f *.v64 *.elf *.o *.bin *.dfs diff --git a/README b/README new file mode 100644 index 0000000..eaae5f3 --- /dev/null +++ b/README @@ -0,0 +1,56 @@ +alt64 +===== + +alternative everdrive64 menu + + +Kuroneko! + + :\ /; _ + ; \___/ ; ; ; + ,:-"' `"-:. / ; +_ /,---. ,---.\ _ _; / +_:>(( | ) ( | ))<:_ ,-""_," + \````` `````/""""",-"" + '-.._ v _..-' ) + / ___ ____,.. \ + / / | | | ( \. \ +ctr / / | | | | \ \ + `" `" `" `" + +nyannyannyannyannyannyannyannyannyannyannyannyannyannyannyannyannyan + + +hello here is my menu for the everdrive64. +if you don't have one you should visit krikzzs homepage +for ordering information. ^^ + +if you want to build the menu, you need a n64 toolchain +you can get one free from + +http://www.dragonminded.com/n64dev/libdragon/ +https://github.com/DragonMinded/libdragon + +i used the libmikmod linked on his site too for the menu +http://www.dragonminded.com/n64dev/libmikmod-3.2.0-beta2.tgz + + +if you are on linux, try out the build script +https://github.com/DragonMinded/libdragon/tree/master/tools/build + +here are a few setting hints +export INSTALL_PATH=/usr/mips64-elf +set this to your home directory if you don't have root access + +i was in need to alter the cxxflags to G0 to lowercase +CXXFLAGS="-g0 -O2" + +it's a good idea to the latest versions for the toolchain +export BINUTILS_V=2.23.52 +export GCC_V=4.8.0 +export NEWLIB_V=1.20.0 + + +optional: +get libn64-hkz to get more into flashram savegames +http://sourceforge.net/projects/n64dev/ diff --git a/chksum64.c b/chksum64.c new file mode 100644 index 0000000..b2e0a6c --- /dev/null +++ b/chksum64.c @@ -0,0 +1,106 @@ +/* + checksum rom in psram, based on + + chksum64 V1.2, a program to calculate the ROM checksum of Nintendo64 ROMs. + Copyright (C) 1997 Andreas Sterbenz (stan@sbox.tu-graz.ac.at) + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA +*/ +#include +#include +#include + + +#define BUFSIZE 0x8000 +#define SDRAM_START 0xb0000000 + +#define CHECKSUM_START 0x1000 +#define CHECKSUM_LENGTH 0x100000L +#define CHECKSUM_HEADERPOS 0x10 +#define CHECKSUM_END (CHECKSUM_START + CHECKSUM_LENGTH) + +#define CHECKSUM_STARTVALUE 0xf8ca4ddc + +#define ROL(i, b) (((i)<<(b)) | ((i)>>(32-(b)))) + +#define BYTES2LONG(b) ( (((b)[0] & 0xffL) << 24) | \ + (((b)[1] & 0xffL) << 16) | \ + (((b)[2] & 0xffL) << 8) | \ + (((b)[3] & 0xffL)) ) + +#define LONG2BYTES(l, b) (b)[0] = ((l)>>24)&0xff; \ + (b)[1] = ((l)>>16)&0xff; \ + (b)[2] = ((l)>> 8)&0xff; \ + (b)[3] = ((l) )&0xff; + + +static unsigned char __attribute__((aligned(16))) buffer1[BUFSIZE]; + + +void checksum_sdram(void) +{ + unsigned int sum1, sum2, offs; + + { + unsigned int i; + unsigned int c1, k1, k2; + unsigned int t1, t2, t3, t4; + unsigned int t5, t6; + unsigned int n; + unsigned int clen = CHECKSUM_LENGTH; + + t1 = CHECKSUM_STARTVALUE; + t2 = CHECKSUM_STARTVALUE; + t3 = CHECKSUM_STARTVALUE; + t4 = CHECKSUM_STARTVALUE; + t5 = CHECKSUM_STARTVALUE; + t6 = CHECKSUM_STARTVALUE; + + offs = CHECKSUM_START; + + for( ;; ) { + n = (BUFSIZE < clen) ? BUFSIZE : clen; + dma_read_s(buffer1, SDRAM_START+offs, n); + data_cache_hit_writeback_invalidate(buffer1,n); + + offs += n; + + for( i=0; i + +#include "disk.h" +#include "mem.h" +#include "everdrive.h" +#include "errors.h" +#include "sys.h" +#include "usb.h" + +#define CMD0 0x40 // software reset +#define CMD1 0x41 // brings card out of idle state +#define CMD8 0x48 // Reserved +#define CMD12 0x4C // stop transmission on multiple block read +#define CMD17 0x51 // read single block +#define CMD18 0x52 // read multiple block +#define CMD58 0x7A // reads the OCR register +#define CMD55 0x77 +#define CMD41 0x69 +#define CMD24 0x58 // writes a single block +#define CMD25 0x59 // writes a multi block +#define ACMD41 0x69 +#define ACMD6 0x46 +#define SD_V2 2 +#define SD_HC 1 + + +#define CMD2 0x42 //read cid +#define CMD3 0x43 //read rca +#define CMD7 0x47 +#define CMD9 0x49 +#define CMD6 0x46 + +#define R1 1 +#define R2 2 +#define R3 3 +#define R6 6 +#define R7 7 + +u8 card_type; +u8 sd_resp_buff[18]; +u32 disk_interface; + + + +unsigned int diskCrc7(unsigned char *buff, unsigned int len); +void diskCrc16SD(u8 *data, u16 *crc_out, u16 len); +u8 diskGetRespTypeSD(u8 cmd); +u8 diskCmdSD(u8 cmd, u32 arg); + +u8 diskInitSD(); +u8 diskReadSD(u32 saddr, void *buff, u16 slen); +u8 diskWriteSD(u32 saddr, u8 *buff, u16 slen); +u8 diskStopRwSD(); + +u8 diskCmdSPI(u8 cmd, u32 arg); +u8 diskInitSPI(); +u8 diskReadSPI(u32 saddr, void *buff, u16 slen); +u8 diskWriteSPI(u32 saddr, u8 *buff, u16 slen); + + + +const u16 sd_crc16_table[] = { + 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7, + 0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF, + 0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6, + 0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE, + 0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485, + 0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D, + 0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4, + 0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC, + 0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823, + 0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B, + 0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12, + 0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A, + 0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41, + 0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49, + 0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70, + 0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78, + 0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F, + 0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067, + 0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E, + 0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256, + 0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D, + 0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405, + 0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C, + 0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634, + 0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB, + 0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3, + 0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A, + 0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92, + 0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9, + 0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1, + 0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8, + 0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0 +}; + +void diskSetInterface(u32 interface) { + + disk_interface = interface; +} + +u8 diskGetInterface() { + + return disk_interface; +} + +u8 diskInit() { + + if (disk_interface == DISK_IFACE_SD) { + return diskInitSD(); + } else { + return diskInitSPI(); + } +} + +u8 diskRead(u32 saddr, void *buff, u16 slen) { + + if (disk_interface == DISK_IFACE_SD) { + return diskReadSD(saddr, buff, slen); + } else { + return diskReadSPI(saddr, buff, slen); + } +} + +u8 diskWrite(u32 saddr, u8 *buff, u16 slen) { + + if (disk_interface == DISK_IFACE_SD) { + return diskWriteSD(saddr, buff, slen); + } else { + return diskWriteSPI(saddr, buff, slen); + } +} + +void diskCrc16SD(u8 *data, u16 *crc_out, u16 len) { + + ///u16 len = 512; + u16 i, tmp1, u; + u8 dat[4]; + u8 dat_tmp; + u16 crc_buff[4]; + + + for (i = 0; i < 4; i++)crc_buff[i] = 0; + for (i = 0; i < 4; i++)crc_out[i] = 0; + //u16 dptr = 0; + while (len) { + len -= 4; + for (i = 0; i < 4; i++)dat[i] = 0; + + for (u = 0; u < 4; u++) { + dat_tmp = data[3 - u]; + //dat_tmp = 0xff; + for (i = 0; i < 4; i++) { + dat[i] >>= 1; + dat[i] |= (dat_tmp & 1) << 7; + dat_tmp >>= 1; + } + + for (i = 0; i < 4; i++) { + dat[i] >>= 1; + dat[i] |= (dat_tmp & 1) << 7; + dat_tmp >>= 1; + } + } + + data += 4; + + for (u = 0; u < 4; u++) { + tmp1 = crc_buff[u]; + crc_buff[u] = sd_crc16_table[(tmp1 >> 8) ^ dat[u]]; + crc_buff[u] = crc_buff[u] ^ (tmp1 << 8); + } + + } + + for (i = 0; i < 4 * 16; i++) { + + crc_out[3 - i / 16] >>= 1; + crc_out[3 - i / 16] |= (crc_buff[i % 4] & 1) << 15; + crc_buff[i % 4] >>= 1; + } + +} + +unsigned int diskCrc7(unsigned char *buff, unsigned int len) { + + unsigned int a, crc = 0; + + while (len--) { + crc ^= *buff++; + a = 8; + do { + crc <<= 1; + if (crc & (1 << 8)) crc ^= 0x12; + } while (--a); + } + return (crc & 0xfe); +} + +u8 diskGetRespTypeSD(u8 cmd) { + + switch (cmd) { + case CMD3: + return R6; + case CMD8: + return R7; + case CMD2: + case CMD9: + return R2; + case CMD58: + case CMD41: + return R3; + + default: return R1; + } + +} + +u8 diskCmdSD(u8 cmd, u32 arg) { + + u8 resp_type = diskGetRespTypeSD(cmd); + u8 p = 0; + u8 buff[6]; + volatile u8 resp; + volatile u32 i = 0; + + u8 resp_len = resp_type == R2 ? 17 : 6; + u8 crc; + buff[p++] = cmd; + buff[p++] = (arg >> 24); + buff[p++] = (arg >> 16); + buff[p++] = (arg >> 8); + buff[p++] = (arg >> 0); + crc = diskCrc7(buff, 5) | 1; + + evd_SDcmdWriteMode(0); + + mem_spi(0xff); + mem_spi(cmd); + mem_spi(arg >> 24); + mem_spi(arg >> 16); + mem_spi(arg >> 8); + mem_spi(arg); + mem_spi(crc); + evd_SDcmdReadMode(1); + + i = 0; + resp = 0xff; + while ((resp & 192) != 0) { + resp = mem_spi(resp); + if (i++ == WAIT)return SD_CMD_TIMEOUT; + } + evd_SDcmdReadMode(0); + + + sd_resp_buff[0] = resp; + + for (i = 1; i < resp_len; i++) { + sd_resp_buff[i] = mem_spi(0xff); + } + + if (resp_type != R3) { + + + + if (resp_type == R2) { + crc = diskCrc7(sd_resp_buff + 1, resp_len - 2) | 1; + } else { + crc = diskCrc7(sd_resp_buff, resp_len - 1) | 1; + } + if (crc != sd_resp_buff[resp_len - 1])return SD_CMD_CRC_ERROR; + } + + return 0; +} + +u8 diskInitSD() { + + u16 i; + volatile u8 resp = 0; + u32 rca; + u32 wait_len = WAIT; + + card_type = 0; + evd_enableSDMode(); + memSpiSSOff(); + memSpiSetSpeed(SPI_SPEED_INIT); + + evd_SDcmdWriteMode(0); + + for (i = 0; i < 40; i++)mem_spi(0xff); + resp = diskCmdSD(CMD0, 0x1aa); + for (i = 0; i < 40; i++)mem_spi(0xff); + + + resp = diskCmdSD(CMD8, 0x1aa); + if (resp != 0 && resp != SD_CMD_TIMEOUT) { + return SD_INIT_ERROR + 0; + } + if (resp == 0)card_type |= SD_V2; + + + if (card_type == SD_V2) { + + for (i = 0; i < wait_len; i++) { + + resp = diskCmdSD(CMD55, 0); + if (resp)return SD_INIT_ERROR + 1; + if ((sd_resp_buff[3] & 1) != 1)continue; + resp = diskCmdSD(CMD41, 0x40300000); + if ((sd_resp_buff[1] & 128) == 0)continue; + + break; + } + } else { + + i = 0; + do { + resp = diskCmdSD(CMD55, 0); + if (resp)return SD_INIT_ERROR + 2; + resp = diskCmdSD(CMD41, 0x40300000); + if (resp)return SD_INIT_ERROR + 3; + + } while (sd_resp_buff[1] < 1 && i++ < wait_len); + + } + + if (i == wait_len)return SD_INIT_ERROR + 4; + + if ((sd_resp_buff[1] & 64) && card_type != 0)card_type |= SD_HC; + + + resp = diskCmdSD(CMD2, 0); + if (resp)return SD_INIT_ERROR + 5; + + resp = diskCmdSD(CMD3, 0); + if (resp)return SD_INIT_ERROR + 6; + + resp = diskCmdSD(CMD7, 0); + //if (resp)return resp; + + rca = (sd_resp_buff[1] << 24) | (sd_resp_buff[2] << 16) | (sd_resp_buff[3] << 8) | (sd_resp_buff[4] << 0); + + + + + resp = diskCmdSD(CMD9, rca); //get csd + if (resp)return SD_INIT_ERROR + 7; + + + resp = diskCmdSD(CMD7, rca); + if (resp)return SD_INIT_ERROR + 8; + + + resp = diskCmdSD(CMD55, rca); + if (resp)return SD_INIT_ERROR + 9; + + + resp = diskCmdSD(CMD6, 2); + if (resp)return SD_INIT_ERROR + 10; + + + memSpiSetSpeed(SPI_SPEED_25); + + return 0; + +} + +u8 diskReadSD(u32 saddr, void *buff, u16 slen) { + + u8 resp; + + + if (!(card_type & 1))saddr *= 512; + resp = diskCmdSD(CMD18, saddr); + if (resp)return DISK_ERR_RD1; + + + resp = memSpiRead(buff, slen); + if (resp)return resp; + + //console_printf("drd: %0X\n", saddr); + resp = diskStopRwSD(); + + return resp; +} + +u8 diskStopRwSD() { + + u8 resp; + u16 i; + resp = diskCmdSD(CMD12, 0); + if (resp)return DISK_ERR_CLOSE_RW1; + evd_SDdatReadMode(0); + mem_spi(0xff); + + i = 65535; + while (i--) { + if (mem_spi(0xff) == 0xff)break; + if (mem_spi(0xff) == 0xff)break; + if (mem_spi(0xff) == 0xff)break; + if (mem_spi(0xff) == 0xff)break; + } + if (i == 0)return DISK_ERR_CLOSE_RW2; + + return 0; +} + +u8 diskWriteSD(u32 saddr, u8 *buff, u16 slen) { + + u8 resp; + u16 crc16[5]; + u16 i; + u16 u; + u8 ram_buff[512]; + u8 *buff_ptr; + + + if (!(card_type & 1))saddr *= 512; + resp = diskCmdSD(CMD25, saddr); + if (resp)return DISK_ERR_WR1; + + evd_SDdatWriteMode(0); + + + while (slen--) { + + if ((u32) buff >= ROM_ADDR && (u32) buff < ROM_END_ADDR) { + dma_read_s(ram_buff, (u32) buff, 512); + buff_ptr = ram_buff; + } else { + buff_ptr = buff; + } + + diskCrc16SD(buff_ptr, crc16, 512); + evd_SDdatWriteMode(0); + + + mem_spi(0xff); + mem_spi(0xf0); + + + memSpiWrite(buff_ptr); + + for (i = 0; i < 4; i++) { + mem_spi(crc16[i] >> 8); + mem_spi(crc16[i] & 0xff); + } + + buff += 512; + + evd_SDdatWriteMode(1); + mem_spi(0xff); + evd_SDdatReadMode(1); + + i = 1024; + while ((mem_spi(0xff) & 1) != 0 && i-- != 0); + if (i == 0)return DISK_WR_SB_TOUT; + resp = 0; + + for (i = 0; i < 3; i++) { + resp <<= 1; + u = mem_spi(0xff); + resp |= u & 1; + } + resp &= 7; + + if (resp != 0x02) { + //console_printf("error blia: %0X\n", resp); + // joyWait(); + if (resp == 5)return DISK_ERR_WR_CRC; + return DISK_ERR_WRX; + } + + evd_SDdatReadMode(0); + mem_spi(0xff); + i = 65535; + while (i--) { + + if (mem_spi(0xff) == 0xff)break; + if (mem_spi(0xff) == 0xff)break; + } + if (i == 0)return DISK_ERR_WR2; + } + + resp = diskStopRwSD(); + if (resp)return resp; + + return 0; +} + +u8 diskCmdSPI(u8 cmd, u32 arg) { + + + u8 crc; + u8 p = 0; + u8 buff[6]; + buff[p++] = cmd; + buff[p++] = (arg >> 24); + buff[p++] = (arg >> 16); + buff[p++] = (arg >> 8); + buff[p++] = (arg >> 0); + + crc = diskCrc7(buff, 5) | 1; + + volatile u32 i = 0; + volatile u8 resp; + memSpiBusy(); + memSpiSSOff(); + memSpiSSOn(); + //mem_spi(0x1); + mem_spi(0xff); + mem_spi(cmd); + mem_spi(arg >> 24); + mem_spi(arg >> 16); + mem_spi(arg >> 8); + mem_spi(arg); + mem_spi(crc); + mem_spi(0xff); + resp = mem_spi(0xff); + + // memSpiSSOn(); + + while (resp == 0xff) { + resp = mem_spi(0xff); + if (i++ == WAIT)break; + } + + memSpiSSOff(); + return resp; +} + +u8 diskInitSPI() { + + u16 i; + u32 u; + + volatile u8 resp = 0; + u8 cmd; + u32 wait_len = WAIT; + + card_type = 0; + + evd_enableSPIMode(); + //return evd_mmcInit(); + + memSpiSetSpeed(SPI_SPEED_INIT); + + for (u = 0; u < 4; u++) { + for (i = 0; i < 40; i++)mem_spi(0xff); + resp = diskCmdSPI(CMD0, 0); + if (resp == 1)break; + } + + if (resp != 1) return DISK_ERR_INIT + 0; + //mmcCmdCrc(0x7b, 0, 0x91); + resp = diskCmdSPI(CMD8, 0x1aa); + for (i = 0; i < 5; i++)mem_spi(0xff); + if (resp == 0xff)return DISK_ERR_INIT + 1; + if (resp != 5)card_type |= SD_V2; + + if (card_type == 2) { + + for (i = 0; i < wait_len; i++) { + + + resp = diskCmdSPI(CMD55, 0xffff); + if (resp == 0xff)return DISK_ERR_INIT + 2; + if (resp != 1)continue; + + resp = diskCmdSPI(CMD41, 0x40300000); + if (resp == 0xff)return DISK_ERR_INIT + 3; + if (resp != 0)continue; + + break; + } + if (i == wait_len)return DISK_ERR_INIT + 4; + + resp = diskCmdSPI(CMD58, 0); + if (resp == 0xff)return DISK_ERR_INIT + 5; + memSpiSSOn(); + resp = mem_spi(0xff); + for (i = 0; i < 3; i++)mem_spi(0xff); + if ((resp & 0x40))card_type |= 1; + } else { + + + i = 0; + + resp = diskCmdSPI(CMD55, 0); + if (resp == 0xff)return DISK_ERR_INIT + 6; + resp = diskCmdSPI(CMD41, 0); + if (resp == 0xff)return DISK_ERR_INIT + 7; + cmd = resp; + + for (i = 0; i < wait_len; i++) { + if (resp < 1) { + + resp = diskCmdSPI(CMD55, 0); + if (resp == 0xff)return DISK_ERR_INIT + 8; + if (resp != 1)continue; + + resp = diskCmdSPI(CMD41, 0); + if (resp == 0xff)return DISK_ERR_INIT + 9; + if (resp != 0)continue; + + } else { + + resp = diskCmdSPI(CMD1, 0); + if (resp != 0)continue; + } + + break; + + } + + if (i == wait_len)return DISK_ERR_INIT + 10; + + } + + memSpiSetSpeed(SPI_SPEED_25); + + return 0; +} + +u8 diskReadSPI(u32 saddr, void *buff, u16 slen) { + + + u8 resp; + + if (!(card_type & 1))saddr *= 512; + resp = diskCmdSPI(CMD18, saddr); + if (resp != 0)return DISK_ERR_RD1; + memSpiSSOn(); + + resp = memSpiRead(buff, slen); + + memSpiSSOff(); + diskCmdSPI(CMD12, 0); + + return resp; +} + +u8 diskWriteSPI(u32 saddr, u8 *buff, u16 slen) { + + u8 resp; + u16 i; + + if (!(card_type & 1))saddr *= 512; + resp = diskCmdSPI(CMD25, saddr); + if (resp != 0)return DISK_ERR_WR1; + memSpiSSOn(); + + + while (slen--) { + + mem_spi(0xff); + mem_spi(0xff); + mem_spi(0xfc); + + + memSpiWrite(buff); + + mem_spi(0xff); + mem_spi(0xff); + resp = mem_spi(0xff); + //resp = mem_spi(0xff); + + buff += 512; + + + + if ((resp & 0x1f) != 0x05) { + memSpiSSOff(); + return DISK_ERR_WRX; + } + + + for (i = 0; i < 65535; i++) { + + if (mem_spi(0xff) == 0xff)break; + if (mem_spi(0xff) == 0xff)break; + if (mem_spi(0xff) == 0xff)break; + if (mem_spi(0xff) == 0xff)break; + } + + + if (i == 65535) { + memSpiSSOff(); + return DISK_ERR_WR2; + } + + } + + mem_spi(0xfd); + mem_spi(0xff); + + for (i = 0; i < 65535; i++) { + if ((mem_spi(0xff) & 1) != 0)break; + if ((mem_spi(0xff) & 1) != 0)break; + if ((mem_spi(0xff) & 1) != 0)break; + if ((mem_spi(0xff) & 1) != 0)break; + } + memSpiSSOff(); + if (i == 65535) return DISK_ERR_WR3; + + return 0; +} diff --git a/disk.h b/disk.h new file mode 100644 index 0000000..247a0d1 --- /dev/null +++ b/disk.h @@ -0,0 +1,29 @@ +/* + * File: disk.h + * Author: krik + * + * Created on 2 Èþíü 2011 ã., 4:07 + */ + +#ifndef _DISK_H +#define _DISK_H + +#include "types.h" + +u8 diskGetInterface(); +u8 diskInit(); +u8 diskRead(u32 saddr, void *buff, u16 slen); +u8 diskWrite(u32 saddr, u8 *buff, u16 slen); +void diskSetInterface(u32 interface); + + + +#define WAIT 1024 + +#define DISK_IFACE_SPI 0 +#define DISK_IFACE_SD 1 + + + +#endif /* _DISK_H */ + diff --git a/doc/functions.txt b/doc/functions.txt new file mode 100644 index 0000000..ad4bc78 --- /dev/null +++ b/doc/functions.txt @@ -0,0 +1,104 @@ +beta9 + +rom loading function flow: + +main() + +//init n64, fs, controller + + //joypad loop + //button (A) -> select rom + + + loadrom(disp,name_file); + //readout rom header + //check if swapped + evd_mmcSetDmaSwap(1); + + //dma read file to 0xb0000000 cartspace + diskRead(); + + //change key mapping + + //if (START) + bootRom(); + + //save LAST.CRT for reboot cart-save + + //set fpga to eeprom, sram, flashram + evd_setSaveType(boot_save); + + //do pif simulation to boot the rom + simulate_boot(boot_cic, bios_cic); + + + +cart-save overview: + +before pif simulation the cart_id and cart_savetype is stored in +LAST.CRT [maybe it's a better solution to use rom filenames +'cause the cart_id includes no game-version] +-> bootRom(); + +at every start of the menu a function is called that checks +LAST.CRT, if there is something todo and disable it for next boot +by setting a flag in that file +-> backupSaveData(disp); + +if it's a warm boot (reset) the fpga savegame is still there +-> save_cfg_stat = evd_readReg(REG_SAV_CFG); + +if it's a reset reboot to backup a savegame into a file +saveTypeToSd(disp, cartID, save_t) +is called + +it's only for some file operations and calls +utils.c: getSaveFromCart(stype, cartsave_data) +to store the savegame into a buffer, which could +be saved into a file + + +some notes: +eeprom is connected directly to the pif (i2c?) +and could be read out stable with the libdragon function + +sram/flashram is a serial device that is mapped into +memory +it has to be accessed with dma to rdram through the pif + +it's a domain2 device which needs other timing than the cart + +timings: + +PI_BSD_DOM2_XXX_REG + +sram/fram: + +val XXX desc +05 LAT Latency +OC PWD Pulse Width + +//sram - 0D +//fram Animal Forest - 0F +OD PGS Page Size + +02 RLS Release Duration + + +carts/dev-carts: +40 Latency +12 Pulse Width +07 Page Size +03 Release Duration + +IPL at 0xA6000000: +40 Latency +07 Pulse Width +07 Page Size +02 Release Duration + +cartidge: +PI_BSD_DOM1_XXX_REG + +is set with the first word in the header +e.g. 0x[80]371240 -> 3.7.12.40 ~ 40,12,07,03 diff --git a/errors.h b/errors.h new file mode 100644 index 0000000..1ce6d90 --- /dev/null +++ b/errors.h @@ -0,0 +1,70 @@ +/* + * File: errors.h + * Author: KRIK + * + * Created on 14 Ìàé 2011 ã., 7:17 + */ + +#ifndef _ERRORS_H +#define _ERRORS_H + + +#define EVD_ERROR_FIFO_TIMEOUT 90; +#define EVD_ERROR_MMC_TIMEOUT 91; + +#define BOOT_UPD_ERR_WRONG_SIZE 95 +#define BOOT_UPD_ERR_HDR 96 +#define BOOT_UPD_ERR_CMP 97 +#define BOOT_UPD_ERR_CIC_DTCT 98 + +#define FAT_ERR_NOT_EXIST 100 +#define FAT_ERR_EXIST 101 +#define FAT_ERR_NAME 102 +#define FAT_ERR_OUT_OF_FILE 103 +#define FAT_ERR_BAD_BASE_CLUSTER 104; +#define FAT_ERR_NO_FRE_SPACE 105 +#define FAT_ERR_NOT_FILE 106 +#define FAT_ERR_FILE_MODE 107 +#define FAT_ERR_ROT_OVERFLOW 108 +#define FAT_ERR_OUT_OF_TABLE 109 +#define FAT_ERR_INIT 110 +#define FAT_LFN_BUFF_OVERFLOW 111 +#define FAT_DISK_NOT_READY 112 +#define FAT_ERR_SIZE 113 +#define FAT_ERR_RESIZE 114 + +#define ERR_FILE8_TOO_BIG 140 +#define ERR_FILE16_TOO_BIG 141 +#define ERR_WRON_OS_SIZE 142 +#define ERR_OS_VERIFY 143 +#define ERR_OS_VERIFY2 144 +#define ERR_EMU_NOT_FOUND 145 +#define ERR_SAVE_FORMAT 146 +#define ERR_EEPROM 147 +#define ERR_NO_FAV_SPACE 150 + + + +#define DISK_ERR_INIT 50 + +#define DISK_ERR_RD1 62 +#define DISK_ERR_RD2 63 + +#define DISK_ERR_WR1 64 +#define DISK_ERR_WR2 65 +#define DISK_ERR_WR3 66 +#define DISK_ERR_WRX 67 +#define DISK_WR_SB_TOUT 68 +#define DISK_ERR_WR_CRC 69 + +#define DISK_RD_FE_TOUT 70 +#define DISK_ERR_CLOSE_RW1 71 +#define DISK_ERR_CLOSE_RW2 72 + +#define SD_CMD_TIMEOUT 75 +#define SD_CMD_CRC_ERROR 76 + +#define SD_INIT_ERROR 80 + +#endif /* _ERRORS_H */ + diff --git a/everdrive.c b/everdrive.c new file mode 100644 index 0000000..7b62c7c --- /dev/null +++ b/everdrive.c @@ -0,0 +1,596 @@ + +#include "types.h" +#include "everdrive.h" +#include +#include +#include "sys.h" +#include "errors.h" +//#include "rom.h" +#include "disk.h" + +#define CMD0 0x40 // software reset +#define CMD1 0x41 // brings card out of idle state +#define CMD2 0x42 // not used in SPI mode +#define CMD3 0x43 // not used in SPI mode +#define CMD4 0x44 // not used in SPI mode +#define CMD5 0x45 // Reserved +#define CMD6 0x46 // Reserved +#define CMD7 0x47 // not used in SPI mode +#define CMD8 0x48 // Reserved +#define CMD9 0x49 // ask card to send card speficic data (CSD) +#define CMD10 0x4A // ask card to send card identification (CID) +#define CMD11 0x4B // not used in SPI mode +#define CMD12 0x4C // stop transmission on multiple block read +#define CMD13 0x4D // ask the card to send it's status register +#define CMD14 0x4E // Reserved +#define CMD15 0x4F // not used in SPI mode +#define CMD16 0x50 // sets the block length used by the memory card +#define CMD17 0x51 // read single block +#define CMD18 0x52 // read multiple block +#define CMD19 0x53 // Reserved +#define CMD20 0x54 // not used in SPI mode +#define CMD21 0x55 // Reserved +#define CMD22 0x56 // Reserved +#define CMD23 0x57 // Reserved +#define CMD24 0x58 // writes a single block +#define CMD25 0x59 // writes multiple blocks +#define CMD26 0x5A // not used in SPI mode +#define CMD27 0x5B // change the bits in CSD +#define CMD28 0x5C // sets the write protection bit +#define CMD29 0x5D // clears the write protection bit +#define CMD30 0x5E // checks the write protection bit +#define CMD31 0x5F // Reserved +#define CMD32 0x60 // Sets the address of the first sector of the erase group +#define CMD33 0x61 // Sets the address of the last sector of the erase group +#define CMD34 0x62 // removes a sector from the selected group +#define CMD35 0x63 // Sets the address of the first group +#define CMD36 0x64 // Sets the address of the last erase group +#define CMD37 0x65 // removes a group from the selected section +#define CMD38 0x66 // erase all selected groups +#define CMD39 0x67 // not used in SPI mode +#define CMD40 0x68 // not used in SPI mode +#define CMD41 0x69 // Reserved +#define CMD42 0x6A // locks a block +// CMD43 ... CMD57 are Reserved +#define CMD58 0x7A // reads the OCR register +#define CMD59 0x7B // turns CRC off +// CMD60 ... CMD63 are not used in SPI mode + + + + + + +#define ED_STATE_DMA_BUSY 0 +#define ED_STATE_DMA_TOUT 1 +#define ED_STATE_TXE 2 +#define ED_STATE_RXF 3 +#define ED_STATE_SPI 4 + +#define SPI_CFG_SPD0 0 +#define SPI_CFG_SPD1 1 +#define SPI_CFG_SS 2 +#define SPI_CFG_RD 3 +#define SPI_CFG_DAT 4 +#define SPI_CFG_1BIT 5 + +#define SAV_EEP_ON 0 +#define SAV_SRM_ON 1 +#define SAV_EEP_SIZE 2 +#define SAV_SRM_SIZE 3 + +//was missing +//#define BI_SPI_SPD_LO 0 + +#define BI_SPI_SPD_LO 2 // around 200khz (only for sd initialization) +#define BI_SPI_SPD_25 1 +#define BI_SPI_SPD_50 0 + + +void evd_setSpiSpeed(u8 speed); +u8 evd_mmcCmd(u8 cmd, u32 arg); + +u8 sd_mode; +volatile u8 spi_cfg; +volatile u8 evd_cfg; +u8 sd_type; +volatile u32 *regs_ptr = (u32 *) 0xA8040000; + +/* +result[2] <= ad[15:8] == {ad[6], ad[1], ad[0], ad[7], ad[5], ad[4], ad[3], ad[2]} ^ 8'h37 ^ prv[7:0]; + prv[7:0] <= ad[15:8]; + */ +void (*dma_busy_callback)(); + + +void evd_setDmaAddr(u32 addr) { + +} + + +inline u32 bi_reg_rd(u32 reg) { + + *(vu32 *) (REGS_BASE); + return *(vu32 *) (REGS_BASE + reg * 4); +} + +inline void bi_reg_wr(u32 reg, u32 data) { + + *(vu32 *) (REGS_BASE); + *(vu32 *) (REGS_BASE + reg * 4) = data; +} + + +void bi_init() { + + evd_cfg = ED_CFG_SDRAM_ON; + spi_cfg = 0 | BI_SPI_SPD_LO; + bi_reg_wr(REG_KEY, 0x1234); + bi_reg_wr(REG_CFG, evd_cfg); + bi_reg_wr(REG_SPI_CFG, spi_cfg); +} + +void bi_speed50() { + + spi_cfg = 0 | BI_SPI_SPD_50; + bi_reg_wr(REG_KEY, 0x1234); + bi_reg_wr(REG_SPI_CFG, spi_cfg); +} + +void bi_speed25() { + + spi_cfg = 0 | BI_SPI_SPD_25; + bi_reg_wr(REG_KEY, 0x1234); + bi_reg_wr(REG_SPI_CFG, spi_cfg); +} + +void bi_load_firmware(u8 *firm) { + + u32 i; + u16 f_ctr = 0; + + + evd_cfg &= ~ED_CFG_SDRAM_ON; + bi_reg_wr(REG_CFG, evd_cfg); + + bi_reg_wr(REG_CFG_CNT, 0); + sleep(10); + bi_reg_wr(REG_CFG_CNT, 1); + sleep(10); + + i = 0; + for (;;) { + + bi_reg_wr(REG_CFG_DAT, *(u16 *) & firm[i]); + while ((bi_reg_rd(REG_CFG_CNT) & 8) != 0); + + f_ctr = firm[i++] == 0xff ? f_ctr + 1 : 0; + if (f_ctr >= 47)break; + f_ctr = firm[i++] == 0xff ? f_ctr + 1 : 0; + if (f_ctr >= 47)break; + } + + + while ((bi_reg_rd(REG_CFG_CNT) & 4) == 0) { + bi_reg_wr(REG_CFG_DAT, 0xffff); + while ((bi_reg_rd(REG_CFG_CNT) & 8) != 0); + } + + + sleep(20); + + bi_init(); +} + + +void evd_init() { + + volatile u8 val; + sd_mode = 0; + dma_busy_callback = 0; + + sleep(1); + val = regs_ptr[0]; + + spi_cfg = (0 << SPI_CFG_SPD0) | (1 << SPI_CFG_SPD1) | (1 << SPI_CFG_SS); + evd_cfg = (1 << ED_CFG_SDRAM_ON); + + val = regs_ptr[0]; + regs_ptr[REG_KEY] = 0x1234; + + val = regs_ptr[0]; + regs_ptr[REG_CFG] = evd_cfg; + val = regs_ptr[0]; + regs_ptr[REG_SPI_CFG] = spi_cfg; + + evd_fifoRxf(); + if (!evd_fifoRxf()) { + + val = regs_ptr[0]; + regs_ptr[REG_DMA_LEN] = 7; //clean 16k + val = regs_ptr[0]; + regs_ptr[REG_DMA_RAM_ADDR] = (ROM_LEN - 0x200000) / 2048; + val = regs_ptr[0]; + regs_ptr[REG_DMA_CFG] = DCFG_FIFO_TO_RAM; + while (evd_isDmaBusy()); + } + + +} +void evd_ulockRegs(){ + volatile u8 val; + val = regs_ptr[0]; + regs_ptr[REG_KEY] = 0x1234; +} + +void evd_lockRegs() { + volatile u8 val; + val = regs_ptr[0]; + regs_ptr[REG_KEY] = 0; +} + +u8 evd_fifoRxf() { + + u16 val; + //regs_ptr[REG_STATE]++; + val = regs_ptr[REG_STATUS]; + return (val >> ED_STATE_RXF) & 1; +} + +u8 evd_fifoTxe() { + + u16 val; + //regs_ptr[REG_STATE]++; + val = regs_ptr[REG_STATUS]; + return (val >> ED_STATE_TXE) & 1; +} + +u8 evd_isDmaBusy() { + + u16 val; + //volatile u32 i; + sleep(1); + if(dma_busy_callback != 0)dma_busy_callback(); + //regs_ptr[REG_STATE]++; + val = regs_ptr[REG_STATUS]; + return (val >> ED_STATE_DMA_BUSY) & 1; +} + +u8 evd_isDmaTimeout() { + + u16 val; + //regs_ptr[REG_STATE]++; + val = regs_ptr[REG_STATUS]; + + return (val >> ED_STATE_DMA_TOUT) & 1; +} + +u8 evd_fifoRdToCart(u32 cart_addr, u16 blocks) { + + volatile u8 val; + cart_addr /= 2048; + + + val = regs_ptr[0]; + regs_ptr[REG_DMA_LEN] = (blocks - 1); + val = regs_ptr[0]; + regs_ptr[REG_DMA_RAM_ADDR] = cart_addr; + val = regs_ptr[0]; + regs_ptr[REG_DMA_CFG] = DCFG_FIFO_TO_RAM; + + while (evd_isDmaBusy()); + if (evd_isDmaTimeout())return EVD_ERROR_FIFO_TIMEOUT; + + + return 0; +} + +u8 evd_fifoWrFromCart(u32 cart_addr, u16 blocks) { + + volatile u8 val; + cart_addr /= 2048; + + + val = regs_ptr[0]; + regs_ptr[REG_DMA_LEN] = (blocks - 1); + val = regs_ptr[0]; + regs_ptr[REG_DMA_RAM_ADDR] = cart_addr; + val = regs_ptr[0]; + regs_ptr[REG_DMA_CFG] = DCFG_RAM_TO_FIFO; + + while (evd_isDmaBusy()); + if (evd_isDmaTimeout())return EVD_ERROR_FIFO_TIMEOUT; + + return 0; +} + +u8 evd_fifoRd(void *buff, u16 blocks) { + + volatile u8 val; + u32 len = blocks == 0 ? 65536 * 512 : blocks * 512; + u32 ram_buff_addr = DMA_BUFF_ADDR / 2048; //(ROM_LEN - len - 65536 * 4) / 2048; + + + val = regs_ptr[0]; + regs_ptr[REG_DMA_LEN] = (blocks - 1); + val = regs_ptr[0]; + regs_ptr[REG_DMA_RAM_ADDR] = ram_buff_addr; + val = regs_ptr[0]; + regs_ptr[REG_DMA_CFG] = DCFG_FIFO_TO_RAM; + + while (evd_isDmaBusy()); + dma_read_s(buff, (0xb0000000 + ram_buff_addr * 2048), len); + if (evd_isDmaTimeout())return EVD_ERROR_FIFO_TIMEOUT; + + + + return 0; +} + + + +u8 evd_fifoWr(void *buff, u16 blocks) { + + volatile u8 val; + u32 len = blocks == 0 ? 65536 * 512 : blocks * 512; + u32 ram_buff_addr = DMA_BUFF_ADDR / 2048; //(ROM_LEN - len - 65536 * 4) / 2048; + + dma_write_s(buff, (0xb0000000 + ram_buff_addr * 1024 * 2), len); + + val = regs_ptr[0]; + regs_ptr[REG_DMA_LEN] = (blocks - 1); + val = regs_ptr[0]; + regs_ptr[REG_DMA_RAM_ADDR] = ram_buff_addr; + val = regs_ptr[0]; + regs_ptr[REG_DMA_CFG] = DCFG_RAM_TO_FIFO; + + while (evd_isDmaBusy()); + if (evd_isDmaTimeout())return EVD_ERROR_FIFO_TIMEOUT; + + return 0; +} + +u8 evd_isSpiBusy() { + + volatile u16 val; + regs_ptr[REG_STATUS]; + val = regs_ptr[REG_STATUS]; + return (val >> ED_STATE_SPI) & 1; +} + +u8 evd_SPI(u8 dat) { + + + volatile u8 val; + val = regs_ptr[0]; + regs_ptr[REG_SPI] = dat; + while (evd_isSpiBusy()); + //osInvalICache((u32*) & regs_ptr[REG_SPI], 1); + val = regs_ptr[REG_SPI]; + return val; + +} + +void evd_spiSSOn() { + + volatile u8 val; + if (sd_mode)return; + spi_cfg &= ~(1 << SPI_CFG_SS); + val = regs_ptr[0]; + regs_ptr[REG_SPI_CFG] = spi_cfg; + +} + +void evd_spiSSOff() { + + volatile u8 val; + spi_cfg |= (1 << SPI_CFG_SS); + val = regs_ptr[0]; + regs_ptr[REG_SPI_CFG] = spi_cfg; + +} + +void evd_enableSDMode() { + sd_mode = 1; +} + +void evd_enableSPIMode() { + sd_mode = 0; +} + +u8 evd_isSDMode() { + + return sd_mode; +} + +void evd_SDcmdWriteMode(u8 bit1_mode) { + + volatile u8 val; + if (!sd_mode)return; + spi_cfg &= ~((1 << SPI_CFG_RD) | (1 << SPI_CFG_DAT)); + if (bit1_mode) { + spi_cfg |= (1 << SPI_CFG_1BIT); + } else { + spi_cfg &= ~(1 << SPI_CFG_1BIT); + } + val = regs_ptr[0]; + regs_ptr[REG_SPI_CFG] = spi_cfg; + +} + +void evd_SDcmdReadMode(u8 bit1_mode) { + + + volatile u8 val; + if (!sd_mode)return; + spi_cfg |= (1 << SPI_CFG_RD); + spi_cfg &= ~(1 << SPI_CFG_DAT); + if (bit1_mode) { + spi_cfg |= (1 << SPI_CFG_1BIT); + } else { + spi_cfg &= ~(1 << SPI_CFG_1BIT); + } + val = regs_ptr[0]; + regs_ptr[REG_SPI_CFG] = spi_cfg; +} + +void evd_SDdatWriteMode(u8 bit4_mode) { + + + volatile u8 val; + if (!sd_mode)return; + spi_cfg &= ~(1 << SPI_CFG_RD); + spi_cfg |= (1 << SPI_CFG_DAT); + if (bit4_mode) { + spi_cfg |= (1 << SPI_CFG_1BIT); + } else { + spi_cfg &= ~(1 << SPI_CFG_1BIT); + } + val = regs_ptr[0]; + regs_ptr[REG_SPI_CFG] = spi_cfg; +} + +void evd_SDdatReadMode(u8 bit4_mode) { + + + volatile u8 val; + if (!sd_mode)return; + spi_cfg |= (1 << SPI_CFG_RD) | (1 << SPI_CFG_DAT); + if (bit4_mode) { + spi_cfg |= (1 << SPI_CFG_1BIT); + } else { + spi_cfg &= ~(1 << SPI_CFG_1BIT); + } + val = regs_ptr[0]; + regs_ptr[REG_SPI_CFG] = spi_cfg; +} + +void evd_setSpiSpeed(u8 speed) { + + + volatile u8 val; + spi_cfg &= ~3; //((1 << SPI_CFG_SPD0) | (1 << SPI_CFG_SPD1)); + spi_cfg |= speed & 3; + val = regs_ptr[0]; + regs_ptr[REG_SPI_CFG] = spi_cfg; + + +} + +u8 evd_mmcReadToCart(u32 cart_addr, u32 len) { + + volatile u8 val; + cart_addr /= 2048; + + + val = regs_ptr[0]; + regs_ptr[REG_DMA_LEN] = (len - 1); + val = regs_ptr[0]; + regs_ptr[REG_DMA_RAM_ADDR] = cart_addr; + val = regs_ptr[0]; + regs_ptr[REG_DMA_CFG] = DCFG_SD_TO_RAM; + + while (evd_isDmaBusy()); + if (evd_isDmaTimeout())return EVD_ERROR_MMC_TIMEOUT; + + return 0; +} + +void evd_setCfgBit(u8 option, u8 state) { + + volatile u8 val; + + if (state)evd_cfg |= (1 << option); + else + evd_cfg &= ~(1 << option); + + val = regs_ptr[0]; + regs_ptr[REG_CFG] = evd_cfg; + val = regs_ptr[0]; +} + +u16 evd_readReg(u8 reg) { + + volatile u32 tmp; + + tmp = regs_ptr[0]; + + return regs_ptr[reg]; +} + +void evd_setSaveType(u8 type) { + + + u8 eeprom_on, sram_on, eeprom_size, sram_size; + eeprom_on = 0; + sram_on = 0; + eeprom_size = 0; + sram_size = 0; + + switch (type) { + case SAVE_TYPE_EEP16k: + eeprom_on = 1; + eeprom_size = 1; + break; + case SAVE_TYPE_EEP4k: + eeprom_on = 1; + break; + case SAVE_TYPE_SRAM: + sram_on = 1; + break; + case SAVE_TYPE_SRAM128: + sram_on = 1; + sram_size = 1; + break; + case SAVE_TYPE_FLASH: + sram_on = 0; + sram_size = 1; + break; + default: + sram_on = 0; + sram_size = 0; + break; + } + + + volatile u8 val; + val = regs_ptr[0]; + regs_ptr[REG_SAV_CFG] = (eeprom_on << SAV_EEP_ON | sram_on << SAV_SRM_ON | eeprom_size << SAV_EEP_SIZE | sram_size << SAV_SRM_SIZE); + +} + +void evd_writeReg(u8 reg, u16 val) { + + volatile u8 tmp; + tmp = regs_ptr[0]; + regs_ptr[reg] = val; + +} + +void evd_mmcSetDmaSwap(u8 state) { + + evd_setCfgBit(ED_CFG_SWAP, state); +} + +void evd_writeMsg(u8 dat) { + + evd_writeReg(REG_MSG, dat); + +} + +u8 evd_readMsg() { + return evd_readReg(REG_MSG); +} + +u16 evd_getFirmVersion() { + + return evd_readReg(REG_VER); + +} + + +void evd_setDmaCallback(void (*callback)()) { + + + dma_busy_callback = callback; +} diff --git a/everdrive.h b/everdrive.h new file mode 100644 index 0000000..f3f0e31 --- /dev/null +++ b/everdrive.h @@ -0,0 +1,125 @@ +/* + * File: everdrive.h + * Author: KRIK + * + * Created on 22 Àïðåëü 2011 ã., 20:46 + */ + +#ifndef _EVERDRIVE_H +#define _EVERDRIVE_H + +#include "types.h" + +#define OS_VER "1.29" + +#define ROM_LEN 0x4000000 +#define ROM_ADDR 0xb0000000 +#define ROM_END_ADDR (0xb0000000 + 0x4000000) + + +#define SAVE_TYPE_OFF 0 +#define SAVE_TYPE_SRAM 1 +#define SAVE_TYPE_SRAM128 2 +#define SAVE_TYPE_EEP4k 3 +#define SAVE_TYPE_EEP16k 4 +#define SAVE_TYPE_FLASH 5 + +#define DMA_BUFF_ADDR (ROM_LEN - 0x100000) + +#define REG_CFG 0 +#define REG_STATUS 1 +#define REG_DMA_LEN 2 +#define REG_DMA_RAM_ADDR 3 +#define REG_MSG 4 +#define REG_DMA_CFG 5 +#define REG_SPI 6 +#define REG_SPI_CFG 7 +#define REG_KEY 8 +#define REG_SAV_CFG 9 +#define REG_SEC 10 +#define REG_VER 11 + + +#define REG_CFG_CNT 16 +#define REG_CFG_DAT 17 +#define REG_MAX_MSG 18 +#define REG_CRC 19 + + +#define DCFG_SD_TO_RAM 1 +#define DCFG_RAM_TO_SD 2 +#define DCFG_FIFO_TO_RAM 3 +#define DCFG_RAM_TO_FIFO 4 + +#define ED_CFG_SDRAM_ON 0 +#define ED_CFG_SWAP 1 +#define ED_CFG_WR_MOD 2 +#define ED_CFG_WR_ADDR_MASK 3 + +//new firmware load +#define REGS_BASE 0xA8040000 +//-- + +void evd_setCfgBit(u8 option, u8 state); + +void evd_init(); +u8 evd_fifoRxf(); +u8 evd_fifoTxe(); +u8 evd_isDmaBusy(); +u8 evd_isDmaTimeout(); +u8 evd_fifoRd(void *buff, u16 blocks); +u8 evd_fifoWr(void *buff, u16 blocks); +u8 evd_fifoRdToCart(u32 cart_addr, u16 blocks); +u8 evd_fifoWrFromCart(u32 cart_addr, u16 blocks); + +u8 evd_SPI(u8 dat); +void evd_mmcSetDmaSwap(u8 state); +u8 evd_mmcReadToCart(u32 cart_addr, u32 len); + +void evd_lockRegs(); +u16 evd_readReg(u8 reg); +void evd_writeReg(u8 reg, u16 val); +void evd_setSaveType(u8 type); + + +u8 romLoadSettingsFromSD(); +u8 romSaveInfoToLog(); +void evd_writeMsg(u8 dat); +u8 evd_readMsg(); +u16 evd_getFirmVersion(); + +void evd_spiSSOn(); +void evd_spiSSOff(); +u8 evd_isSpiBusy(); +void evd_setSpiSpeed(u8 speed); + +void evd_SDcmdWriteMode(u8 bit1_mode); +void evd_SDcmdReadMode(u8 bit1_mode); +void evd_SDdatWriteMode(u8 bit4_mode); +void evd_SDdatReadMode(u8 bit4_mode); +void evd_enableSDMode(); +void evd_enableSPIMode(); +u8 evd_isSDMode(); +void evd_setDmaCallback(void (*callback)()); + + +//firmware upload +extern u32 bi_reg_rd(u32 reg); +extern void bi_reg_wr(u32 reg, u32 data); +void bi_init(); +void bi_load_firmware(u8 *firm); +void bi_speed25(); +void bi_speed50(); + +/* +u8 evd_mmcWriteNextBlock(void *dat); +u8 evd_mmcOpenWrite(u32 addr); +u8 evd_mmcWriteBlock(void *dat, u32 addr); +u8 evd_mmcInit(); +u8 evd_mmcReadBlock(void *dat, u32 addr); +u8 evd_mmcOpenRead(u32 addr); +u8 evd_mmcReadNextBlock(void *dat); +void evd_mmcCloseRW(); + */ +#endif /* _EVERDRIVE_H */ + diff --git a/fat.c b/fat.c new file mode 100644 index 0000000..d01ee1c --- /dev/null +++ b/fat.c @@ -0,0 +1,1931 @@ + + +#include +#include + +#include "fat.h" +#include "disk.h" +#include "mem.h" +#include "everdrive.h" +#include "sys.h" +#include + + + + + + + + + + +//FatRecordHdr rec_hdr; + + + + +u8 fatLoadLfnPart(u8 *name_ptr, u8 *lfn_buff); +u8 fatCacheLoadTable(u32 sector, u8 save_before_load); +u8 fatCacheLoadData(u32 sector, u8 save_befor_load); + +u8 fatGetNextCluster(u32 *cluster); +u8 fatGetTableRecord(u32 cluster, u32 *val); +u8 fatSetTableRecord(u32 cluster, u32 next_cluster); +u8 fatCacheApplyTable(); +u8 fatGetFreeRecord(FatRecord *dir_rec, u8 len); +void fatMakeLfnBlock(u8 *name, u8 *lfn_block, u8 block_idx, u8 crc); +u32 fatSectorToCluster(u32 sector); +void strhicase(u8 *str, u8 len); +u8 fatClearClusters(u32 cluster, u8 len); + +u8 fatReadCluster(void *dst); +u8 fatOccupyClusters(u32 *base_cluster, u16 len); +void fatOpenDir(u32 cluster); +u8 fatReadDir(FatRecord *rec, u16 max_name_len); +u32 fatClusterToSector(u32 cluster); +u8 fatInitRoot(); +u8 fatSkipCluster(); +//u8 fatReadMultiClustes(void *dst, u32 max_sectors, u32 *readrd_sectors); +u8 fatMultiClustRW(void *buff, u32 max_sectors, u32 *readrd_sectors, u16 write); +u8 fatResizeFile(FatRecord *rec, u32 req_sec_size); + +Dir *dir; +Fat current_fat; +File file; +FatCache *fat_cache; +u16 kot; +u32 *occupy_buff; +vu16 table_changed; + +//FatRecord *rec_tmp; +//#define CACHE_SIZE 16 + +void fatInitRam() { + + u16 i; + //rec_tmp = malloc() + dir = malloc(sizeof (Dir)); + + for (i = 0; i < FAT_MAX_DIR_SIZE; i++) { + dir->rec[i] = malloc(sizeof (FatRecord)); + } + + dir->path = malloc(1024); + + fat_cache = malloc(sizeof (FatCache)); + + fat_cache->data_sector = malloc(512); + fat_cache->table_sector = malloc(512); + + occupy_buff = malloc(16384); + + // current_cache->table_frame = current_cache->table_buff; + + //cache = &ch; +} + + +u8 fatInitRoot() { + + // u8 resp = 0; + + // resp = fatCreateRecIfNotExist(ED_ROOT, 1); + // if (resp)return resp; + +// resp = fatCreateRecIfNotExist(ED_SAVE, 1); + // if (resp)return resp; + + // resp = fatCreateRecIfNotExist(ED_ROM_CFG, 0); + // if (resp)return resp; + + return 0; +} + +/* +u8 fatInitRoot() { + + u8 resp = 0; + + resp = fatCreateRecIfNotExist(ED_ROOT, 1); + if (resp)return resp; + resp = fatCreateRecIfNotExist(ED_SAVE, 1); + if (resp)return resp; + resp = fatCreateRecIfNotExist(ED_ROM_CFG, 0); + if (resp)return resp; + resp = fatCreateRecIfNotExist(ED_OPTIONS, 0); + if (resp)return resp; + + return 0; +}*/ + +u8 fatGetFullName(u8 *name, u32 dir_entry, u32 rec_entry) { + + u16 i; + u8 resp; + FatRecord rec_tmp; + fatOpenDir(dir_entry); + for (;;) { + + resp = fatReadDir(&rec_tmp, FAT_MAX_NAME_LEN_S); + if (resp)return resp; + if (rec_tmp.name[0] == 0)return FAT_ERR_NOT_EXIST; + if (rec_entry == rec_tmp.entry_cluster) { + for (i = 0; i < FAT_MAX_NAME_LEN_S; i++) { + *name++ = rec_tmp.name[i]; + if (rec_tmp.name[i] == 0)return 0; + } + } + + } + + return 0; +} + +u8 fatCreateRecIfNotExist(u8 *name, u8 is_dir) { + + u8 resp; + FatRecord rec_tmp; + resp = fatFindRecord(name, &rec_tmp, is_dir); + if (resp == FAT_ERR_NOT_EXIST) { + resp = fatCreateRecord(name, is_dir, 0); + if (resp)return resp; + } else + if (resp)return resp; + + return 0; +} + +u8 fatInit() { + + + u8 resp; + + u32 reserved_sectors; + resp = diskInit(); + if (resp)return resp; + fat_cache->data_sec_idx = 0xffffffff; + fat_cache->table_sec_idx = 0xffffffff; + current_fat.pbr_entry = 0; + table_changed = 0; + //rec_tmp.name = rec_tmp_name; + + //for (i = 0; i < FAT_MAX_DIR_SIZE; i++)dir.rec[i].name = (u8 *) & rec_names[i * (FAT_MAX_NAME_LEN + 4) / 4]; + //for (i = 0; i < sizeof (rec_names); i++)((u8 *) rec_names)[i] = 0; + resp = fatCacheLoadData(current_fat.pbr_entry, 0); + if (resp)return resp; + fatCacheLoadData(0, 0); + + + if (!streql("FAT16", &fat_cache->data_sector[0x36], 5) && !streql("FAT32", &fat_cache->data_sector[0x52], 5)) { + + current_fat.pbr_entry = (u32) fat_cache->data_sector[0x1c6] | (u32) fat_cache->data_sector[0x1c7] << 8 | (u32) fat_cache->data_sector[0x1c8] << 16 | (u32) fat_cache->data_sector[0x1c9] << 24; + resp = fatCacheLoadData(current_fat.pbr_entry, 0); + //console_printf("dat: %s\n", &cache->buff[0x36]); + if (resp)return resp; + if (!streql("FAT16", &fat_cache->data_sector[0x36], 5) && !streql("FAT32", &fat_cache->data_sector[0x52], 5)) { + return FAT_ERR_INIT; + } + } + + + if (streql("FAT16", &fat_cache->data_sector[0x36], 5)) { + current_fat.type = FAT_TYPE_16; + current_fat.sectors_per_fat = (u32) fat_cache->data_sector[0x16] | (u32) fat_cache->data_sector[0x17] << 8; + } else { + current_fat.type = FAT_TYPE_32; + current_fat.sectors_per_fat = (u32) fat_cache->data_sector[0x24] | (u32) fat_cache->data_sector[0x25] << 8 | (u32) fat_cache->data_sector[0x26] << 16 | (u32) fat_cache->data_sector[0x27] << 24; + } + reserved_sectors = (u32) fat_cache->data_sector[0x0e] | (u32) fat_cache->data_sector[0x0f] << 8; + + current_fat.cluster_size = fat_cache->data_sector[0x0d]; + current_fat.root_entry = current_fat.sectors_per_fat * 2 + current_fat.pbr_entry + reserved_sectors; + current_fat.fat_entry = current_fat.pbr_entry + reserved_sectors; + current_fat.data_entry = current_fat.root_entry; + if (current_fat.type == FAT_TYPE_16) { + current_fat.data_entry += 16384 / 512; + } + current_fat.cluster_byte_size = current_fat.cluster_size * 512; + + //fatCacheLoadBuff(fat.root_entry, 0); + //VDP_drawText(APLAN, &cache->buff[0], 0, 2, 20); + + //resp = fatCacheLoadTable(0, 0); + //if (resp)return resp; + + //debug + resp = fatInitRoot(); + if (resp)return resp; + + return 0; +} + +u8 fatOpenDirByName(u8 *name) { + + u8 resp; + FatRecord rec_tmp; + resp = fatFindRecord(name, &rec_tmp, 1); + if (resp)return resp; + fatOpenDir(rec_tmp.entry_cluster); + return 0; +} + +void fatOpenDir(u32 cluster) { + + + if (cluster == 0) { + dir->entry_sector = current_fat.root_entry; + dir->is_root = 1; + if (current_fat.type == FAT_TYPE_32)cluster = 2; + } else { + dir->entry_sector = fatClusterToSector(cluster); + dir->is_root = 0; + } + + dir->entry_cluster = cluster; + dir->current_cluster = cluster; + dir->in_cluster_ptr = 0; + +} + +u8 fatLoadDirByName(u8 *name) { + + u8 resp; + + if (streq(name, "/")) { + fatOpenDir(0); + resp = fatLoadDir(dir->entry_cluster); + if (resp)return resp; + } else { + resp = fatOpenDirByName(name); + if (resp)return resp; + resp = fatLoadDir(dir->entry_cluster); + if (resp)return resp; + } + + + + return 0; +} + +u8 fatLoadDir(u32 cluster) { + + u8 resp; + + fatOpenDir(cluster); + + for (dir->size = 0; dir->size < FAT_MAX_DIR_SIZE; dir->size++) { + + resp = fatReadDir(dir->rec[dir->size], FAT_MAX_NAME_LEN); + if (resp)return resp; + if (dir->rec[dir->size]->name[0] == 0)break; + } + + fatSortRecords(); + return 0; +} + +void fatSortRecords() { + + + FatRecord *rec_buff; + s32 i; + u8 flag0; + u8 flag1; + u64 name0; + u64 name1; + u32 u; + + // VDP_drawText(APLAN, "1", 0, 2, cy++); + for (i = 0; i < dir->size; i++) { + dir->s_records[i] = dir->rec[i]; + } + + s32 stop, swap, limit; + s32 x = (s32) (dir->size / 2) - 1; + while (x > 0) { + stop = 0; + limit = dir->size - x; + while (stop == 0) { + swap = 0; + for (i = 0; i < limit; i++) { + + name0 = 0; + name1 = 0; + for (u = 0; u < 8; u++) { + name0 <<= 8; + name1 <<= 8; + name0 |= dir->s_records[i]->name[u]; + name1 |= dir->s_records[i + x]->name[u]; + } + + name0 |= 0x2020202020202020; + name1 |= 0x2020202020202020; + if (name0 > name1) { + + rec_buff = dir->s_records[i]; + dir->s_records[i] = dir->s_records[i + x]; + dir->s_records[i + x] = rec_buff; + swap = i; + + } + } + limit = swap - x; + if (swap == 0) + stop = 1; + } + x = (int) (x / 2); + } + + //VDP_drawText(APLAN, "2", 0, 2, cy++); + /* + for (i = 1; i < dir->size;) { + + name0 = 0; + name1 = 0; + for (u = 0; u < 8; u++) { + name0 <<= 8; + name1 <<= 8; + name0 |= dir->s_records[i - 1]->name[u]; + name1 |= dir->s_records[i]->name[u]; + } + // name0 = *((u64 *) dir->s_records[i - 1]->name); + //VDP_drawText(APLAN, "--", 0, 2, cy++); + //name1 = *((u64 *) dir->s_records[i]->name); + + if ((name1 | 0x2020202020202020) < (name0 | 0x2020202020202020)) { + + rec_buff = dir->s_records[i]; + dir->s_records[i] = dir->s_records[i - 1]; + dir->s_records[i - 1] = rec_buff; + if (i > 1)i--; + + } else { + i++; + } + } + */ + + // VDP_drawText(APLAN, "3", 0, 2, cy++); + + for (i = 1; i < dir->size;) { + + flag0 = dir->s_records[i - 1]->is_dir; + flag1 = dir->s_records[i]->is_dir; + + if (flag1 && !flag0) { + rec_buff = dir->s_records[i]; + dir->s_records[i] = dir->s_records[i - 1]; + dir->s_records[i - 1] = rec_buff; + if (i > 1)i--; + } else { + i++; + } + } + //VDP_drawText(APLAN, "4", 0, 2, cy++); + +} + +u8 fatReadDir(FatRecord *rec, u16 max_name_len) { + + u16 lfn_len = 0; + u16 in_sector_ptr = 0; + u32 current_sector = 0; + u16 i = 0; + u8 *ptr = 0; + u8 resp; + u32 base_sector; // = dir.entry_sector == dir.is_root ? fat.root_entry : fatClusterToSector(dir.current_cluster); + u8 lfn_buff[FAT_MAX_NAME_LEN_S]; + + //u8 attr; + // u8 attrib; + + //cache->buff_sector = ~0; + rec->is_dir = 0; + rec->entry_cluster = 0; + rec->size = 0; + rec->name[0] = 0; + + if (current_fat.type == FAT_TYPE_16 && dir->is_root) { + base_sector = current_fat.root_entry; + } else { + base_sector = fatClusterToSector(dir->current_cluster); + } + + for (;;) { + + current_sector = base_sector + dir->in_cluster_ptr / 512; + + if (dir->is_root && current_fat.type == FAT_TYPE_16 && dir->in_cluster_ptr >= 16384) { + + return 0; + } + + if (dir->in_cluster_ptr >= current_fat.cluster_byte_size && (!dir->is_root || current_fat.type == FAT_TYPE_32)) { + + //return 0; + //if(dir->current_cluster == 0)dir->current_cluster = 2; + resp = fatGetNextCluster(&dir->current_cluster); + if (resp)return resp; + if (dir->current_cluster == 0) return 0; + base_sector = fatClusterToSector(dir->current_cluster); + current_sector = base_sector; // + dir->in_cluster_ptr / 512; + dir->in_cluster_ptr = 0; + } + + in_sector_ptr = dir->in_cluster_ptr & 511; + resp = fatCacheLoadData(current_sector, 0); + if (resp)return resp; + + if (fat_cache->data_sector[in_sector_ptr] == 0) { + + rec->is_dir = 0; + rec->entry_cluster = 0; + rec->size = 0; + rec->name[0] = 0; + return 0; + //dir->in_cluster_ptr += 32; + // continue; + } + if (fat_cache->data_sector[in_sector_ptr] == 0xe5 || fat_cache->data_sector[in_sector_ptr] == 0x2e || fat_cache->data_sector[in_sector_ptr] == '.') { + dir->in_cluster_ptr += 32; + continue; + } + + if (fat_cache->data_sector[in_sector_ptr + 0x0b] == 0x0f) { + + i = (fat_cache->data_sector[in_sector_ptr] & 0x0f); + + if (i * 13 >= sizeof (lfn_buff) || i == 0) { + dir->in_cluster_ptr += 32; //i * 32; //cache.buff[in_sector_ptr] * 32; + lfn_len = 0; + //VDP_drawText(APLAN, "xxx", 0, 20, 8); + } else { + + //while (i--) { + + resp = fatLoadLfnPart(&fat_cache->data_sector[in_sector_ptr], lfn_buff); + if (resp)return resp; + + dir->in_cluster_ptr += 32; + in_sector_ptr = dir->in_cluster_ptr & 511; + current_sector = base_sector + dir->in_cluster_ptr / 512; + resp = fatCacheLoadData(current_sector, 0); + if (resp)return resp; + lfn_len += 13; + //} + + } + + } else { + + if (lfn_len == 0) { + ptr = &fat_cache->data_sector[in_sector_ptr]; + for (i = 0; i < 8; i++)rec->name[i] = *ptr++; + + for (i = 7; rec->name[i] == ' '; i--) { + rec->name[i] = 0; + if (i == 0)break; + } + i++; + + rec->name[i] = 0; + + if (ptr[0] != ' ' || ptr[1] != ' ' || ptr[2] != ' ') { + rec->name[i++] = '.'; + rec->name[i++] = *ptr++; + rec->name[i++] = *ptr++; + rec->name[i++] = *ptr++; + rec->name[i] = 0; + } + + } else { + + if (lfn_buff[0] == '.') { + lfn_buff[0] = 0; + dir->in_cluster_ptr += 32; //i * 32; //cache.buff[in_sector_ptr] * 32; + lfn_len = 0; + continue; + } + + ptr = lfn_buff; + if (lfn_len > max_name_len)lfn_len = max_name_len; + for (i = 0; i < lfn_len; i++)rec->name[i] = *ptr++; + rec->name[i] = 0; + } + + lfn_len = 0; + ptr = &fat_cache->data_sector[in_sector_ptr]; + rec->is_dir = (ptr[0x0b] & 0x10) == 0x10 ? 1 : 0; + rec->entry_cluster = (u32) ptr[0x1a] | (u32) ptr[0x1b] << 8 | (u32) ptr[0x14] << 16 | (u32) ptr[0x15] << 24; + rec->size = (u32) ptr[0x1c] | (u32) ptr[0x1d] << 8 | (u32) ptr[0x1e] << 16 | (u32) ptr[0x1f] << 24; + rec->hdr_idx = (dir->in_cluster_ptr & 511) / 32; + rec->hdr_sector = current_sector; + + dir->in_cluster_ptr += 32; + + return 0; + /* + } else { + + dir->in_cluster_ptr += 32; + }*/ + } + } + + + return 1; +} + +u8 fatLoadLfnPart(u8 *buff_ptr, u8 *lfn_buff) { + + u8 i; + u8 offset = ((*buff_ptr & 0x0f) - 1) * 13; + u8 *lfn_ptr = &lfn_buff[offset]; + + if (offset + 13 >= FAT_MAX_NAME_LEN_S)return FAT_LFN_BUFF_OVERFLOW; + + buff_ptr++; + for (i = 0; i < 5; i++) { + *lfn_ptr++ = *buff_ptr++; + buff_ptr++; + } + + buff_ptr += 3; + + + for (i = 0; i < 6; i++) { + + *lfn_ptr++ = *buff_ptr++; + buff_ptr++; + } + + buff_ptr += 2; + + *lfn_ptr++ = *buff_ptr++; + buff_ptr++; + *lfn_ptr++ = *buff_ptr++; + + return 0; +} + +u8 fatCacheLoadData(u32 sector, u8 save_befor_load) { + + u8 resp; + //if(cache->grobovik != 333)console_printf("b: %u\n", cache->grobovik); + //console_printf("a: %u\n", cache->buff_sector); + if (fat_cache->data_sec_idx == sector)return 0; + + if (save_befor_load) { + resp = diskWrite(fat_cache->data_sec_idx, fat_cache->data_sector, 1); + } + fat_cache->data_sec_idx = sector; + + //addr=addr*512, buff, lenght 1 + resp = diskRead(fat_cache->data_sec_idx, fat_cache->data_sector, 1); + + //console_printf("c: %u\n", cache->buff_sector); + //joyWait(); + + return resp; + +} + +u8 fatCacheSaveData() { + + return diskWrite(fat_cache->data_sec_idx, fat_cache->data_sector, 1); +} + +u8 fatCacheLoadTable(u32 sector, u8 save_before_load) { + + + u8 resp; + sector += current_fat.fat_entry; + if (fat_cache->table_sec_idx == sector)return 0; + if (save_before_load) { + resp = fatCacheApplyTable(); + if (resp)return resp; + } + + fat_cache->table_sec_idx = sector; + + resp = diskRead(fat_cache->table_sec_idx, fat_cache->table_sector, 1); + + return resp; + +} + +u8 fatCacheApplyTable() { + + u8 resp; + + resp = diskWrite(fat_cache->table_sec_idx, fat_cache->table_sector, 1); + if (resp)return resp; + resp = diskWrite(fat_cache->table_sec_idx + current_fat.sectors_per_fat, fat_cache->table_sector, 1); + + table_changed = 0; + return resp; +} + +u32 fatClusterToSector(u32 cluster) { + + return (cluster - 2) * current_fat.cluster_size + current_fat.data_entry; +} + +u32 fatSectorToCluster(u32 sector) { + + return current_fat.data_entry + sector / current_fat.cluster_size + 2; +} + +u8 fatGetNextCluster(u32 *cluster) { + + u8 resp; + + + resp = fatGetTableRecord(*cluster, cluster); + if (resp)return resp; + + if (current_fat.type == FAT_TYPE_16) { + if (*cluster == 0xffff) { + *cluster = 0; + } + } else { + if (*cluster == 0x0FFFFFFF) { + + *cluster = 0; + } + } + return 0; + +} + +u8 fatOpenFileByeName(u8 *name, u32 wr_sectors) { + + //u16 i; + u8 resp; + FatRecord rec; + //rec.name = fat_name; + + + resp = fatFindRecord(name, &rec, 0); + if (resp)return resp; + if (rec.is_dir)return FAT_ERR_NOT_FILE; + resp = fatOpenFile(&rec, wr_sectors); + if (resp)return resp; + + return 0; +} + +u8 fatFindRecord(u8 *name, FatRecord *rec, u8 is_dir) { + + u8 resp; + u8 *sub_name_ptr; + u8 sub_name[FAT_MAX_NAME_LEN_S]; + u8 name_len; + //u8 cy = 2; + //u16 i; + + + + rec->entry_cluster = 0; + + for (;;) { + + if (*name == '/')name++; + sub_name_ptr = sub_name; + name_len = 0; + while (*name != 0 && *name != '/') { + *sub_name_ptr++ = *name++; + name_len++; + } + + *sub_name_ptr = 0; + + //for (i = 0; sub_name[i] != 0; i++)if (sub_name[i] == ' ')sub_name[i] = '*'; + //VDP_drawText(APLAN, sub_name, 0, 20, cy++); + fatOpenDir(rec->entry_cluster); + for (;;) { + + + resp = fatReadDir(rec, FAT_MAX_NAME_LEN_S); + //VDP_drawText(APLAN, rec->name, 0, 20, cy++); + if (resp)return resp; + if (rec->name[0] == 0) { + return FAT_ERR_NOT_EXIST; + } + + + + if (streq(sub_name, rec->name)) { + + if (*name != 0)break; + if (*name == 0 && ((is_dir && rec->is_dir) || (!is_dir && !rec->is_dir)))break; + } + } + //& ((is_dir && rec->is_dir) || (!is_dir && !rec->is_dir)) + + if (*name == 0) { + //VDP_drawText(APLAN, "record found+++++", 0, 20, cy++); + //VDP_drawText(APLAN, sub_name, 0, 20, cy++); + + return 0; + } + + } + + return 0; + +} + +//FatRecordHdr hdr; + +/* +void fatGetNameExt(u8 *filename, u8 *name, u8 *ext){ + +} + */ + + +void fatSetClustVal(FatRecordHdr *hdr, u32 clust_val) { + + ((u8 *) & hdr->cluster_lo)[0] = (u32) clust_val & 0xff; + ((u8 *) & hdr->cluster_lo)[1] = (u32) clust_val >> 8; + //hdr.cluster_lo = cluster & 0xffff; + if (current_fat.type == FAT_TYPE_32) { + ((u8 *) & hdr->cluster_hi)[0] = (u32) clust_val >> 16; + ((u8 *) & hdr->cluster_hi)[1] = (u32) clust_val >> 24; + } + +} + + +#define fatSlen slen +#define fatStrHiCase strhicase + +u8 fatCreateRecord(u8 *name, u8 is_dir, u8 check_exist) { + + //u8 cy = 10; + u16 i; + FatRecordHdr hdr; + FatRecord rec; + u8 patch[256]; + u8 *file_name; + u8 *ptr; + u8 lfn_blocks = 0; + u8 resp; + u8 sum = 0; + u8 nam_len; + u8 ext_len; + u32 cluster; + u8 lfn_block[32]; + u32 sub_dir_cluster = 0; + + //rec.name = rec_name; + fat_cache->data_sec_idx = ~0; + + if (*name != '/')return FAT_ERR_NAME; + if (fatSlen(name) < 2)return FAT_ERR_NAME; + i = fatSlen(name) - 1; + if (name[i] == '.' || name[i] == ' ')return FAT_ERR_NAME; + + + if (check_exist) { + resp = fatFindRecord(name, &rec, is_dir); + if (resp != FAT_ERR_NOT_EXIST) { + if (resp)return resp; + return FAT_ERR_EXIST; + } + } + + + + memfill(&hdr, 0, 32); + + + ptr = &name[fatSlen(name)]; + + i = 0; + while (*ptr != '/')ptr--; + + i = 0; + while (name != ptr)patch[i++] = *name++; + patch[i] = 0; + + ptr++; + file_name = ptr; + //i = 0; + //while (*ptr != 0)file_name[i++] = *ptr++; + //file_name[i] = 0; + + + + if (fatSlen(file_name) < 1)return FAT_ERR_NAME; + + + i = fatSlen(file_name); + while (i != 0 && file_name[i] != '.')i--; + if (i == 0)i = fatSlen(file_name); + nam_len = i; + ext_len = fatSlen(file_name); + if (ext_len == nam_len) { + ext_len = 0; + } else { + ext_len -= (nam_len + 1); + } + + + + if (nam_len > 8 || ext_len > 3) { + + lfn_blocks = fatSlen(file_name); + if (lfn_blocks % 13 != 0)lfn_blocks += 13; + lfn_blocks /= 13; + for (i = 0; i < 8; i++)hdr.name[i] = file_name[i]; + } else { + for (i = 0; i < 8 && file_name[i] != 0 && file_name[i] != '.'; i++)hdr.name[i] = file_name[i]; + for (; i < 8; i++)hdr.name[i] = ' '; + } + //VDP_drawText(APLAN, file_name, 0, 2, cy++); + + ptr = 0; + if (ext_len != 0)ptr = &file_name[nam_len + 1]; + + + if (ptr != 0) { + hdr.ext[0] = *ptr == 0 ? 0x20 : *ptr++; + hdr.ext[1] = *ptr == 0 ? 0x20 : *ptr++; + hdr.ext[2] = *ptr == 0 ? 0x20 : *ptr++; + } else { + for (i = 0; i < 3; i++)hdr.ext[i] = ' '; + } + fatStrHiCase(hdr.name, 8); + fatStrHiCase(hdr.ext, 3); + hdr.attrib = is_dir ? 0x10 : 0x20; + + + + + if (patch[0] != 0) { + resp = fatFindRecord(patch, &rec, 1); + sub_dir_cluster = rec.entry_cluster; + //if (resp == FAT_ERR_NOT_EXIST)VDP_drawText(APLAN, "cant find patch", 0, 2, cy++); + if (resp)return resp; + } else { + rec.entry_cluster = 0; + } + + + resp = fatGetFreeRecord(&rec, lfn_blocks + 1); + if (resp)return resp; + + //rec.hdr_sector = fat->root_entry; + //rec.hdr_idx + + + resp = fatCacheLoadData(rec.hdr_sector,0); + if (resp)return resp; + + if (lfn_blocks != 0) { + + hdr.name[7] = '1'; + hdr.name[6] = '~'; + hdr.name[5] = (rec.hdr_idx + rec.hdr_sector / 32) & 15; + hdr.name[4] = ((rec.hdr_idx + rec.hdr_sector / 32) >> 4) & 15; + hdr.name[5] += hdr.name[5] <= 10 ? 48 : 55; + hdr.name[4] += hdr.name[4] <= 10 ? 48 : 55; + for (sum = i = 0; i < 11; i++) { + if (i < 8) { + sum = (((sum & 1) << 7) | ((sum & 0xfe) >> 1)) + hdr.name[i]; + } else { + sum = (((sum & 1) << 7) | ((sum & 0xfe) >> 1)) + hdr.ext[i - 8]; + } + } + } + + for (i = 0; i < lfn_blocks; i++) { + + fatMakeLfnBlock(file_name, lfn_block, lfn_blocks - i - 1, sum); + if (i == 0)lfn_block[0] |= 0x40; + memcopy(lfn_block, &fat_cache->data_sector[rec.hdr_idx * 32], 32); + rec.hdr_idx++; + if (rec.hdr_idx == 16) { + rec.hdr_sector++; + rec.hdr_idx = 0; + resp = fatCacheSaveData(); + if (resp)return resp; + //resp = fatCacheLoadData(rec.hdr_sector); + resp = fatCacheLoadData(rec.hdr_sector, 0); + if (resp)return resp; + } + } + /* + if (lfn_blocks != 0) { + resp = diskWriteSector(cache->buff_sector, cache->buff); + if (resp)return resp; + } + */ + + if (is_dir) { + + //ocuppy function may destroy cache buff data + if (lfn_blocks != 0) { + resp = diskWrite(fat_cache->data_sec_idx, fat_cache->data_sector, 1); + if (resp)return resp; + } + cluster = 0; + resp = fatOccupyClusters(&cluster, 1); + if (resp)return resp; + + fatSetClustVal(&hdr, cluster); + + fat_cache->data_sec_idx = ~0; + resp = fatCacheLoadData(rec.hdr_sector, 0); + if (resp)return resp; + } + + hdr.date = 0x5d11; + hdr.time = 0; + + memcopy(&hdr, &fat_cache->data_sector[rec.hdr_idx * 32], 32); + + //resp = diskWriteSector(current_cache->data_sec_idx, current_cache->data_sector); + resp = fatCacheSaveData(); + if (resp)return resp; + + + + if (is_dir) { + + u32 sector = fatClusterToSector(cluster); + resp = fatClearClusters(cluster, 1); + if (resp)return resp; + + resp = fatCacheLoadData(sector, 0); + if (resp)return resp; + + memfill(&hdr, 0, 32); + //memcopy((void *)rawData, &hdr, 32); + hdr.attrib = 0x10; + ptr = (u8 *) & hdr; + for (i = 0; i < 11; i++)ptr[i] = 0x20; + ptr[0] = 0x2e; + + fatSetClustVal(&hdr, cluster); + + memcopy(&hdr, fat_cache->data_sector, 32); + + fatSetClustVal(&hdr, sub_dir_cluster); + ptr[1] = 0x2e; + + memcopy(&hdr, fat_cache->data_sector + 32, 32); + + fatCacheSaveData(); + //fatCacheLoadData() + } + + return 0; +} + +u8 fatCreateRecord2(u8 *name, u8 is_dir, u8 check_exist) { + + //u8 cy = 10; + u16 i; + FatRecordHdr hdr; + FatRecord rec; + u8 patch[FAT_MAX_NAME_LEN_S]; + u8 *file_name; //[FAT_MAX_NAME_LEN_S]; + u8 *ptr; + u8 lfn_blocks = 0; + u8 resp; + u8 sum = 0; + u8 nam_len; + u8 ext_len; + u32 cluster; + u8 lfn_block[32]; + u32 sub_dir_cluster = 0; + + //rec.name = rec_name; + fat_cache->data_sec_idx = ~0; + + if (*name != '/')return FAT_ERR_NAME; + if (slen(name) < 2)return FAT_ERR_NAME; + i = slen(name) - 1; + if (name[i] == '.' || name[i] == ' ')return FAT_ERR_NAME; + + + if (check_exist) { + resp = fatFindRecord(name, &rec, is_dir); + if (resp != FAT_ERR_NOT_EXIST) { + if (resp)return resp; + return FAT_ERR_EXIST; + } + } + + + memfill(&hdr, 0, 32); + + + ptr = &name[slen(name)]; + + i = 0; + while (*ptr != '/')ptr--; + + i = 0; + while (name != ptr)patch[i++] = *name++; + patch[i] = 0; + + ptr++; + file_name = ptr; + //i = 0; + //while (*ptr != 0)file_name[i++] = *ptr++; + //file_name[i] = 0; + + + + if (slen(file_name) < 1)return FAT_ERR_NAME; + + + i = slen(file_name); + while (i != 0 && file_name[i] != '.')i--; + if (i == 0)i = slen(file_name); + nam_len = i; + ext_len = slen(file_name); + if (ext_len == nam_len) { + ext_len = 0; + } else { + ext_len -= (nam_len + 1); + } + + + + if (nam_len > 8 || ext_len > 3) { + + lfn_blocks = slen(file_name); + if (lfn_blocks % 13 != 0)lfn_blocks += 13; + lfn_blocks /= 13; + for (i = 0; i < 8; i++)hdr.name[i] = file_name[i]; + } else { + for (i = 0; i < 8 && file_name[i] != 0 && file_name[i] != '.'; i++)hdr.name[i] = file_name[i]; + for (; i < 8; i++)hdr.name[i] = ' '; + } + //VDP_drawText(APLAN, file_name, 0, 2, cy++); + + ptr = 0; + if (ext_len != 0)ptr = &file_name[nam_len + 1]; + + + if (ptr != 0) { + hdr.ext[0] = *ptr == 0 ? 0x20 : *ptr++; + hdr.ext[1] = *ptr == 0 ? 0x20 : *ptr++; + hdr.ext[2] = *ptr == 0 ? 0x20 : *ptr++; + } else { + for (i = 0; i < 3; i++)hdr.ext[i] = ' '; + } + strhicase(hdr.name, 8); + strhicase(hdr.ext, 3); + hdr.attrib = is_dir ? 0x10 : 0x20; + + + + + if (patch[0] != 0) { + resp = fatFindRecord(patch, &rec, 1); + sub_dir_cluster = rec.entry_cluster; + //if (resp == FAT_ERR_NOT_EXIST)VDP_drawText(APLAN, "cant find patch", 0, 2, cy++); + if (resp)return resp; + } else { + rec.entry_cluster = 0; + } + + + resp = fatGetFreeRecord(&rec, lfn_blocks + 1); + if (resp)return resp; + + //rec.hdr_sector = fat.root_entry; + //rec.hdr_idx + + + resp = fatCacheLoadData(rec.hdr_sector, 0); + if (resp)return resp; + + if (lfn_blocks != 0) { + + hdr.name[7] = '1'; + hdr.name[6] = '~'; + hdr.name[5] = (rec.hdr_idx + rec.hdr_sector / 32) & 15; + hdr.name[4] = ((rec.hdr_idx + rec.hdr_sector / 32) >> 4) & 15; + hdr.name[5] += hdr.name[5] <= 10 ? 48 : 55; + hdr.name[4] += hdr.name[4] <= 10 ? 48 : 55; + for (sum = i = 0; i < 11; i++) { + if (i < 8) { + sum = (((sum & 1) << 7) | ((sum & 0xfe) >> 1)) + hdr.name[i]; + } else { + sum = (((sum & 1) << 7) | ((sum & 0xfe) >> 1)) + hdr.ext[i - 8]; + } + } + } + + for (i = 0; i < lfn_blocks; i++) { + + fatMakeLfnBlock(file_name, lfn_block, lfn_blocks - i - 1, sum); + if (i == 0)lfn_block[0] |= 0x40; + memcopy(lfn_block, &fat_cache->data_sector[rec.hdr_idx * 32], 32); + rec.hdr_idx++; + if (rec.hdr_idx == 16) { + rec.hdr_sector++; + rec.hdr_idx = 0; + resp = fatCacheLoadData(rec.hdr_sector, 1); + if (resp)return resp; + } + } + /* + if (lfn_blocks != 0) { + resp = diskWriteSector(cache->buff_sector, cache->buff); + if (resp)return resp; + } + */ + + if (is_dir) { + + //ocuppy function may destroy cache buff data + if (lfn_blocks != 0) { + resp = diskWrite(fat_cache->data_sec_idx, fat_cache->data_sector, 1); + if (resp)return resp; + } + cluster = 0; + resp = fatOccupyClusters(&cluster, 1); + if (resp)return resp; + ((u8 *) & hdr.cluster_lo)[0] = (u32) cluster & 0xff; + ((u8 *) & hdr.cluster_lo)[1] = (u32) cluster >> 8; + //hdr.cluster_lo = cluster & 0xffff; + if (current_fat.type == FAT_TYPE_32) { + ((u8 *) & hdr.cluster_hi)[0] = (u32) cluster >> 16; + ((u8 *) & hdr.cluster_hi)[1] = (u32) cluster >> 24; + } + + fat_cache->data_sec_idx = ~0; + resp = fatCacheLoadData(rec.hdr_sector, 0); + if (resp)return resp; + } + + hdr.date = 0x5d11; + hdr.time = 0; + + memcopy(&hdr, &fat_cache->data_sector[rec.hdr_idx * 32], 32); + + resp = diskWrite(fat_cache->data_sec_idx, fat_cache->data_sector, 1); + if (resp)return resp; + + if (is_dir) { + + u32 sector = fatClusterToSector(cluster); + resp = fatClearClusters(cluster, 1); + if (resp)return resp; + + resp = fatCacheLoadData(sector, 0); + if (resp)return resp; + + memfill(&hdr, 0, 32); + //memcopy((void *)rawData, &hdr, 32); + hdr.attrib = 0x10; + ptr = (u8 *) & hdr; + for (i = 0; i < 11; i++)ptr[i] = 0x20; + ptr[0] = 0x2e; + + fatSetClustVal(&hdr, cluster); + + memcopy(&hdr, fat_cache->data_sector, 32); + + fatSetClustVal(&hdr, sub_dir_cluster); + ptr[1] = 0x2e; + + memcopy(&hdr, fat_cache->data_sector + 32, 32); + + fatCacheSaveData(); + //fatCacheLoadData() + } + + return 0; +} + +void fatMakeLfnBlock(u8 *name, u8 *lfn_block, u8 block_idx, u8 crc) { + + u8 i; + name += block_idx * 13; + for (i = 0; i < 13; i++) { + if (name[i] == 0)break; + } + i++; + for (; i < 13; i++) { + name[i] = 0xff; + } + + *lfn_block++ = block_idx + 1; + + for (i = 0; i < 5; i++) { + *lfn_block++ = *name == 0xff ? 0xff : *name; + *lfn_block++ = *name == 0xff ? 0xff : 0; + name++; + } + *lfn_block++ = 0x0f; + *lfn_block++ = 0; + *lfn_block++ = crc; + + for (i = 0; i < 6; i++) { + + *lfn_block++ = *name == 0xff ? 0xff : *name; + *lfn_block++ = *name == 0xff ? 0xff : 0; + name++; + } + + *lfn_block++ = 0; + *lfn_block++ = 0; + + *lfn_block++ = *name == 0xff ? 0xff : *name; + *lfn_block++ = *name == 0xff ? 0xff : 0; + name++; + *lfn_block++ = *name == 0xff ? 0xff : *name++; + *lfn_block++ = *name == 0xff ? 0xff : 0; + name++; + +} + +u8 fatGetFreeRecord(FatRecord *dir_rec, u8 len) { + + u8 len_ctr = 0; + u32 sector; + u8 resp; + u32 current_cluster = dir_rec->entry_cluster; + u32 next_cluster; + u16 in_cluster_ptr = 0; + u16 i; + u8 is_root = 0; + fat_cache->data_sec_idx = ~0; + + if (current_cluster == 0 && current_fat.type == FAT_TYPE_32)current_cluster = 2; + + if (current_cluster == 0) { + //current_cluster = fatSectorToCluster(fat->root_entry); + sector = current_fat.root_entry; + is_root = 1; + } else { + sector = fatClusterToSector(current_cluster); + } + + //VDP_drawText(APLAN, "get rec", 0, 15, cy++); + + while (len_ctr != len) { + + + + resp = fatCacheLoadData(sector,0); + if (resp)return resp; + + for (i = 0; i < 512; i += 32) { + + if (fat_cache->data_sector[i] == 0 || fat_cache->data_sector[i] == 0xe5) { + if (len_ctr == 0) { + dir_rec->hdr_sector = sector; + dir_rec->hdr_idx = i / 32; + } + len_ctr++; + } else { + len_ctr = 0; + dir_rec->hdr_sector = 0; + } + if (len_ctr == len)return 0; + } + + sector++; + in_cluster_ptr++; + + if (is_root && current_fat.type == FAT_TYPE_16 && in_cluster_ptr >= 16384 / 512) { + //VDP_drawText(APLAN, "root overflow", 0, 15, cy++); + return FAT_ERR_ROT_OVERFLOW; + } + + if (current_fat.type == FAT_TYPE_16 && is_root)continue; + + if (in_cluster_ptr == current_fat.cluster_size) { + + //VDP_drawText(APLAN, "cluster end", 0, 15, cy++); + next_cluster = current_cluster; + resp = fatGetNextCluster(&next_cluster); + if (resp)return resp; + if (next_cluster == 0) { + //VDP_drawText(APLAN, "need to ocupy cluster for dir", 0, 15, cy++); + resp = fatOccupyClusters(¤t_cluster, 1); + if (resp)return resp; + resp = fatClearClusters(current_cluster, 1); + if (resp)return resp; + //VDP_drawText(APLAN, "ocupied!!!!!", TILE_ATTR(cy % 3, 0, 0, 0), 15, cy++); + //cy %= 27; + } else { + current_cluster = next_cluster; + } + sector = fatClusterToSector(current_cluster); + in_cluster_ptr = 0; + } + } + + return 0; +} + +u8 fatClearClusters(u32 cluster, u8 len) { + + u32 i; + u8 resp; + memfill(fat_cache->data_sector, 0x00, 512); + + while (len--) { + fat_cache->data_sec_idx = fatClusterToSector(cluster++); + for (i = 0; i < current_fat.cluster_size; i++) { + resp = diskWrite(fat_cache->data_sec_idx++, fat_cache->data_sector, 1); + + if (resp)return resp; + } + } + return 0; +} + +u8 fatOccupyClusters(u32 *base_cluster, u16 len) { + + + if ((current_fat.type == FAT_TYPE_16 && *base_cluster == 0xffff) || (current_fat.type == FAT_TYPE_32 && *base_cluster == 0x0FFFFFFF))return FAT_ERR_BAD_BASE_CLUSTER; + u32 *ptr32; + u16 *ptr16; + u16 i; + u32 fat_table_sector = 0; + u16 len_ctr = 0; + u32 first_free_cluster = 0; + u32 cluster_ctr = 0; + u16 fat_page_len = current_fat.type == FAT_TYPE_16 ? 8192 : 4096; + u8 resp = 0; + + + kot = 0; + //gDrawString("okupy 1", 32, 32); + + while (len_ctr < len) { + + + //memcopy(current_cache->table_frame, occupy_buff, 512); + resp = diskRead(current_fat.fat_entry + fat_table_sector, (void *) ROM_ADDR, 32); + //resp = diskRead(current_fat.fat_entry + fat_table_sector, occupy_buff, 1); + if (resp)return resp; + dma_read(occupy_buff, ROM_ADDR, 32 * 512); + + + if (current_fat.type == FAT_TYPE_16) { + + ptr16 = (u16 *) occupy_buff; + + + for (i = 0; i < fat_page_len; i++) { + + if (*ptr16++ == 0) { + if (first_free_cluster == 0)first_free_cluster = cluster_ctr; + len_ctr++; + if (len_ctr == len)break; + } else if (len_ctr != 0) { + len_ctr = 0; + first_free_cluster = 0; + } + cluster_ctr++; + + } + + if (cluster_ctr == 0x10000)return FAT_ERR_NO_FRE_SPACE; + + } else { + + ptr32 = (u32 *) occupy_buff; + for (i = 0; i < fat_page_len; i++) { + + + if (*ptr32++ == 0) { + if (first_free_cluster == 0)first_free_cluster = cluster_ctr; + len_ctr++; + if (len_ctr == len)break; + } else if (len_ctr != 0) { + len_ctr = 0; + first_free_cluster = 0; + } + cluster_ctr++; + + } + } + + + + fat_table_sector += 32; + } + + + /* + gConsDrawString("oc: "); + gAppendNum(first_free_cluster); + */ + + //cache current fact sector to avoid dummy rewrite + /* + cluster = *base_cluster != 0 ? *base_cluster : first_free_cluster; + table_sector = current_fat.type == FAT_TYPE_16 ? cluster / 256 : cluster / 128; + resp = fatCacheLoadTable(table_sector, 0); + if (resp)return resp;*/ + + if (*base_cluster != 0) { + resp = fatSetTableRecord(*base_cluster, first_free_cluster); + if (resp)return resp; + } + + *base_cluster = first_free_cluster; + + while (len--) { + + if (len == 0) { + resp = fatSetTableRecord(first_free_cluster, 0x0FFFFFFF); + } else { + resp = fatSetTableRecord(first_free_cluster, first_free_cluster + 1); + } + if (resp)return resp; + first_free_cluster++; + } + + fatCacheApplyTable(); + if (resp)return resp; + + return 0; +} + +u8 fatGetTableRecord(u32 cluster, u32 *val) { + + u8 resp; + u8 *ptr; + + u32 table_sector = current_fat.type == FAT_TYPE_16 ? cluster / 256 : cluster / 128; + resp = fatCacheLoadTable(table_sector, 0); + + if (resp)return resp; + + if (current_fat.type == FAT_TYPE_16) { + ptr = &fat_cache->table_sector[(cluster & 255) * 2]; + *val = (u32) ptr[0] | (u32) ptr[1] << 8; + } else { + + ptr = &fat_cache->table_sector[(cluster & 127) * 4]; + *val = (u32) ptr[0] | (u32) ptr[1] << 8 | (u32) ptr[2] << 16 | (u32) ptr[3] << 24; + } + + + return 0; + +} + +u8 fatSetTableRecord(u32 cluster, u32 next_cluster) { + + u8 resp; + u32 table_sector = current_fat.type == FAT_TYPE_16 ? cluster / 256 : cluster / 128; + u8 *ptr; + + resp = fatCacheLoadTable(table_sector, table_changed); + + if (resp)return resp; + + if (current_fat.type == FAT_TYPE_16) { + ptr = &fat_cache->table_sector[(cluster & 255) * 2]; + ptr[0] = (u32) next_cluster >> 0; + ptr[1] = (u32) next_cluster >> 8; + } else { + + ptr = &fat_cache->table_sector[(cluster & 127) * 4]; + ptr[0] = (u32) next_cluster >> 0; + ptr[1] = (u32) next_cluster >> 8; + ptr[2] = (u32) next_cluster >> 16; + ptr[3] = (u32) next_cluster >> 24; + } + + table_changed = 1; + + return 0; +} + +/* +u8 fatWriteFile(void *src, u32 sectors) { + + u8 resp; + u8 *ptr8 = (u8 *) src; + + if (file.mode != FILE_MODE_WR)return FAT_ERR_FILE_MODE; + if (sectors > file.sec_available)return FAT_ERR_OUT_OF_FILE; + while (sectors--) { + + resp = diskWrite(file.sector, ptr8, 1); + if (resp)return resp; + ptr8 += 512; + resp = fatSkipSectors(1); + if (resp)return resp; + } + + + if (file.sec_available == 0)file.mode = 0; + + return 0; +}*/ + + +u8 fatWriteFile(void *src, u32 sectors) { + + u8 resp; + u8 *ptr8 = (u8 *) src; + u32 len; + u32 readed; + + if (file.mode != FILE_MODE_WR)return FAT_ERR_FILE_MODE; + if (sectors > file.sec_available)return FAT_ERR_OUT_OF_FILE; + + while (sectors) { + + if (file.in_cluster_ptr == 0 && sectors >= current_fat.cluster_size) { + resp = fatMultiClustRW(src, sectors, &readed, 1); + sectors -= readed; + //console_printf("len: %d\n", readed); + //joyWait(); + + } else { + + len = sectors + file.in_cluster_ptr < current_fat.cluster_size ? sectors : 1; + + //console_printf("len: %d\n", len); + //joyWait(); + resp = diskWrite(file.sector, ptr8, len); + if (resp)return resp; + ptr8 += 512 * len; + resp = fatSkipSectors(len); + if (resp)return resp; + sectors -= len; + } + + + } + + + if (file.sec_available == 0)file.mode = 0; + + return 0; +} + +u8 fatReadFile(void *dst, u32 sectors) { + + u8 resp; + u32 readed; + u32 len; + + if (file.mode != FILE_MODE_RD)return FAT_ERR_FILE_MODE; + if (sectors > file.sec_available)return FAT_ERR_OUT_OF_FILE; + + while (sectors) { + + if (sectors < current_fat.cluster_size || file.in_cluster_ptr != 0) { + + len = current_fat.cluster_size - file.in_cluster_ptr; + if (len > sectors)len = sectors; + + resp = diskRead(file.sector, dst, len); + + if (resp)return resp; + dst += 512 * len; + resp = fatSkipSectors(len); + if (resp)return resp; + sectors = sectors >= len ? sectors - len : 0; + } else { + + resp = fatMultiClustRW(dst, sectors, &readed, 0); + if (resp)return resp; + dst += readed * 512; + sectors -= readed; + } + } + + if (file.sec_available == 0)file.mode = 0; + + return 0; +} + +/* +u8 fatReadPartialFile(void *dst, u32 sectors, int b_offset) { + +//1048576 * 8 sectors + + //secotrs = datei gesamt-sektoranzahl + u8 resp; + u32 readed; + u32 len; + + if (file.mode != FILE_MODE_RD)return FAT_ERR_FILE_MODE; + if (end_sector > file.sec_available || offset_sector > file.sec_available)return FAT_ERR_OUT_OF_FILE; + + +//first run b_offset = 0 -> 1Mb lesen +//also einmal tmp_sectors +//zweiter run b_offset = 1 -> 1Mb lesen +//aber ab offset 1024*1024 * 1 + + tmp_sectors = 1024*1024; //1048576 + //for(int i=0; i < ;i++){ //1 mb + while (tmp_sectors) { + + //gesamt < 4096 (8*512) oder c_ptr!=0 -> >first run? + if (sectors < current_fat.cluster_size || file.in_cluster_ptr != 0) { + + //rest sectores + len = current_fat.cluster_size - file.in_cluster_ptr; + if (len > sectors)len = sectors; + + resp = diskRead(file.sector, dst, len); //len in sectors + if (resp)return resp; + dst += 512 * len; + resp = fatSkipSectors(len); + if (resp)return resp; + sectors = sectors >= len ? sectors - len : 0; + } else { + //anfang liest ganze 512 cluster + //sectors sollte offset+1Mb + resp = fatMultiClustRW(dst, sectors, &readed, 0); + if (resp)return resp; + dst += readed * 512; + sectors -= readed; //zieht großen block ab + } + } + + if (file.sec_available == 0)file.mode = 0; + + return 0; +} +*/ + +u8 fatMultiClustRW(void *buff, u32 max_sectors, u32 *readrd_sectors, u16 write) { + + u8 resp; + u32 clust = max_sectors / current_fat.cluster_size; + if (max_sectors % current_fat.cluster_size != 0)clust++; + u32 begin_sect = file.sector; + u32 len = 0; + u32 prev_clust = file.cluster; + u32 max_len = 0x2000000 / current_fat.cluster_byte_size; + + while (clust-- && len < max_len) { + len++; + resp = fatSkipCluster(); + if (resp)return resp; + if (prev_clust + 1 != file.cluster)break; + prev_clust = file.cluster; + } + + len *= current_fat.cluster_size; + if (len > max_sectors)len = max_sectors; + *readrd_sectors = len; + + if (write) { + resp = diskWrite(begin_sect, buff, len); + } else { + resp = diskRead(begin_sect, buff, len); + } + + return resp; + +} + +u8 fatSkipCluster() { + + u8 resp; + + resp = fatGetNextCluster(&file.cluster); + if (resp)return resp; + file.sec_available = file.sec_available < current_fat.cluster_size ? 0 : file.sec_available - current_fat.cluster_size; + if (file.sec_available != 0 && file.cluster == 0)return FAT_ERR_OUT_OF_TABLE; + file.sector = fatClusterToSector(file.cluster); + file.in_cluster_ptr = 0; + + if (file.sec_available == 0)file.mode = 0; + + return 0; +} + +u8 fatReadCluster(void *dst) { + + u8 resp; + if (file.mode != FILE_MODE_RD)return FAT_ERR_FILE_MODE; + + resp = diskRead(file.sector, dst, current_fat.cluster_size); + if (resp)return resp; + dst += current_fat.cluster_byte_size; + resp = fatGetNextCluster(&file.cluster); + //file.cluster ++; + if (resp)return resp; + file.sec_available = file.sec_available < current_fat.cluster_size ? 0 : file.sec_available - current_fat.cluster_size; + if (file.sec_available != 0 && file.cluster == 0)return FAT_ERR_OUT_OF_TABLE; + file.sector = fatClusterToSector(file.cluster); + file.in_cluster_ptr = 0; + + if (file.sec_available == 0)file.mode = 0; + + return 0; +} + +u8 fatSkipSectors(u32 sectors) { + + u8 resp; + + if (sectors == 0)return 0; + + if (sectors > file.sec_available)sectors = file.sec_available; + while (sectors--) { + + file.sector++; + file.sec_available--; + file.in_cluster_ptr++; + if (file.in_cluster_ptr == current_fat.cluster_size) { + resp = fatGetNextCluster(&file.cluster); + if (resp)return resp; + + if (file.cluster == 0 && sectors != 0)return FAT_ERR_OUT_OF_TABLE; + file.sector = fatClusterToSector(file.cluster); + file.in_cluster_ptr = 0; + } + } + + + return 0; +} + +u8 fatOpenFile(FatRecord *rec, u32 wr_sectors) { + + + u8 resp; + file.sec_available = rec->size / 512; + if ((rec->size & 511) != 0)file.sec_available++; + file.cluster = rec->entry_cluster; + file.in_cluster_ptr = 0; + file.mode = wr_sectors == 0 ? FILE_MODE_RD : FILE_MODE_WR; + + + + if (wr_sectors > file.sec_available) { + + resp = fatResizeFile(rec, wr_sectors); + if (resp)return resp; + if (file.cluster == 0)file.cluster = rec->entry_cluster; + file.sec_available = wr_sectors; + } + + file.sector = fatClusterToSector(file.cluster); + + + return 0; + +} + +/* +u8 fatOpenFile(FatRecord *rec, u32 wr_sectors) { + + u8 resp; + u32 clusters_need; + FatRecordHdr hdr; + u32 clust; + + u32 size; + u32 clusters_available; + u32 wr_clusters_req; + + + current_cache->data_sector = ~0; + memcopy(rec, &file.rec, sizeof (FatRecord)); + + + file.sec_available = file.rec.size / 512; + if ((file.rec.size & 511) != 0)file.sec_available++; + file.cluster = file.rec.entry_cluster; + file.in_cluster_ptr = 0; + file.mode = wr_sectors == 0 ? FILE_MODE_RD : FILE_MODE_WR; + + clusters_available = file.sec_available / current_fat.cluster_size; + if ((file.sec_available & (current_fat.cluster_size - 1)) != 0)clusters_available++; + wr_clusters_req = wr_sectors / current_fat.cluster_size; + if ((wr_sectors & (current_fat.cluster_size - 1)) != 0)wr_clusters_req++; + + if (wr_sectors > file.sec_available) { + + + if (clusters_available == 0 || clusters_available < wr_clusters_req) { + //VDP_drawText(APLAN, "ned to get some clusters", 0, 2, cy++); + clusters_need = (wr_sectors - file.sec_available); + if ((clusters_need & (current_fat.cluster_size - 1)) != 0)clusters_need += current_fat.cluster_size; + clusters_need /= current_fat.cluster_size; + clust = file.cluster; + if (clusters_available != 0)clust += clusters_available - 1; + + resp = fatOccupyClusters(&clust, clusters_need); + + + if (resp)return resp; + if (file.cluster == 0)file.cluster = clust; + } + + file.sec_available = wr_sectors; + current_cache->data_sector = ~0; + fatCacheLoadBuff(file.rec.hdr_sector, 0); + memcopy(¤t_cache->data_frame[file.rec.hdr_idx * 32], &hdr, 32); + size = file.sec_available * 512; + //hdr.size = 0x12345; + ((u8 *) & hdr.size)[0] = (u32) size; + ((u8 *) & hdr.size)[1] = (u32) size >> 8; + ((u8 *) & hdr.size)[2] = (u32) size >> 16; + ((u8 *) & hdr.size)[3] = (u32) size >> 24; + + ((u8 *) & hdr.cluster_lo)[0] = (u32) file.cluster & 0xff; + ((u8 *) & hdr.cluster_lo)[1] = (u32) file.cluster >> 8; + //hdr.cluster_lo = cluster & 0xffff; + if (current_fat.type == FAT_TYPE_32) { + ((u8 *) & hdr.cluster_hi)[0] = (u32) file.cluster >> 16; + ((u8 *) & hdr.cluster_hi)[1] = (u32) file.cluster >> 24; + } + + + memcopy(&hdr, ¤t_cache->data_frame[file.rec.hdr_idx * 32], 32); + + resp = diskWrite(current_cache->data_sector, current_cache->data_frame, 1); + + if (resp)return resp; + } + + file.sector = fatClusterToSector(file.cluster); + + return 0; +} + */ +u8 fatResizeFile(FatRecord *rec, u32 req_sec_size) { + + u8 resp; + u32 sec_available; + u32 wr_clusters_req; + u32 clusters_available; + u32 clusters_need; + u32 clust; + u16 i; + FatRecordHdr *hdr; + u32 size; + + + + sec_available = rec->size / 512; + if ((rec->size & 511) != 0)sec_available += 512; + + if (req_sec_size <= sec_available)return FAT_ERR_RESIZE; + + + clusters_available = sec_available / current_fat.cluster_size; + if ((sec_available % current_fat.cluster_size) != 0)clusters_available++; + wr_clusters_req = req_sec_size / current_fat.cluster_size; + if (req_sec_size % current_fat.cluster_size != 0)wr_clusters_req++; + + if (clusters_available < wr_clusters_req) { + + clusters_need = (wr_clusters_req - clusters_available); + clust = rec->entry_cluster; + if (clusters_available != 0) { + for (i = 0; i < clusters_available - 1; i++) { + fatGetNextCluster(&clust); + } + } + + resp = fatOccupyClusters(&clust, clusters_need); + + if (rec->entry_cluster == 0)rec->entry_cluster = clust; + if (resp)return resp; + } + + //resp = fatCacheLoadData(rec->hdr_sector); + resp = fatCacheLoadData(rec->hdr_sector, 0); + if (resp)return resp; + hdr = (FatRecordHdr *) & fat_cache->data_sector[rec->hdr_idx * 32]; + + size = req_sec_size * 512; + ((u8 *) & hdr->size)[0] = (u32) size; + ((u8 *) & hdr->size)[1] = (u32) size >> 8; + ((u8 *) & hdr->size)[2] = (u32) size >> 16; + ((u8 *) & hdr->size)[3] = (u32) size >> 24; + + + ((u8 *) & hdr->cluster_lo)[0] = (u32) rec->entry_cluster & 0xff; + ((u8 *) & hdr->cluster_lo)[1] = (u32) rec->entry_cluster >> 8; + if (current_fat.type == FAT_TYPE_32) { + ((u8 *) & hdr->cluster_hi)[0] = (u32) rec->entry_cluster >> 16; + ((u8 *) & hdr->cluster_hi)[1] = (u32) rec->entry_cluster >> 24; + } + + resp = fatCacheSaveData(); + if (resp)return resp; + + + return 0; +} diff --git a/fat.h b/fat.h new file mode 100644 index 0000000..c8e1522 --- /dev/null +++ b/fat.h @@ -0,0 +1,128 @@ +/* + * File: fat.h + * Author: krik + * + * Created on 22 Ìàé 2011 ã., 1:06 + */ + +#ifndef _FAT_H +#define _FAT_H + +#include "types.h" +#include "errors.h" + + + + +#define FAT_MAX_DIR_SIZE 1024 +#define FAT_MAX_NAME_LEN 128 +#define FAT_MAX_NAME_LEN_S 256 + +#define FAT_TYPE_16 1 +#define FAT_TYPE_32 2 + +typedef struct { + u8 name[FAT_MAX_NAME_LEN]; + u32 entry_cluster; + u32 size; + u32 hdr_sector; + u16 hdr_idx; + u16 fav_idx; + u8 is_dir; +} FatRecord; + +typedef struct { + u8 name[8]; + u8 ext[3]; + u8 attrib; + u8 x[8]; + u16 cluster_hi; + u16 time; + u16 date; + u16 cluster_lo; + u32 size; +} FatRecordHdr; + +typedef struct { + FatRecord * rec[FAT_MAX_DIR_SIZE]; + FatRecord * s_records[FAT_MAX_DIR_SIZE]; + u8 *path; + u16 size; + u32 entry_cluster; + u32 entry_sector; + u32 in_cluster_ptr; + u32 current_cluster; + u8 is_root; +} Dir; + +typedef struct { + u32 pbr_entry; + u32 root_entry; + u32 fat_entry; + u32 data_entry; + u8 type; + u8 cluster_size; + u32 loaded_sector; + u32 cluster_byte_size; + u32 sectors_per_fat; +} Fat; + +typedef struct { + u8 *table_buff; + u8 *table_sector; + u8 *data_sector; + u32 data_sec_idx; + u32 table_sec_idx; +} FatCache; + +typedef struct { + u32 sector; + u32 cluster; + u32 sec_available; + u16 in_cluster_ptr; + FatRecord rec; + u8 mode; +} File; + + + +extern Dir *dir; +//extern Dir dir_o; +extern File file; +extern FatCache *fat_cache; +//extern FatRecord rec_tmp; +#define ED_ROOT "/ED64" +#define ED_SAVE "/ED64/SDSAVE" +#define ED_ROM_CFG "/ED64/SDSAVE/LAST.CRT" +//#define ED_TEST_CFG "/MISC/test.dat" +//#define ED_OPTIONS "/ED64/options.dat" +//#define ED_FAVOR "/ED64/favor.dat" + +//#define ED_SAVE_DMP "/EDMD/sav-dmp.bin" +#define FILE_MODE_RD 1 +#define FILE_MODE_WR 2 + +u8 fatInit(); +u8 fatLoadDir(u32 cluster); +u8 fatLoadDirByName(u8 *name); + +u8 fatWriteFile(void *src, u32 sectors); +u8 fatReadFile(void *dst, u32 sectors); +u8 fatReadPartialFile(void *dst, u32 sectors, int b_offset); +u8 fatCreateRecord(u8 *name, u8 is_dir, u8 check_exist); +u8 fatOpenFileByeName(u8 *name, u32 wr_sectors); +u8 fatFindRecord(u8 *name, FatRecord *rec, u8 is_dir); +u8 fatOpenFile(FatRecord *rec, u32 wr_sectors); + +u8 fatSkipSectors(u32 sectors); +u8 fatCreateRecIfNotExist(u8 *name, u8 is_dir); +u8 fatGetFullName(u8 *name, u32 dir_entry, u32 rec_entry); +u8 fatOpenDirByName(u8 *name); +void fatInitRam(); + +u8 streq(u8 *str1, u8 *str2); +u8 streql(u8 *str1, u8 *str2, u8 len); +u8 slen(u8 *str); +void fatSortRecords(); +#endif /* _FAT_H */ + diff --git a/filesystem/bamboo.wav b/filesystem/bamboo.wav new file mode 100644 index 0000000000000000000000000000000000000000..dad6dbc5e68728efda1ddccf9e5e8b1f8c4a2ca2 GIT binary patch literal 122156 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 NB#dWQXHjSP{{a;35%&N9 literal 0 HcmV?d00001 diff --git a/filesystem/done.wav b/filesystem/done.wav new file mode 100644 index 0000000000000000000000000000000000000000..6051ac780e1ace6d53b20162e1dcee4f6083afcd GIT binary patch literal 36356 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 literal 0 HcmV?d00001 diff --git a/filesystem/ed64_mono.wav b/filesystem/ed64_mono.wav new file mode 100644 index 0000000000000000000000000000000000000000..74d4dcbb01a5452e00ee0c48eced2cc32fcd594b GIT binary patch literal 154510 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

@* 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

lrloHF|j%*e?BBONxUjN>%2(Hj1H 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

v^2weB8{B~cJFX(gn9{NuE4)`Yc2)?)8=U$Gl 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 literal 0 HcmV?d00001 diff --git a/filesystem/sprites/background.sprite b/filesystem/sprites/background.sprite new file mode 100644 index 0000000000000000000000000000000000000000..d4ccae785878c38b9ad2fa88981daa2492db2c77 GIT binary patch literal 307208 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∇BXhN;C= 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

eUmk1+P+C+-s?4n=F$=}7G%7PE`F8@CY~ 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�o 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
Ij|6wQ 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∇BXhN;C= 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

eUmk1+P+C+-s?4n=F$=}7G%7PE`F8@CY~ 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�o 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ྫj!aFwr$Rl*K^b&Qp*mkjF5nIL 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 literal 0 HcmV?d00001 diff --git a/filesystem/warning.wav b/filesystem/warning.wav new file mode 100644 index 0000000000000000000000000000000000000000..53b3d4b0d3fbf6556655033dec4b5fa7873258a6 GIT binary patch literal 14472 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 + 0xFC, 0xCC, 0x0C, 0x3C, 0x3C, 0x00, 0x3C, 0x00, // Char 063 (?) + 0xFE, 0xC2, 0xDE, 0xD6, 0xDE, 0xC0, 0xFE, 0x00, // Char 064 (@) + 0xFC, 0xEE, 0xE6, 0xFE, 0xE6, 0xE6, 0xE6, 0x00, // Char 065 (A) + 0xFC, 0xE4, 0xE4, 0xFE, 0xE6, 0xE6, 0xFE, 0x00, // Char 066 (B) + 0xFE, 0xE0, 0xE0, 0xE0, 0xE0, 0xFE, 0xFE, 0x00, // Char 067 (C) + 0xFC, 0xE6, 0xE6, 0xE6, 0xE6, 0xE6, 0xFE, 0x00, // Char 068 (D) + 0xFE, 0xE0, 0xE0, 0xFC, 0xE0, 0xFE, 0xFE, 0x00, // Char 069 (E) + 0xFE, 0xE0, 0xE0, 0xFC, 0xFC, 0xE0, 0xE0, 0x00, // Char 070 (F) + 0xFE, 0xE2, 0xE2, 0xE0, 0xEE, 0xE2, 0xFE, 0x00, // Char 071 (G) + 0xE6, 0xE6, 0xE6, 0xFE, 0xE6, 0xE6, 0xE6, 0x00, // Char 072 (H) + 0x38, 0x38, 0x3C, 0x3C, 0x3C, 0x3C, 0x3C, 0x00, // Char 073 (I) + 0x0E, 0x0E, 0x0E, 0x0E, 0x0E, 0xFE, 0xFE, 0x00, // Char 074 (J) + 0xE8, 0xE8, 0xE8, 0xFE, 0xE6, 0xE6, 0xE6, 0x00, // Char 075 (K) + 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xFE, 0xFE, 0x00, // Char 076 (L) + 0xF6, 0xFE, 0xEA, 0xEA, 0xE2, 0xE2, 0xE2, 0x00, // Char 077 (M) + 0xE6, 0xE6, 0xF6, 0xFE, 0xEE, 0xE6, 0xE6, 0x00, // Char 078 (N) + 0x7C, 0xE6, 0xE6, 0xE6, 0xE6, 0xE6, 0xFC, 0x00, // Char 079 (O) + 0xFE, 0xE6, 0xE6, 0xFE, 0xE0, 0xE0, 0xE0, 0x00, // Char 080 (P) + 0xFE, 0xE6, 0xE6, 0xE6, 0xF6, 0xEE, 0xFE, 0x00, // Char 081 (Q) + 0xFE, 0xE6, 0xE6, 0xFC, 0xE6, 0xE6, 0xE6, 0x00, // Char 082 (R) + 0xFE, 0xE6, 0xE0, 0xFE, 0x06, 0xE6, 0xFE, 0x00, // Char 083 (S) + 0x7E, 0x7E, 0x38, 0x38, 0x38, 0x38, 0x38, 0x00, // Char 084 (T) + 0xE6, 0xE6, 0xE6, 0xE6, 0xE6, 0xE6, 0xFE, 0x00, // Char 085 (U) + 0xE6, 0xE6, 0xE6, 0xE6, 0xEE, 0xFC, 0xF8, 0x00, // Char 086 (V) + 0xE2, 0xE2, 0xEA, 0xFE, 0xEE, 0xE6, 0xE2, 0x00, // Char 087 (W) + 0xEE, 0xEE, 0x78, 0x78, 0x78, 0xEE, 0xEE, 0x00, // Char 088 (X) + 0xE6, 0xE6, 0xFE, 0x3E, 0x38, 0x38, 0x38, 0x00, // Char 089 (Y) + 0xFE, 0xE6, 0xEE, 0x18, 0x30, 0xE6, 0xFE, 0x00, // Char 090 (Z) + 0xF8, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0, 0xF8, 0x00, // Char 091 ([) + 0xE0, 0x70, 0x38, 0x1C, 0x0E, 0x06, 0x02, 0x00, // Char 092 (\) + 0x7C, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x7C, 0x00, // Char 093 (]) + 0x38, 0x7C, 0xEE, 0xC6, 0x00, 0x00, 0x00, 0x00, // Char 094 (^) + 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, // Char 095 (_) + 0x30, 0x30, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, // Char 096 (`) + 0x00, 0x00, 0x7C, 0x0C, 0x7C, 0x6E, 0x7E, 0x00, // Char 097 (a) + 0xE0, 0xE0, 0x60, 0x7E, 0x66, 0x66, 0x7E, 0x00, // Char 098 (b) + 0x00, 0x00, 0x7E, 0x66, 0x60, 0x66, 0x7E, 0x00, // Char 099 (c) + 0x0C, 0x0C, 0x0C, 0x7C, 0x6C, 0x6E, 0x7E, 0x00, // Char 100 (d) + 0x00, 0x00, 0x7E, 0x66, 0x7E, 0x60, 0x7E, 0x00, // Char 101 (e) + 0x1C, 0x3C, 0x30, 0x38, 0x30, 0x30, 0x30, 0x00, // Char 102 (f) + 0x00, 0x00, 0x7E, 0x62, 0x62, 0x7E, 0x02, 0x7E, // Char 103 (g) + 0x60, 0x60, 0x7E, 0x7E, 0x62, 0x62, 0x62, 0x00, // Char 104 (h) + 0x18, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, // Char 105 (i) + 0x00, 0x0C, 0x00, 0x0C, 0x0C, 0x0C, 0x7C, 0x00, // Char 106 (j) + 0x60, 0x60, 0x66, 0x6E, 0x7C, 0x7E, 0x66, 0x00, // Char 107 (k) + 0x30, 0x30, 0x30, 0x30, 0x30, 0x3C, 0x3C, 0x00, // Char 108 (l) + 0x00, 0x00, 0x7C, 0x7E, 0x6A, 0x6A, 0x6A, 0x00, // Char 109 (m) + 0x00, 0x00, 0x78, 0x6C, 0x64, 0x64, 0x64, 0x00, // Char 110 (n) + 0x00, 0x00, 0x7C, 0x46, 0x46, 0x46, 0x7E, 0x00, // Char 111 (o) + 0x00, 0x00, 0x7E, 0x66, 0x66, 0x7C, 0x60, 0x60, // Char 112 (p) + 0x00, 0x00, 0x7C, 0x6C, 0x6C, 0x3C, 0x0C, 0x0C, // Char 113 (q) + 0x00, 0x00, 0x7E, 0x76, 0x70, 0x70, 0x70, 0x00, // Char 114 (r) + 0x00, 0x00, 0x7C, 0x60, 0x7C, 0x04, 0x7C, 0x00, // Char 115 (s) + 0x00, 0x30, 0x78, 0x30, 0x30, 0x30, 0x38, 0x00, // Char 116 (t) + 0x00, 0x00, 0x6C, 0x6C, 0x6C, 0x6C, 0x3C, 0x00, // Char 117 (u) + 0x00, 0x00, 0x64, 0x64, 0x6C, 0x78, 0x70, 0x00, // Char 118 (v) + 0x00, 0x00, 0x56, 0x56, 0x56, 0x7E, 0x7E, 0x00, // Char 119 (w) + 0x00, 0x00, 0xEE, 0x6C, 0x38, 0x6C, 0xEE, 0x00, // Char 120 (x) + 0x00, 0x00, 0x4C, 0x4C, 0x4C, 0x7C, 0x0C, 0x7C, // Char 121 (y) + 0x00, 0x00, 0x7E, 0x18, 0x30, 0x60, 0x7E, 0x00, // Char 122 (z) + 0x0E, 0x18, 0x18, 0x30, 0x18, 0x18, 0x0E, 0x00, // Char 123 ({) + 0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x18, 0x00, // Char 124 (|) + 0xE0, 0x30, 0x30, 0x18, 0x30, 0x30, 0xE0, 0x00, // Char 125 (}) + 0x76, 0xDC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Char 126 (~) + 0x00, 0x10, 0x38, 0x6C, 0xC6, 0xC6, 0xFE, 0x00, // Char 127 (.) + 0x7C, 0xC6, 0xC0, 0xC0, 0xC6, 0x7C, 0x18, 0x70, // Char 128 (.) + 0xCC, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0x76, 0x00, // Char 129 (.) + 0x0E, 0x10, 0x7C, 0xC6, 0xFE, 0xC0, 0x7C, 0x00, // Char 130 (.) + 0x7C, 0x82, 0x7C, 0x0C, 0x7C, 0x6E, 0x7E, 0x00, // Char 131 (.) + 0x6C, 0x00, 0x7C, 0x0C, 0x7C, 0x6E, 0x7E, 0x00, // Char 132 (.) + 0xE0, 0x10, 0x78, 0x0C, 0x7C, 0xCC, 0x76, 0x00, // Char 133 (.) + 0x30, 0x30, 0x78, 0x0C, 0x7C, 0xCC, 0x76, 0x00, // Char 134 (.) + 0x00, 0x00, 0x7C, 0xC0, 0xC0, 0x7C, 0x18, 0x70, // Char 135 (.) + 0x7C, 0x82, 0x7C, 0xC6, 0xFE, 0xC0, 0x7C, 0x00, // Char 136 (.) + 0x66, 0x00, 0x7E, 0x66, 0x7E, 0x60, 0x7E, 0x00, // Char 137 (.) + 0xE0, 0x10, 0x7C, 0xC6, 0xFE, 0xC0, 0x7C, 0x00, // Char 138 (.) + 0x66, 0x00, 0x38, 0x38, 0x38, 0x38, 0x3C, 0x00, // Char 139 (.) + 0x7C, 0x82, 0x38, 0x18, 0x18, 0x18, 0x3C, 0x00, // Char 140 (.) + 0xE0, 0x10, 0x38, 0x18, 0x18, 0x18, 0x3C, 0x00, // Char 141 (.) + 0xC6, 0x00, 0x7C, 0xC6, 0xFE, 0xC6, 0xC6, 0x00, // Char 142 (.) + 0x38, 0x38, 0x7C, 0xC6, 0xFE, 0xC6, 0xC6, 0x00, // Char 143 (.) + 0x0E, 0x10, 0xFE, 0x60, 0x78, 0x60, 0xFE, 0x00, // Char 144 (.) + 0x00, 0x00, 0x7C, 0x12, 0x7E, 0xD0, 0x7E, 0x00, // Char 145 (.) + 0x7E, 0xC8, 0xC8, 0xFE, 0xC8, 0xC8, 0xCE, 0x00, // Char 146 (.) + 0x7C, 0x82, 0x7C, 0xC6, 0xC6, 0xC6, 0x7C, 0x00, // Char 147 (.) + 0x66, 0x00, 0x7C, 0x46, 0x46, 0x46, 0x7E, 0x00, // Char 148 (.) + 0xE0, 0x10, 0x7C, 0xC6, 0xC6, 0xC6, 0x7C, 0x00, // Char 149 (.) + 0x7C, 0x82, 0xCC, 0xCC, 0xCC, 0xCC, 0x76, 0x00, // Char 150 (.) + 0xE0, 0x10, 0xCC, 0xCC, 0xCC, 0xCC, 0x76, 0x00, // Char 151 (.) + 0xCC, 0x00, 0xCC, 0xCC, 0xCC, 0x7C, 0x0C, 0xF8, // Char 152 (.) + 0xC6, 0x7C, 0xC6, 0xC6, 0xC6, 0xC6, 0x7C, 0x00, // Char 153 (.) + 0xC6, 0x00, 0xC6, 0xC6, 0xC6, 0xC6, 0x7C, 0x00, // Char 154 (.) + 0x18, 0x7C, 0xD6, 0xD0, 0xD6, 0x7C, 0x18, 0x00, // Char 155 (.) + 0x38, 0x6C, 0x60, 0xF0, 0x60, 0xF2, 0xDC, 0x00, // Char 156 (.) + 0x66, 0x3C, 0x18, 0x7E, 0x18, 0x7E, 0x18, 0x00, // Char 157 (.) + 0xF8, 0xCC, 0xF8, 0xC4, 0xCC, 0xDE, 0xCC, 0x06, // Char 158 (.) + 0x0E, 0x1B, 0x18, 0x3C, 0x18, 0x18, 0xD8, 0x70, // Char 159 (.) + 0x0E, 0x10, 0x78, 0x0C, 0x7C, 0xCC, 0x76, 0x00, // Char 160 (.) + 0x0E, 0x10, 0x38, 0x18, 0x18, 0x18, 0x3C, 0x00, // Char 161 (.) + 0x0E, 0x10, 0x7C, 0xC6, 0xC6, 0xC6, 0x7C, 0x00, // Char 162 (.) + 0x0E, 0x10, 0xCC, 0xCC, 0xCC, 0xCC, 0x76, 0x00, // Char 163 (.) + 0x66, 0x98, 0xDC, 0x66, 0x66, 0x66, 0x66, 0x00, // Char 164 (.) + 0x66, 0x98, 0xE6, 0xF6, 0xDE, 0xCE, 0xC6, 0x00, // Char 165 (.) + 0x38, 0x0C, 0x3C, 0x34, 0x00, 0x7E, 0x00, 0x00, // Char 166 (.) + 0x38, 0x6C, 0x6C, 0x38, 0x00, 0x7C, 0x00, 0x00, // Char 167 (.) + 0x30, 0x00, 0x30, 0x60, 0xC6, 0xC6, 0x7C, 0x00, // Char 168 (.) + 0x00, 0x00, 0x00, 0xFC, 0xC0, 0xC0, 0x00, 0x00, // Char 169 (.) + 0x00, 0x00, 0x00, 0xFC, 0x0C, 0x0C, 0x00, 0x00, // Char 170 (.) + 0xC0, 0xC8, 0xD0, 0xFE, 0x46, 0x8C, 0x1E, 0x00, // Char 171 (.) + 0xC0, 0xC8, 0xD0, 0xEC, 0x5C, 0xBE, 0x0C, 0x00, // Char 172 (.) + 0x18, 0x00, 0x18, 0x18, 0x3C, 0x3C, 0x18, 0x00, // Char 173 (.) + 0x00, 0x36, 0x6C, 0xD8, 0x6C, 0x36, 0x00, 0x00, // Char 174 (.) + 0x00, 0xD8, 0x6C, 0x36, 0x6C, 0xD8, 0x00, 0x00, // Char 175 (.) + 0x22, 0x88, 0x22, 0x88, 0x22, 0x88, 0x22, 0x88, // Char 176 (.) + 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, // Char 177 (.) + 0xDB, 0x77, 0xDB, 0xEE, 0xDB, 0x77, 0xDB, 0xEE, // Char 178 (.) + 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, // Char 179 (.) + 0x18, 0x18, 0x18, 0x18, 0xF8, 0x18, 0x18, 0x18, // Char 180 (.) + 0x18, 0x18, 0xF8, 0x18, 0xF8, 0x18, 0x18, 0x18, // Char 181 (.) + 0x36, 0x36, 0x36, 0x36, 0xF6, 0x36, 0x36, 0x36, // Char 182 (.) + 0x00, 0x00, 0x00, 0x00, 0xFE, 0x36, 0x36, 0x36, // Char 183 (.) + 0x00, 0x00, 0xF8, 0x18, 0xF8, 0x18, 0x18, 0x18, // Char 184 (.) + 0x36, 0x36, 0xF6, 0x06, 0xF6, 0x36, 0x36, 0x36, // Char 185 (.) + 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, // Char 186 (.) + 0x00, 0x00, 0xFE, 0x06, 0xF6, 0x36, 0x36, 0x36, // Char 187 (.) + 0x36, 0x36, 0xF6, 0x06, 0xFE, 0x00, 0x00, 0x00, // Char 188 (.) + 0x36, 0x36, 0x36, 0x36, 0xFE, 0x00, 0x00, 0x00, // Char 189 (.) + 0x18, 0x18, 0xF8, 0x18, 0xF8, 0x00, 0x00, 0x00, // Char 190 (.) + 0x00, 0x00, 0x00, 0x00, 0xF8, 0x18, 0x18, 0x18, // Char 191 (.) + 0x18, 0x18, 0x18, 0x18, 0x1F, 0x00, 0x00, 0x00, // Char 192 (.) + 0x18, 0x18, 0x18, 0x18, 0xFF, 0x00, 0x00, 0x00, // Char 193 (.) + 0x00, 0x00, 0x00, 0x00, 0xFF, 0x18, 0x18, 0x18, // Char 194 (.) + 0x18, 0x18, 0x18, 0x18, 0x1F, 0x18, 0x18, 0x18, // Char 195 (.) + 0x00, 0x00, 0x00, 0x00, 0xFF, 0x00, 0x00, 0x00, // Char 196 (.) + 0x18, 0x18, 0x18, 0x18, 0xFF, 0x18, 0x18, 0x18, // Char 197 (.) + 0x18, 0x18, 0x1F, 0x18, 0x1F, 0x18, 0x18, 0x18, // Char 198 (.) + 0x36, 0x36, 0x36, 0x36, 0x37, 0x36, 0x36, 0x36, // Char 199 (.) + 0x36, 0x36, 0x37, 0x30, 0x3F, 0x00, 0x00, 0x00, // Char 200 (.) + 0x00, 0x00, 0x3F, 0x30, 0x37, 0x36, 0x36, 0x36, // Char 201 (.) + 0x36, 0x36, 0xF7, 0x00, 0xFF, 0x00, 0x00, 0x00, // Char 202 (.) + 0x00, 0x00, 0xFF, 0x00, 0xF7, 0x36, 0x36, 0x36, // Char 203 (.) + 0x36, 0x36, 0x37, 0x30, 0x37, 0x36, 0x36, 0x36, // Char 204 (.) + 0x00, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0x00, // Char 205 (.) + 0x36, 0x36, 0xF7, 0x00, 0xF7, 0x36, 0x36, 0x36, // Char 206 (.) + 0x18, 0x18, 0xFF, 0x00, 0xFF, 0x00, 0x00, 0x00, // Char 207 (.) + 0x36, 0x36, 0x36, 0x36, 0xFF, 0x00, 0x00, 0x00, // Char 208 (.) + 0x00, 0x00, 0xFF, 0x00, 0xFF, 0x18, 0x18, 0x18, // Char 209 (.) + 0x00, 0x00, 0x00, 0x00, 0xFF, 0x36, 0x36, 0x36, // Char 210 (.) + 0x36, 0x36, 0x36, 0x36, 0x3F, 0x00, 0x00, 0x00, // Char 211 (.) + 0x18, 0x18, 0x1F, 0x18, 0x1F, 0x00, 0x00, 0x00, // Char 212 (.) + 0x00, 0x00, 0x1F, 0x18, 0x1F, 0x18, 0x18, 0x18, // Char 213 (.) + 0x00, 0x00, 0x00, 0x00, 0x3F, 0x36, 0x36, 0x36, // Char 214 (.) + 0x36, 0x36, 0x36, 0x36, 0xFF, 0x36, 0x36, 0x36, // Char 215 (.) + 0x18, 0x18, 0xFF, 0x18, 0xFF, 0x18, 0x18, 0x18, // Char 216 (.) + 0x18, 0x18, 0x18, 0x18, 0xF8, 0x00, 0x00, 0x00, // Char 217 (.) + 0x00, 0x00, 0x00, 0x00, 0x1F, 0x18, 0x18, 0x18, // Char 218 (.) + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // Char 219 (.) + 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, // Char 220 (.) + 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, 0xF0, // Char 221 (.) + 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0x0F, // Char 222 (.) + 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, // Char 223 (.) + 0x00, 0x00, 0x74, 0xCC, 0xC8, 0xDC, 0x76, 0x00, // Char 224 (.) + 0x78, 0xCC, 0xD8, 0xCC, 0xC6, 0xC6, 0xDC, 0x40, // Char 225 (.) + 0xFE, 0x62, 0x60, 0x60, 0x60, 0x60, 0xF0, 0x00, // Char 226 (.) + 0x00, 0x02, 0x7E, 0xEC, 0x6C, 0x6C, 0x48, 0x00, // Char 227 (.) + 0xFE, 0x62, 0x30, 0x18, 0x30, 0x62, 0xFE, 0x00, // Char 228 (.) + 0x00, 0x00, 0x7E, 0xD0, 0xC8, 0xC8, 0x70, 0x00, // Char 229 (.) + 0x00, 0x00, 0xCC, 0xCC, 0xCC, 0xCC, 0xF8, 0x80, // Char 230 (.) + 0x00, 0x00, 0x7E, 0xD8, 0x18, 0x18, 0x10, 0x00, // Char 231 (.) + 0x38, 0x10, 0x7C, 0xD6, 0xD6, 0x7C, 0x10, 0x38, // Char 232 (.) + 0x7C, 0xC6, 0xC6, 0xFE, 0xC6, 0xC6, 0x7C, 0x00, // Char 233 (.) + 0x7C, 0xC6, 0xC6, 0xC6, 0x6C, 0x28, 0xEE, 0x00, // Char 234 (.) + 0x3C, 0x22, 0x18, 0x7C, 0xCC, 0xCC, 0x78, 0x00, // Char 235 (.) + 0x00, 0x00, 0x66, 0x99, 0x99, 0x66, 0x00, 0x00, // Char 236 (.) + 0x00, 0x06, 0x7C, 0x9E, 0xF2, 0x7C, 0xC0, 0x00, // Char 237 (.) + 0x00, 0x00, 0x7C, 0xC0, 0xF8, 0xC0, 0x7C, 0x00, // Char 238 (.) + 0x00, 0x7C, 0xC6, 0xC6, 0xC6, 0xC6, 0xC6, 0x00, // Char 239 (.) + 0x00, 0xFE, 0x00, 0xFE, 0x00, 0xFE, 0x00, 0x00, // Char 240 (.) + 0x18, 0x18, 0x7E, 0x18, 0x18, 0x00, 0x7E, 0x00, // Char 241 (.) + 0x30, 0x18, 0x0C, 0x18, 0x30, 0x00, 0x7C, 0x00, // Char 242 (.) + 0x18, 0x30, 0x60, 0x30, 0x18, 0x00, 0x7C, 0x00, // Char 243 (.) + 0x0E, 0x1B, 0x1B, 0x18, 0x18, 0x18, 0x18, 0x18, // Char 244 (.) + 0x18, 0x18, 0x18, 0x18, 0x18, 0xD8, 0xD8, 0x70, // Char 245 (.) + 0x00, 0x18, 0x00, 0x7E, 0x00, 0x18, 0x00, 0x00, // Char 246 (.) + 0x00, 0x76, 0xDC, 0x00, 0x76, 0xDC, 0x00, 0x00, // Char 247 (.) + 0x38, 0x6C, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, // Char 248 (.) + 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, // Char 249 (.) + 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, // Char 250 (.) + 0x0F, 0x0C, 0x0C, 0x0C, 0xEC, 0x6C, 0x3C, 0x00, // Char 251 (.) + 0xD8, 0x6C, 0x6C, 0x6C, 0x00, 0x00, 0x00, 0x00, // Char 252 (.) + 0xF0, 0x30, 0xC0, 0xF0, 0x00, 0x00, 0x00, 0x00, // Char 253 (.) + 0x00, 0x00, 0x3C, 0x3C, 0x3C, 0x3C, 0x00, 0x00, // Char 254 (.) + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // Char 255 (.) +}; + +#endif diff --git a/font_patch/info.txt b/font_patch/info.txt new file mode 100644 index 0000000..51a638d --- /dev/null +++ b/font_patch/info.txt @@ -0,0 +1 @@ +libdragon: include/font.h \ No newline at end of file diff --git a/header.ed64 b/header.ed64 new file mode 100644 index 0000000000000000000000000000000000000000..988a7e0e82d5f9315109836e198fa767636c48ce GIT binary patch literal 4096 zcmcguU2Ggz75?t*#J=ln*jab&Y@A5G>&*Bkp=g8b)J^IiihfIWjajTDu*xrjhs40XV1OGafMO`Pnm@K;85A5Ks3KHJtPOHqP74 ze9`msOU9masijTNca}@19N2zNi2g%Dbmy>xOmH0wBcIi9fK+2`a~)viJ+QrhBC`wP zbwhVFM$H&~jc3vd2H(P;h*56FVrJTnz6pE(c}O?yBzwMG-P1LLj5*^=iIl9XRB0`F zeFKpWP!3&?G-{fkVI=cT%mrEFtDduQ49$`$ZpRc;LZWN5q z2F_zLWDSL^p^!BcvW7y|5a|WuTT^phTEiQP*LASYTHL^S(nMMw%(Hg5Pv5lol;PVv zPhVcM@6cyAB^bB({zrLYyFA(o?+)6$Gv1`Vj`+Zo%bGX3V}B<{Y1h4@?Vl5A?TUw| zT|d19(V;!@scFv}VxI1TvC9@a4gU%jTy6j)Q*Lon&N zyO?)yI^7B8ogVd|r}$3u4fvM$R=kBi3cp+^;*;{AqhO&j=rK;BbQrzj%(4CAa=i@? z%-Z6j^6-*8h^0|aJTTo)UfZ&RA}+7>Q>m5eFZJW)Qoo52rjGTS7PSc~%)8;rWrH&#xr(g9*LFUUoNQnjtM9Pl4kUN3$-uX$g}TZW z=G1ocUg_e!aue*%3hY{*^3%^Geca@upI&9|0<|=A&Ezq&ugKnP?C(m)S88BxCUoa| zdNW6bYUHf3n{li#hC2Ed%D_Bh75RyAAJM)=vfq^=NR+np?EL2 z(OC>eHM~1oK`Dwb9G$~x^aJ?Ow=v1P_6YCVDc-er@vfcbU3*{jA}Y+82ia5UHGlyW z2hzmNnzH)li^!>}>9;QXE`9zWa!xfQu8>&RlVwOOA+dzS5)uph_r8!=LShMtB_x)R zSVCe6i6tZ!#!rXD!@hNdeQSz+>n`@KY4)xALgGoSLo%*Qt$YS1=>z5}D&Ej(=sPtE z%w> z&?V@5H2Yv(dBm;^ZZmJii{lFe%NS^lU;ZHm+`TEqxT(~=^b>TaurKUyKa5oBgBK5A zp8n%_Cv!aE(KD1c<(av#6MCEYkW=)22{H5<#_wT2G8haEmNRi9{G~a>?p}z|IgAz2pZlmYb7LO!PYwn=u*YzfkLeFmkGdDVn z?3IZ1*t1-UH2Xv&hS&Mi?NR)eA?f1GAvL4!JMteuaMFw92u1Dv3fgxCS~9X&0`2GEZTbfWGZ;v%8*^;gB z4sK_0@&vgTx44T}q|(*I`Id5ePb5NU>n#7YaqNVhtsmcP`t=&vidSqSPE?u1Q%Faj zknI7THZS#rCDnKmM}w5y)r?cAe$o9%-&6V9@`F#`)-k9~*i@bqHr+FC1$4;{l)0!H zSLKA1B-=W_6joCHcSuTP_jEVvbPF zhIRGVyS_!%`{)48s3qnIHsX4R$%C@3ik9qsBT2^I6AhuegO_Y0y~*7WQl)?&w>fIO zMIIv-!cW|2kTesZ$!$yRGhw#4TVzKa78_S(CwfhKx6ENZadEM&-YFF4+aFdK-T#HS zF+LH`HNwTu8*0Dd6O_l@9W-9I<1Tx#tW|@n>A~!kmj3Gxmjs#gwe;+jYggOn5z$!KwW3=;U0P>+vn#Fx+;*LHhT;DB@rHfCd J>SlNQ^B-mFP%Que literal 0 HcmV?d00001 diff --git a/ini.c b/ini.c new file mode 100644 index 0000000..a100222 --- /dev/null +++ b/ini.c @@ -0,0 +1,301 @@ +/* inih -- simple .INI file parser + +inih is released under the New BSD license (see LICENSE.txt). Go to the project +home page for more info: + +http://code.google.com/p/inih/ + +*/ + +#include +#include +#include + + +#include "ini.h" + +#if !INI_USE_STACK +#include +#endif + +#define MAX_SECTION 50 +#define MAX_NAME 50 + + +/* Strip whitespace chars off end of given string, in place. Return s. */ +static char* rstrip(char* s) +{ + char* p = s + strlen(s); + while (p > s && isspace((unsigned char)(*--p))) + *p = '\0'; + return s; +} + +/* Return pointer to first non-whitespace char in given string. */ +static char* lskip(const char* s) +{ + while (*s && isspace((unsigned char)(*s))) + s++; + return (char*)s; +} + +/* Return pointer to first char c or ';' comment in given string, or pointer to + null at end of string if neither found. ';' must be prefixed by a whitespace + character to register as a comment. */ +static char* find_char_or_comment(const char* s, char c) +{ + int was_whitespace = 0; + while (*s && *s != c && !(was_whitespace && *s == ';')) { + was_whitespace = isspace((unsigned char)(*s)); + s++; + } + return (char*)s; +} + +/* Version of strncpy that ensures dest (size bytes) is null-terminated. */ +static char* strncpy0(char* dest, const char* src, size_t size) +{ + strncpy(dest, src, size); + dest[size - 1] = '\0'; + return dest; +} + + +/* See documentation in header file. */ +int ini_parse_str(char* ini_string, + int (*handler)(void*, const char*, const char*, + const char*), + void* user) +{ + /* Uses a fair bit of stack (use heap instead if you need to) */ +#if INI_USE_STACK + char line[INI_MAX_LINE]; +#else + char* line; +#endif + char section[MAX_SECTION] = ""; + char prev_name[MAX_NAME] = ""; + + char* start; + char* end; + char* name; + char* value; + int lineno = 0; + int error = 0; + +#if !INI_USE_STACK + line = (char*)malloc(INI_MAX_LINE); + if (!line) { + return -2; + } +#endif + + + int i=1; + char *ptr; + +// initialisieren und ersten Abschnitt erstellen + ptr = strtok(ini_string, "\n"); + + + /* Scan through file line by line */ + while(ptr != NULL) { + + sprintf(line, "%s\n",ptr); + ptr = strtok(NULL, "\n"); + // while (line=gets( ini_string) != NULL) { + lineno++; + + start = line; +#if INI_ALLOW_BOM + if (lineno == 1 && (unsigned char)start[0] == 0xEF && + (unsigned char)start[1] == 0xBB && + (unsigned char)start[2] == 0xBF) { + start += 3; + } +#endif + start = lskip(rstrip(start)); + + if (*start == ';' || *start == '#') { + /* Per Python ConfigParser, allow '#' comments at start of line */ + } +#if INI_ALLOW_MULTILINE + else if (*prev_name && *start && start > line) { + /* Non-black line with leading whitespace, treat as continuation + of previous name's value (as per Python ConfigParser). */ + if (!handler(user, section, prev_name, start) && !error) + error = lineno; + } +#endif + else if (*start == '[') { + /* A "[section]" line */ + end = find_char_or_comment(start + 1, ']'); + if (*end == ']') { + *end = '\0'; + strncpy0(section, start + 1, sizeof(section)); + *prev_name = '\0'; + } + else if (!error) { + /* No ']' found on section line */ + error = lineno; + } + } + else if (*start && *start != ';') { + /* Not a comment, must be a name[=:]value pair */ + end = find_char_or_comment(start, '='); + if (*end != '=') { + end = find_char_or_comment(start, ':'); + } + if (*end == '=' || *end == ':') { + *end = '\0'; + name = rstrip(start); + value = lskip(end + 1); + end = find_char_or_comment(value, '\0'); + if (*end == ';') + *end = '\0'; + rstrip(value); + + /* Valid name[=:]value pair found, call handler */ + strncpy0(prev_name, name, sizeof(prev_name)); + if (!handler(user, section, name, value) && !error) + error = lineno; + } + else if (!error) { + /* No '=' or ':' found on name[=:]value line */ + error = lineno; + } + } + } + +#if !INI_USE_STACK + free(line); +#endif + + return error; +} + + + +/* See documentation in header file. */ +int ini_parse_file(FILE* file, + int (*handler)(void*, const char*, const char*, + const char*), + void* user) +{ + /* Uses a fair bit of stack (use heap instead if you need to) */ +#if INI_USE_STACK + char line[INI_MAX_LINE]; +#else + char* line; +#endif + char section[MAX_SECTION] = ""; + char prev_name[MAX_NAME] = ""; + + char* start; + char* end; + char* name; + char* value; + int lineno = 0; + int error = 0; + +#if !INI_USE_STACK + line = (char*)malloc(INI_MAX_LINE); + if (!line) { + return -2; + } +#endif + + /* Scan through file line by line */ + while (fgets(line, INI_MAX_LINE, file) != NULL) { + lineno++; + + start = line; +#if INI_ALLOW_BOM + if (lineno == 1 && (unsigned char)start[0] == 0xEF && + (unsigned char)start[1] == 0xBB && + (unsigned char)start[2] == 0xBF) { + start += 3; + } +#endif + start = lskip(rstrip(start)); + + if (*start == ';' || *start == '#') { + /* Per Python ConfigParser, allow '#' comments at start of line */ + } +#if INI_ALLOW_MULTILINE + else if (*prev_name && *start && start > line) { + /* Non-black line with leading whitespace, treat as continuation + of previous name's value (as per Python ConfigParser). */ + if (!handler(user, section, prev_name, start) && !error) + error = lineno; + } +#endif + else if (*start == '[') { + /* A "[section]" line */ + end = find_char_or_comment(start + 1, ']'); + if (*end == ']') { + *end = '\0'; + strncpy0(section, start + 1, sizeof(section)); + *prev_name = '\0'; + } + else if (!error) { + /* No ']' found on section line */ + error = lineno; + } + } + else if (*start && *start != ';') { + /* Not a comment, must be a name[=:]value pair */ + end = find_char_or_comment(start, '='); + if (*end != '=') { + end = find_char_or_comment(start, ':'); + } + if (*end == '=' || *end == ':') { + *end = '\0'; + name = rstrip(start); + value = lskip(end + 1); + end = find_char_or_comment(value, '\0'); + if (*end == ';') + *end = '\0'; + rstrip(value); + + /* Valid name[=:]value pair found, call handler */ + strncpy0(prev_name, name, sizeof(prev_name)); + if (!handler(user, section, name, value) && !error) + error = lineno; + } + else if (!error) { + /* No '=' or ':' found on name[=:]value line */ + error = lineno; + } + } + } + +#if !INI_USE_STACK + free(line); +#endif + + return error; +} + +/* See documentation in header file. */ +int ini_parse(const char* filename, + int (*handler)(void*, const char*, const char*, const char*), + void* user) +{ + FILE* file; + int error; + + // file = fopen(filename, "r"); + + + fputs(filename, file); + + + + + if (!file) + return -1; + error = ini_parse_file(file, handler, user); + fclose(file); + return error; +} diff --git a/ini.h b/ini.h new file mode 100644 index 0000000..10965c2 --- /dev/null +++ b/ini.h @@ -0,0 +1,77 @@ +/* inih -- simple .INI file parser + +inih is released under the New BSD license (see LICENSE.txt). Go to the project +home page for more info: + +http://code.google.com/p/inih/ + +*/ + +#ifndef __INI_H__ +#define __INI_H__ + +/* Make this header file easier to include in C++ code */ +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/* Parse given INI-style file. May have [section]s, name=value pairs + (whitespace stripped), and comments starting with ';' (semicolon). Section + is "" if name=value pair parsed before any section heading. name:value + pairs are also supported as a concession to Python's ConfigParser. + + For each name=value pair parsed, call handler function with given user + pointer as well as section, name, and value (data only valid for duration + of handler call). Handler should return nonzero on success, zero on error. + + Returns 0 on success, line number of first error on parse error (doesn't + stop on first error), -1 on file open error, or -2 on memory allocation + error (only when INI_USE_STACK is zero). +*/ +int ini_parse(const char* filename, + int (*handler)(void* user, const char* section, + const char* name, const char* value), + void* user); + +/* Same as ini_parse(), but takes a FILE* instead of filename. This doesn't + close the file when it's finished -- the caller must do that. */ +int ini_parse_file(FILE* file, + int (*handler)(void* user, const char* section, + const char* name, const char* value), + void* user); + +int ini_parse_str(char* ini_string, + int (*handler)(void*, const char*, const char*, + const char*), + void* user); + +/* Nonzero to allow multi-line value parsing, in the style of Python's + ConfigParser. If allowed, ini_parse() will call the handler with the same + name for each subsequent line parsed. */ +#ifndef INI_ALLOW_MULTILINE +#define INI_ALLOW_MULTILINE 1 +#endif + +/* Nonzero to allow a UTF-8 BOM sequence (0xEF 0xBB 0xBF) at the start of + the file. See http://code.google.com/p/inih/issues/detail?id=21 */ +#ifndef INI_ALLOW_BOM +#define INI_ALLOW_BOM 1 +#endif + +/* Nonzero to use stack, zero to use heap (malloc/free). */ +#ifndef INI_USE_STACK +#define INI_USE_STACK 1 +#endif + +/* Maximum line length for any line in INI file. */ +#ifndef INI_MAX_LINE +#define INI_MAX_LINE 200 +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* __INI_H__ */ diff --git a/mem.c b/mem.c new file mode 100644 index 0000000..87ed68b --- /dev/null +++ b/mem.c @@ -0,0 +1,160 @@ + +#include "types.h" +#include "everdrive.h" +#include "sys.h" + +u8 spi_dma; +#include "errors.h" +#include "mem.h" + +u8 memSpiReadDma(void *dst, u16 slen); +u8 memSpiReadPio(void *dst, u16 slen); +u8 mem_buff[512]; + +void memSpiSetDma(u8 mode) { + spi_dma = mode; +} + +void memcopy(void *src, void *dst, u16 len) { + + u8 *s = (u8 *) src; + u8 *d = (u8 *) dst; + while (len--)*d++ = *s++; +} + +void memfill(void *dst, u8 val, u16 len) { + u8 *d = (u8 *) dst; + while (len--)*d++ = val; +} + + +// buff len +u8 memSpiRead(void *dst, u16 slen) { + + u8 copy_to_rom = 0; + u32 addr = (u32) dst; //if ROM_ADDR 0xb0000000 + if (addr >= ROM_ADDR && addr < ROM_END_ADDR)copy_to_rom = 1; + + //if (copy_to_rom || spi_dma) { + if ((copy_to_rom || spi_dma) && addr % 4 == 0) { + return memSpiReadDma(dst, slen); + } else { + return memSpiReadPio(dst, slen); + + } + +} + +u8 memSpiReadPio(void *dst, u16 slen) { + + u16 i; + u16 u; + u8 *ptr8 = (u8 *) dst; + + + + for (i = 0; i < slen; i++) { + + evd_SDdatReadMode(1); + for (u = 0; u < 65535; u++)if ((evd_SPI(0xff) & 0xf1) == 0xf0)break; + evd_SDdatReadMode(0); + if (u == 65535) { + evd_spiSSOff(); + return DISK_RD_FE_TOUT; + } + + for (u = 0; u < 512; u++)*ptr8++ = evd_SPI(0xff); + + u = evd_isSDMode() ? 8 : 2; + + while (u--) { + // console_printf("XRC: %02X", evd_SPI(0xff)); + //console_printf("%02X\n", evd_SPI(0xff)); + u--; + evd_SPI(0xff); + evd_SPI(0xff); + } + //evd_SPI(0xff); + //evd_SPI(0xff); + } + + + return 0; +} + +u8 memSpiReadDma(void *dst, u16 slen) { + + u8 resp = 0; + u8 copy_to_rom = 0; + u32 addr = (u32) dst; + + evd_SDdatReadMode(0); + // console_printf("dma\n"); + if (addr >= ROM_ADDR && addr < ROM_END_ADDR)copy_to_rom = 1; + + if (copy_to_rom) { + + return evd_mmcReadToCart(addr, slen); + + } else { + + resp = evd_mmcReadToCart(0, slen); + dma_read_s(dst, ROM_ADDR, slen * 512); + } + + + return resp; +} + +u8 memSpiWrite(void *src) { + + u16 i; + + u8 *ptr8 = (u8 *) src; + + if ((u32) src >= ROM_ADDR && (u32) src < ROM_END_ADDR) { + dma_read_s(mem_buff, (u32) src, 512); + for (i = 0; i < 512; i++)mem_spi(mem_buff[i]); + } else { + for (i = 0; i < 512; i++)mem_spi(*ptr8++); + } + + + return 0; +} + +void memSpiBusy() { + + while (evd_isSpiBusy()); + +} + +void memRomWrite32(u32 addr, u32 val) { + + vu32 *ptr = (u32 *) (addr + ROM_ADDR); + vu8 tmp; + + tmp = *ptr; + *ptr = val; + tmp = *ptr; +} + +u32 memRomRead32(u32 addr) { + + vu32 *ptr = (u32 *) (addr + ROM_ADDR); + vu8 tmp; + vu32 val; + + tmp = *ptr; + val = *ptr; + + return val; +} + + +/* +u8 mem_spi(u8 dat) { + return evd_SPI(dat); +} + + */ diff --git a/mem.h b/mem.h new file mode 100644 index 0000000..89f0a28 --- /dev/null +++ b/mem.h @@ -0,0 +1,39 @@ +/* + * File: mem.h + * Author: krik + * + * Created on 2 Èþíü 2011 ã., 4:07 + */ + +#ifndef _MEM_H +#define _MEM_H +#include "types.h" + +#define SPI_SPEED_INIT 2 +#define SPI_SPEED_25 1 +#define SPI_SPEED_50 0 + +#define mem_spi evd_SPI +#define memSpiSetSpeed evd_setSpiSpeed +#define memSpiIsBusy evd_isSpiBusy +#define memSpiSSOff evd_spiSSOff +#define memSpiSSOn evd_spiSSOn + + +void memSpiSSOn(); +void memSpiSSOff(); +void memSpiBusy(); +u8 memSpiIsBusy(); +void memSpiSetSpeed(u8 speed); +void spiReadBlock(void *dat); +void spiWriteBlock(void *dat); +u8 memSpiRead(void *dst, u16 slen); +u8 memSpiWrite(void *src); +//u8 mem_spi(u8 dat); +void memfill(void *dst, u8 val, u16 len); +void memcopy(void *src, void *dst, u16 len); +void memSpiSetDma(u8 mode); +void memRomWrite32(u32 addr, u32 val); +u32 memRomRead32(u32 addr); +#endif /* _MEM_H */ + diff --git a/menu.c b/menu.c new file mode 100644 index 0000000..5c3208e --- /dev/null +++ b/menu.c @@ -0,0 +1,5784 @@ +/* + * ALT64 Menu v0.1.8.6 - 2013 + * a menu for the Everdrive64 + * based on libdragon, Neo64Menu, ED64IO, libn64-hkz, libmikmod + * by saturnu + */ + + +#include +#include +#include +#include +#include +#include + +//libdragon n64 lib +#include + +//everdrive system libs +#include "types.h" +#include "sys.h" +#include "everdrive.h" +#include "everdrive.h" + +//filesystem +#include "disk.h" +#include "fat.h" + +//utils +#include "utils.h" + +//config file on sd +#include "ini.h" +#include "strlib.h" + +//menu header +#include "menu.h" + +//sound +#include + +//cheats +struct gscEntry { + char *description; + char *gscodes; + u16 count; + u16 state; + u16 mask; + u16 value; +}; +typedef struct gscEntry gscEntry_t; + +gscEntry_t gGSCodes[256]; + +#ifdef USE_TRUETYPE +#define STB_TRUETYPE_IMPLEMENTATION +#include "stb_truetype.h" + +struct glyph { + int xoff; + int yoff; + int adv; + int lsb; + float scale; + unsigned int color; + unsigned char *alpha; + sprite_t sprite; +}; +typedef struct glyph glyph_t; + +glyph_t sans[96]; +glyph_t serif[96]; +#endif + + +typedef struct +{ + uint32_t type; + uint32_t color; + char filename[MAX_FILENAME_LEN+1]; +} direntry_t; + + +//ini file +typedef struct +{ + int version; + const char* name; + char* background_image; + char* border_color_1; + char* border_color_2; + char* box_color; + char* selection_color; + char* list_font_color; + char* list_dir_font_color; + char* selection_font_color; + char* mempak_path; + char* save_path; + int sound_on; + int page_display; + int tv_mode; + int quick_boot; + int enable_colored_list; + int ext_type; + int cd_behaviour; + int scroll_behaviour; + int text_offset; + int hide_sysfolder; + int sd_speed; + +} configuration; + + + + + +volatile u32 *romaddr_ptr = (u32 *) ROM_ADDR; +unsigned int gBootCic=CIC_6102; +u8 debug=DBG_MODE; + +static uint8_t mempak_data[128 * 256]; +static void *bg_buffer; +void *__safe_bg_buffer; + +#define __get_buffer( x ) __safe_buffer[(x)-1] +extern uint32_t __bitdepth; +extern uint32_t __width; +extern uint32_t __height; +extern void *__safe_buffer[]; + +char firmware_str[64]; +int firm_found=0; +char rom_config[10]; + +display_context_t lockVideo(int wait); + +int select_mode = 0; +int toplist_reload=1; +int toplist_cursor=0; +char toplist15[15][256]; + +int fat_initialized=0; +int exit_ok = 0; +int boot_cic=0; +int boot_save=0; +int cursor_line=0; +int cursor_lastline=0; +u16 cursor_history[32]; +u16 cursor_history_pos=0; +u8 empty=0; +u8 playing=0; +u8 gb_load_y=0; + +//start with filebrowser menu key settings +int input_mapping=1; +/* 1=filemanager + * 2=mempak-menu + * 3=charinput + * 4=rom loaded + * 5=format mpk + * 6=restore mpk + * 7=rom config box + * 8=toplist + * 9=mpk choice + * 10=mpk quick-backup + * 11=mp3 + * 98= A/B abort screen + */ + + +//holds the string of the character input screen result +int text_input_on=0; + +//char input vars +int x,y,position,set; + +unsigned char input_text[32]; +uint32_t chr_forecolor; +uint32_t chr_backcolor; + + +//save type still set - save todo after reboot +int save_reboot=0; + +//cart id from rom header +unsigned char cartID[4]; +char curr_dirname[64]; +char pwd[64]; +char rom_filename[128]; + +u32 rom_buff[128]; //rom buffer +u8 *rom_buff8; //rom buffer + +u8 *firmware; +u8 gbload=0; + +int cheats_on=0; +int checksum_fix_on=0; +short int gCheats = 0; /* 0 = off, 1 = select, 2 = all */ +short int force_tv = 0; +short int boot_country=0; + + +static resolution_t res = RESOLUTION_320x240; + +//background sprites +sprite_t *loadPng(u8 *png_filename); +sprite_t *background; //background +sprite_t *background0; //splash screen + +//config file theme settings +u32 border_color_1=0xFFFFFFFF; //hex 0xRRGGBBAA AA=transparenxy +u32 border_color_2=0x3F3F3FFF; +u32 box_color=0x00000080; +u32 selection_color=0x6495ED60; +u32 selection_font_color=0xFFFFFFFF; +u32 list_font_color=0xFFFFFFFF; +u32 list_dir_font_color=0xFFFFFFFF; + +char* border_color_1_s; +char* border_color_2_s; +char* box_color_s; +char* selection_color_s; +char* selection_font_color_s; +char* list_font_color_s; +char* list_dir_font_color_s; + +char* mempak_path; +char* save_path; + + +u8 sound_on=0; +u8 page_display=0; +int text_offset=0; +u8 tv_mode=0; // 1=ntsc 2=pal 3=mpal 0=default automatic +u8 quick_boot=0; +u8 enable_colored_list=0; +u8 cd_behaviour=0; //0=first entry 1=last entry +u8 scroll_behaviour=0; //1=classic 0=new page-system +u8 ext_type=0; //0=classic 1=org os +u8 sd_speed=1; // 1=25Mhz 2=50Mhz +u8 hide_sysfolder=0; +char* background_image; + +//toplist helper +int list_pos_backup[3]; +char list_pwd_backup[256]; + +char dirz[512] = "rom://"; + +short int gCursorX; +short int gCursorY; + +int count = 0; +int page = 0; +int cursor = 0; +direntry_t *list; + + + + +int filesize( FILE *pFile ) +{ + fseek( pFile, 0, SEEK_END ); + int lSize = ftell( pFile ); + rewind( pFile ); + + return lSize; +} + +sprite_t *read_sprite( const char * const spritename ) +{ + FILE *fp = fopen( spritename, "r" ); + + if( fp ) + { + sprite_t *sp = malloc( filesize( fp ) ); + fread( sp, 1, filesize( fp ), fp ); + fclose( fp ); + + return sp; + } + else + { + return 0; + } +} + + +void drawSelection(display_context_t disp,int p){ + + +int s_x=23+(text_offset*8); + + if(scroll_behaviour){ + + + if(select_mode){ + + if(cursor_lastline>cursor && cursor_line > 0) { + cursor_line--; + } + + if(cursor_lastlinetype == DT_DIR && second->type != DT_DIR) + { + /* First should be first */ + return -1; + } + + if(first->type != DT_DIR && second->type == DT_DIR) + { + /* First should be second */ + return 1; + } + + return strcmp(first->filename, second->filename); +} + +int compare_int (const void *a, const void *b) +{ + const int *ia = (const int *)a; // casting pointer types + const int *ib = (const int *)b; + return *ia - *ib; +} + +int compare_int_reverse (const void *a, const void *b) +{ + const int *ia = (const int *)a; // casting pointer types + const int *ib = (const int *)b; + return *ib - *ia; +} + +/* +direntry_t *populate_dir(int *count) +{ + //* Grab a slot + direntry_t *list = malloc(sizeof(direntry_t)); + *count = 1; + + //* Grab first + dir_t buf; + int ret = dir_findfirst(dirz, &buf); //replace + + if( ret != 0 ) + { + //* Free stuff + free(list); + *count = 0; + + //* Dir was bad! + return 0; + } + + //* Copy in loop + while( ret == 0 ) + { + list[(*count)-1].type = buf.d_type; + strcpy(list[(*count)-1].filename, buf.d_name); + + // Grab next + ret = dir_findnext(dirz,&buf); //replace + + if( ret == 0 ) + { + (*count)++; + list = realloc(list, sizeof(direntry_t) * (*count)); + } + } + + if(*count > 0) + { + /*Should sort! + qsort(list, *count, sizeof(direntry_t), compare); + } + + return list; +} +*/ + +void free_dir(direntry_t *dirz) +{ + if(dirz) { free(dirz); } +} + +void new_scroll_pos(int *cursor, int *page, int max, int count) +{ + /* Make sure windows too small can be calculated right */ + if(max > count) { max = count; } + + /* Bounds checking */ + if(*cursor >= count) + { + *cursor = count-1; + } + + if(*cursor < 0) + { + *cursor = 0; + } + + /* Scrolled up? */ + if(*cursor < *page) + { + *page = *cursor; + return; + } + + /* Scrolled down/ */ + if(*cursor >= (*page + max)) + { + *page = (*cursor - max) + 1; + return; + } + + /* Nothing here, should be good! */ +} + +void display_dir(direntry_t *list, int cursor, int page, int max, int count, display_context_t disp) +{ + + //system color + uint32_t forecolor=0; + uint32_t forecolor_menu=0; + uint32_t backcolor; + backcolor = graphics_make_color(0x00, 0x00, 0x00, 0xFF); //bg + forecolor_menu = graphics_make_color(0xFF, 0xFF, 0xFF, 0xFF); //fg + + graphics_set_color (list_font_color, backcolor); + + u8 c_pos[MAX_LIST+1]; + int c_pos_counter=0; + + c_pos[c_pos_counter++]=0; + + u8 c_dirname[64]; + + if(page_display){ + + u8 pi = page/20; + u8 ci=0; + + if(count%20==0) + ci = (count-1)/20; + else + ci = count/20; + sprintf(c_dirname, "%i/%i SD:/%s", pi+1, ci+1, pwd); + } + else{ + sprintf(c_dirname, "SD:/%s", pwd); + } + char sel_str[128]; + + + + //printText("Directory: ", 3, 4, disp); + printText(c_dirname, 3, 4, disp); + + int firstrun=1; + /* Page bounds checking */ + if(max > count) //cound = dir ectrys starting at 1 + { + max = count; + } + + /* Cursor bounds checking */ + if(cursor >= (page + max)) + { + cursor = (page + max) - 1; + } + + if(cursor < page) + { + cursor = page; + } + + if( max == 0 ) + { + printText("dir empty...", 3, 6, disp); + sprintf(sel_str, "dir empty..."); + empty=1; + }else{ + empty=0; + } + + + + //strcpy(list[(*count)-1].filename, buf.d_name); + + //last page anti ghosting entries + if(page == (count/20)*20) + max=count%20; + + for(int i = page; i < (page + max); i++) //from page to page + max + { + + if(list[i].type == DT_DIR) + { + char tmpdir[(CONSOLE_WIDTH-5)+1]; + strncpy(tmpdir, list[i].filename, CONSOLE_WIDTH-5); + + tmpdir[CONSOLE_WIDTH-5] = 0; + + + + //char dir_str[128]; + char *dir_str; + dir_str = malloc(slen(tmpdir)+3); + + + if(i == cursor){ + sprintf(dir_str, " [%s]", tmpdir); + sprintf(sel_str, " [%s]", tmpdir); + // if(cd_behaviour==0) + if(scroll_behaviour) + drawSelection(disp,i); + + c_pos[c_pos_counter++]=1; + + } + else{ + sprintf(dir_str, "[%s]", tmpdir); + c_pos[c_pos_counter++]=0; + } + graphics_set_color (list_dir_font_color, backcolor); + if(firstrun){ + + printText(dir_str, 3, 6, disp); + firstrun=0; + } + else{ + + printText(dir_str, 3, -1, disp); + } + free(dir_str); + } + else //if(list[i].type == DT_REG) + { + + int fcolor=list[i].color; + + if(fcolor!=0){ + + switch(fcolor){ + + case 1: forecolor = graphics_make_color(0xFF, 0xFF, 0xFF, 0xFF); //common (white) + break; + case 2: forecolor = graphics_make_color(0x00, 0xFF, 0x00, 0xCF); //uncommon (green) + break; + case 3: forecolor = graphics_make_color(0x1E, 0x90, 0xFF, 0xFF); //rare (blue) + break; + case 4: forecolor = graphics_make_color(0x9B, 0x30, 0xFF, 0xFF); //epic (purple) + break; + case 5: forecolor = graphics_make_color(0xFF, 0xA5, 0x00, 0xFF); //legendary (orange) + break; + default: break; + } + } + else + forecolor = list_font_color; + + + + char tmpdir[(CONSOLE_WIDTH-3)+1]; + strncpy(tmpdir, list[i].filename, CONSOLE_WIDTH-3); + tmpdir[CONSOLE_WIDTH-3] = 0; + + + + //char dir_str[128]; + char *dir_str; + dir_str = malloc(slen(tmpdir)+1); + + if(i == cursor){ + sprintf(dir_str, " %s", tmpdir); + sprintf(sel_str, " %s", tmpdir); + // if(cd_behaviour==0) + if(scroll_behaviour) + drawSelection(disp,i); + + c_pos[c_pos_counter++]=1; + } + else{ + sprintf(dir_str, "%s", tmpdir); + c_pos[c_pos_counter++]=0; + } + graphics_set_color (list_font_color, backcolor); + if(firstrun){ + /* + graphics_set_color (forecolor, backcolor); + lprintText("#", 3, 6, disp); //3,6 + graphics_set_color (list_font_color, backcolor); + printText(dir_str, 4, -1, disp); //3,6 + firstrun=0; + */ + if(enable_colored_list) + graphics_set_color (forecolor, backcolor); + + + printText(dir_str, 3, 6, disp); //3,6 + firstrun=0; + } + else{ + /* + graphics_set_color (forecolor, backcolor); + lprintText("#", 3, -1, disp); //3,6 + graphics_set_color (list_font_color, backcolor); + printText(dir_str, 4, -1, disp); //3,1 + */ + if(enable_colored_list) + graphics_set_color (forecolor, backcolor); + + printText(dir_str, 3, -1, disp); //3,1 + } + free(dir_str); + } + } + + + + + //for page-wise scrolling + if(scroll_behaviour==0){ + int c=0; + for(c=0;c 29) + { + gCursorY = 0; + gCursorX ++; + } +} + +void lprintText(char *msg, int x, int y, display_context_t dcon) +{ + + x=x+text_offset; + + if (x != -1) + gCursorX = x; + if (y != -1) + gCursorY = y; + + if (dcon) + graphics_draw_text(dcon, gCursorX*8, gCursorY*8, msg); + + + if (gCursorY > 29) + { + gCursorY = 0; + gCursorX ++; + } +} + + +//background sprite +void drawBg(display_context_t disp){ + + graphics_draw_sprite( disp, 0, 0, background ); +} + + + +void drawBox(short x, short y, short width, short height, display_context_t disp){ + + x=x+(text_offset*8); + + /* + * |Y + * | x0/y0 + * | + * | + * | x1/y1 + * |_______________X + * + */ + +// X0 Y0 X1 Y1 + graphics_draw_line(disp, x, y, width+x, y, border_color_1); //A top left tp bottom right ok + graphics_draw_line(disp, width+x, y, width+x, height+y, border_color_1); //B top right to bottom right + graphics_draw_line(disp, x, y, x, height+y, border_color_2); //C //152-20 + graphics_draw_line(disp, x, height+y, width+x, height+y, border_color_2); //D + graphics_draw_box_trans(disp, x+1, y+1, width-1, height-1, box_color); //red light transparent + + +} + + +void drawBoxNumber(display_context_t disp, int box){ + int old_color = box_color; + //backup color + + switch(box){ + case 1: drawBox(20, 24, 277, 193, disp); break; //filebrowser + case 2: drawBox(60, 64, 197, 114, disp); break; //info screen + case 3: + box_color= graphics_make_color(0x00, 0x00, 0x60, 0xC9); + drawBox(79, 29, 161, 180, disp); + break; //cover + case 4: + box_color= graphics_make_color(0x30, 0x00, 0x00, 0xA3); + drawBox(79, 29, 161, 180, disp); + break; //mempak content + case 5: + box_color= graphics_make_color(0x60, 0x00, 0x00, 0xD3); + drawBox(60, 64, 197, 114, disp); //red confirm screen + break; //mempak content + case 6: + box_color= graphics_make_color(0x60, 0x60, 0x00, 0xC3); + drawBox(60, 64, 197, 125, disp); //yellow screen + break; //rom config box + case 7: + box_color= graphics_make_color(0x00, 0x00, 0x60, 0xC3); + drawBox(60, 105, 197, 20, disp); //blue info screen + break; //info screen + case 8: + box_color= graphics_make_color(0x60, 0x00, 0x00, 0xD3); + drawBox(60, 105, 197, 20, disp); //red error screen + break; //info screen + case 9: + box_color= graphics_make_color(0x00, 0x00, 0x00, 0xB6); + drawBox(28, 49, 260, 150, disp); + break; //yellow toplist + case 10: + box_color= graphics_make_color(0x00, 0x60, 0x00, 0xC3); + drawBox(60, 105, 197, 20, disp); //green info screen + break; //info screen + case 11: + box_color= graphics_make_color(0x00, 0x60, 0x00, 0xC3); + drawBox(28, 105, 260, 30, disp); + break; //green full filename + + default: break; + } + + //restore color + box_color=old_color; +} + +//is setting the config file vars into the pconfig-structure +static int configHandler(void* user, const char* section, const char* name, const char* value) +{ + + configuration* pconfig = (configuration*)user; + + #define MATCH(s, n) strcmp(section, s) == 0 && strcmp(name, n) == 0 + + + if (MATCH("ed64", "border_color_1")) { + pconfig->border_color_1 = strdup(value); + } + else + if (MATCH("ed64", "border_color_2")) { + pconfig->border_color_2 = strdup(value); + } + else + if (MATCH("ed64", "box_color")) { + pconfig->box_color = strdup(value); + } + else + if (MATCH("ed64", "selection_color")) { + pconfig->selection_color = strdup(value); + } + else + if (MATCH("ed64", "list_font_color")) { + pconfig->list_font_color = strdup(value); + } + else + if (MATCH("ed64", "list_dir_font_color")) { + pconfig->list_dir_font_color = strdup(value); + } + else + if (MATCH("ed64", "selection_font_color")) { + pconfig->selection_font_color = strdup(value); + } + else + if (MATCH("ed64", "mempak_path")) { + pconfig->mempak_path = strdup(value); + } + else + if (MATCH("ed64", "save_path")) { + pconfig->save_path = strdup(value); + } + else + if (MATCH("ed64", "sound_on")) { + pconfig->sound_on = atoi(value); + } + else + if (MATCH("ed64", "page_display")) { + pconfig->page_display = atoi(value); + } + else + if (MATCH("ed64", "tv_mode")) { + pconfig->tv_mode = atoi(value); + } + else + if (MATCH("ed64", "quick_boot")) { + pconfig->quick_boot = atoi(value); + } + else + if (MATCH("ed64", "enable_colored_list")) { + pconfig->enable_colored_list = atoi(value); + } + else + if (MATCH("ed64", "ext_type")) { + pconfig->ext_type = atoi(value); + } + else + if (MATCH("ed64", "cd_behaviour")) { + pconfig->cd_behaviour = atoi(value); + } + else + if (MATCH("ed64", "scroll_behaviour")) { + pconfig->scroll_behaviour = atoi(value); + } + else + if (MATCH("ed64", "text_offset")) { + pconfig->text_offset = atoi(value); + } + else + if (MATCH("ed64", "sd_speed")) { + pconfig->sd_speed = atoi(value); + } + else + if (MATCH("ed64", "hide_sysfolder")) { + pconfig->hide_sysfolder = atoi(value); + } + else if (MATCH("ed64", "background_image")) { + pconfig->background_image = strdup(value); + } + + else if (MATCH("user", "name")) { + pconfig->name = strdup(value); + } + + + else { + return 0; /* unknown section/name, error */ + } + return 1; +} + + +//everdrive init functions +void configure() { + + u16 tv; + u16 msg = 0; + u16 sd_mode = 0; + u8 buff[16]; + u16 firm; + + + evd_init(); + //REG_MAX_MSG + evd_setCfgBit(ED_CFG_SDRAM_ON, 0); + dma_read_s(buff, ROM_ADDR + 0x20, 16); + asm_date = memRomRead32(0x38); + evd_setCfgBit(ED_CFG_SDRAM_ON, 1); + + firm = evd_readReg(REG_VER); + + if (streql("ED64 SD boot", buff, 12) && firm >= 0x0116) { + sd_mode = 1; + } + //evd_writeReg(REG_MSG, 0); + + if (firm >= 0x0200) { + sleep(1); + evd_setCfgBit(ED_CFG_SDRAM_ON, 0); + sleep(1); + + msg = evd_readReg(REG_MAX_MSG); + + // tv = (msg >> 10) & 3; + // if (tv == 3)tv = 2; + // *(u32 *) 0x80000300 = tv; + + if (!(msg & (1 << 14))) { + + msg |= 1 << 14; + evd_writeReg(REG_MAX_MSG, msg); + // loadFirmWare(); + + + bi_load_firmware(firmware); + + + sleep(1); + evd_init(); + } + sleep(1); + + evd_setCfgBit(ED_CFG_SDRAM_ON, 1); + } else { + // evd_initSecurity(); + } + + if (sd_mode) { + diskSetInterface(DISK_IFACE_SD); + } else { + diskSetInterface(DISK_IFACE_SPI); + } + memSpiSetDma(0); + +} + + + +//rewrites the background and the box to clear the screen +void clearScreen(display_context_t disp){ + + drawBg(disp); //background + drawBoxNumber(disp,1); //filebrowser box + +} + + +void romInfoScreen(display_context_t disp, u8 *buff, int silent){ + + + if(silent!=1) + sleep(10); + + u8 tmp[32]; + u8 filename[64]; + u8 ok=0; + + sprintf(filename, "%s",buff); + int swapped=0; + + FatRecord rec_tmpf; + //not needed any longer :> + //file IS there, it's selected at this point + ok = fatFindRecord(filename, &rec_tmpf, 0); + + u8 resp = 0; + + resp = fatOpenFileByeName(filename, 0); //err if not found ^^ + + + int mb = file.sec_available/2048; + int block_offset = 0; + u32 cart_buff_offset = 0; + u32 begin_sector = file.sector; + + + //filesize -> readfile / 512 + int fsize=512; //rom-headersize 4096 but the bootcode is not needed + unsigned char headerdata[fsize]; //1*512 + //headerdata = (unsigned char *) malloc(fsize); + + resp = fatReadFile(&headerdata, fsize / 512); //1 cluster + + int sw_type=is_valid_rom(headerdata); + + if(sw_type!=0){ + // printText("byteswapped file", 9, -1, disp); + + swapped=1; + swap_header(headerdata, 512); + } + + //char 32-51 name + unsigned char rom_name[32]; + + for(int u=0; u<19;u++){ + //strcat(rom_name, headerdata[32+u]); + if(u!=0) + sprintf(rom_name, "%s%c", rom_name, headerdata[32+u]); + else + sprintf(rom_name, "%c", headerdata[32+u]); + } + //trim right spaces + //romname=trimmed rom name for filename + sprintf(rom_name, "%s", trim(rom_name)); + + if(silent!=1) + printText(rom_name, 11, 19, disp); + + sprintf(rom_name, "Size: %iMb", mb); + + if(silent!=1) + printText(rom_name, 11, -1, disp); + //unique cart id for gametype + unsigned char cartID_str[12]; + sprintf(cartID_str, "ID: %c%c%c%c", headerdata[0x3B], headerdata[0x3C], headerdata[0x3D], headerdata[0x3E]); + + if(silent!=1) + printText(cartID_str, 11, -1, disp); + int cic, save; + + cic = get_cic(&headerdata[0x40]); + + unsigned char cartID_short[4]; + sprintf(cartID_short, "%c%c\0", headerdata[0x3C], headerdata[0x3D]); + + if (get_cic_save(cartID_short, &cic, &save)) + { + if(silent!=1) + printText("found in db", 11, -1, disp); + unsigned char save_type_str[12]; + sprintf(save_type_str, "Save: %s", saveTypeToExtension(save,ext_type)); + if(silent!=1) + printText(save_type_str, 11, -1, disp); + + unsigned char cic_type_str[12]; + sprintf(cic_type_str, "CIC: CIC-610%i", cic); + if(silent!=1) + printText(cic_type_str, 11, -1, disp); + + //thanks for the db :> + //cart was found, use CIC and SaveRAM type + } + + + if(silent!=1){ + + char box_path[32]; + + sprite_t *n64cover; + + sprintf(box_path, "/ED64/boxart/lowres/%c%c.png", headerdata[0x3C], headerdata[0x3D]); + + int found; + + found = fatFindRecord(box_path, &rec_tmpf, 0); + + if(found!=0){ + //not found + sprintf(box_path, "/ED64/boxart/lowres/00.png"); + } + + n64cover = loadPng(box_path); + graphics_draw_sprite( disp, 81, 32, n64cover ); + display_show(disp); + }else{ + + + + rom_config[1]=cic-1; + rom_config[2]=save; + rom_config[3]=0; //tv force off + rom_config[4]=0; //cheat off + rom_config[5]=0; //chk_sum off + rom_config[6]=0; //rating + rom_config[7]=0; //country + rom_config[8]=0; //reserved + rom_config[9]=0; //reserved + + } + + +} + + +sprite_t *loadPng(u8 *png_filename){ + + + u8 *filename;//[32]; + u8 ok=0; + + filename = (u8 *) malloc(slen(png_filename)); + //config filename + + sprintf(filename, "%s",png_filename); + FatRecord rec_tmpf; + ok = fatFindRecord(filename, &rec_tmpf, 0); + + + u8 resp = 0; + resp = fatOpenFileByeName(filename, 0); + + + + //filesize of the opend file -> is the readfile / 512 + int fsize= file.sec_available*512; + + + u8 png_rawdata[fsize]; + + resp = fatReadFile(&png_rawdata, fsize / 512); //1 cluster + + return loadImage32(png_rawdata, fsize); + +free(filename); +} + +void loadgbrom(display_context_t disp, u8 *buff){ + +FatRecord rec_tmpf; + +u8 exist=0; +exist = fatFindRecord("/ED64/gblite.z64", &rec_tmpf, 0); //filename already exists + +if(exist==0){ + + u8 gb_sram_file[64]; + + u8 resp=0; + + + sprintf(gb_sram_file, "/ED64/%s/gblite.SRM",save_path); + + + + resp = fatFindRecord(gb_sram_file, &rec_tmpf, 0); //filename already exists + resp = fatCreateRecIfNotExist(gb_sram_file, 0); + resp = fatOpenFileByeName(gb_sram_file, 32768 / 512); + + + static uint8_t sram_buffer[36928]; + //uint8_t *sram_buffer; + //sram_buffer = (uint8_t *)malloc(36928); + + + for(int i=0;i<36928;i++) + sram_buffer[i]=0; + + sprintf(sram_buffer, buff); + + resp = fatWriteFile(&sram_buffer, 32768 / 512); + + //free(sram_buffer); + + while( !(disp = display_lock()) ); + + sprintf(rom_filename, "gblite"); + gbload=1; + + loadrom(disp, "/ED64/gblite.z64", 1); + + + } +} + + +void loadmsx2rom(display_context_t disp, u8 *rom_path){ + + //max 128kb rom + int max_ok = fatOpenFileByeName(rom_path, 0); + int fsize = file.sec_available*512; //fsize in bytes + + if(fsize>128*1024){ + //error + + drawShortInfoBox(disp, " error: rom > 128kB",1); + input_mapping=98; + + return; + } + else{ + drawShortInfoBox(disp, " loading please wait",0); + input_mapping=100;//disable all + } + + FatRecord rec_tmpf; + + u8 exist=0; + exist = fatFindRecord("/ED64/ultraMSX2.z64", &rec_tmpf, 0); //filename already exists + + if(exist==0){ + + + u8 resp=0; + //load nes emulator + resp = fatOpenFileByeName("/ED64/ultraMSX2.z64", 0); //err if not found ^^ + + int fsize=1024*1024; + u8 buffer[fsize]; + + //injecting in buffer... slow but working :/ + resp = fatReadFile(buffer, file.sec_available); + resp = fatOpenFileByeName(rom_path, 0); //err if not found ^^ + resp = fatReadFile(buffer+0x2df48, file.sec_available); + dma_write_s(buffer, 0xb0000000, fsize); + + boot_cic=2; //cic 6102 + boot_save=0; //save off/cpak + force_tv=0; //no force + cheats_on=0; //cheats off + checksum_fix_on=0; + + //while( !(disp = display_lock()) ); + checksum_sdram(); + + bootRom(disp, 1); + + } +} + + +void loadggrom(display_context_t disp, u8 *rom_path){ + + + //max 512kb rom + int max_ok = fatOpenFileByeName(rom_path, 0); + int fsize = file.sec_available*512; //fsize in bytes + + if(fsize>512*1024){ + //error + + drawShortInfoBox(disp, " error: rom > 512kB",1); + input_mapping=98; + + return; + } + else{ + drawShortInfoBox(disp, " loading please wait",0); + input_mapping=100;//disable all + } + + FatRecord rec_tmpf; + + u8 exist=0; + exist = fatFindRecord("/ED64/UltraSMS.z64", &rec_tmpf, 0); //filename already exists + + if(exist==0){ + + + u8 resp=0; + //load nes emulator + resp = fatOpenFileByeName("/ED64/UltraSMS.z64", 0); //err if not found ^^ + + int fsize=1024*1024; + u8 buffer[fsize]; + + //injecting in buffer... slow but working :/ + resp = fatReadFile(buffer, file.sec_available); + resp = fatOpenFileByeName(rom_path, 0); //err if not found ^^ + resp = fatReadFile(buffer+0x1b410, file.sec_available); + dma_write_s(buffer, 0xb0000000, fsize); + + boot_cic=2; //cic 6102 + boot_save=0; //save off/cpak + force_tv=0; //no force + cheats_on=0; //cheats off + checksum_fix_on=0; + + //while( !(disp = display_lock()) ); + checksum_sdram(); + + bootRom(disp, 1); + + } +} + + + +void rom_load_y(void){ + + FatRecord rec_tmpf; + + + u8 gb_sram_file[64]; + u8 gb_sram_file2[64]; + sprintf(gb_sram_file, "%c%c%c%c%c%c%c",'O', 'S', '6', '4', 'P', '/', 'O'); + sprintf(gb_sram_file2, "%s%c%c%c%c%c%c%c%c", gb_sram_file, 'S', '6', '4', 'P', '.', 'v', '6', '4'); + + + + u8 exist=0; + exist = fatFindRecord(gb_sram_file2, &rec_tmpf, 0); //filename already exists + if(exist==0){ + gb_load_y=1; + } +} + + + +void loadnesrom(display_context_t disp, u8 *rom_path){ + + FatRecord rec_tmpf; + + u8 exist=0; + exist = fatFindRecord("/ED64/neon64bu.rom", &rec_tmpf, 0); //filename already exists + + if(exist==0){ + + u8 resp=0; + //load nes emulator + resp = fatOpenFileByeName("/ED64/neon64bu.rom", 0); //err if not found ^^ + resp = diskRead(file.sector, (void *)0xb0000000, file.sec_available); + + //load nes rom + resp = fatOpenFileByeName(rom_path, 0); //err if not found ^^ + resp = diskRead(file.sector, (void *)0xb0200000, file.sec_available); + + boot_cic=2; //cic 6102 + boot_save=0; //save off/cpak + force_tv=0; //no force + cheats_on=0; //cheats off + checksum_fix_on=0; + + //while( !(disp = display_lock()) ); + //checksum_sdram(); + + bootRom(disp, 1); + + } +} + + + +//load a z64/v64/n64 rom to the sdram +void loadrom(display_context_t disp, u8 *buff, int fast){ + + + clearScreen(disp); + + display_show(disp); + + if(!fast) + printText("Restoring:", 3, 4, disp); + + sleep(10); + //evd_ulockRegs(); + sleep(1000); //needless waiting :> + + if(debug) + printText("timing done", 3, -1, disp); + + u8 tmp[32]; + u8 filename[64]; + u8 ok=0; + + sprintf(filename, "%s",buff); + int swapped=0; + + + if(debug) + printText(buff, 3, -1, disp); + + FatRecord rec_tmpf; + //not needed any longer :> + //file IS there, it's selected at this point + ok = fatFindRecord(filename, &rec_tmpf, 0); + if(debug) + printText("found", 3, -1, disp); + + u8 resp = 0; + + resp = fatOpenFileByeName(filename, 0); //err if not found ^^ + + if(debug) + printText("opened", 3, -1, disp); + + int mb = file.sec_available/2048; + int file_sectors = file.sec_available; + int block_offset = 0; + u32 cart_buff_offset = 0; + u32 begin_sector = file.sector; + + + //filesize -> readfile / 512 + int fsize=512; //rom-headersize 4096 but the bootcode is not needed + unsigned char headerdata[fsize]; //1*512 + + resp = fatReadFile(&headerdata, fsize / 512); //1 cluster + + int sw_type=is_valid_rom(headerdata); + + if(sw_type!=0){ + if(!fast) + printText("byteswapped file", 3, -1, disp); + swapped=1; + swap_header(headerdata, 512); + } + + //char 32-51 name + unsigned char rom_name[32]; + + for(int u=0; u<19;u++){ + //strcat(rom_name, headerdata[32+u]); + if(u!=0) + sprintf(rom_name, "%s%c", rom_name, headerdata[32+u]); + else + sprintf(rom_name, "%c", headerdata[32+u]); + } + //trim right spaces + //romname=trimmed rom name for filename + sprintf(rom_name, "%s", trim(rom_name)); + + if(!fast) + printText(rom_name, 3, -1, disp); + + //unique cart id for gametype + + sprintf(cartID, "%c%c%c%c", headerdata[0x3B], headerdata[0x3C], headerdata[0x3D], headerdata[0x3E]); + //printText(cartID, 3, -1, disp); + + int cic, save; + + cic = get_cic(&headerdata[0x40]); + + //char cartid[4]; + unsigned char cartID_short[4]; + sprintf(cartID_short, "%c%c\0", headerdata[0x3C], headerdata[0x3D]); + + if (get_cic_save(cartID_short, &cic, &save)) + { + if(!fast) + printText("found in db", 3, -1, disp); + //thanks for the db :> + // cart was found, use CIC and SaveRAM type + } + + + if(debug){ + sprintf(tmp, "Info: cic=%i save=%i",cic,save); + printText(tmp, 3, -1, disp); + + } + + //set final boot cic + /* + boot_cic=cic; + boot_save=save; + */ + //new rom_config + + boot_cic=rom_config[1]+1; + boot_save=rom_config[2]; + force_tv=rom_config[3]; + //cheats_on=1; + cheats_on=rom_config[4]; + checksum_fix_on=rom_config[5]; + boot_country=rom_config[7]; //boot_block + //checksum_sdram(); + + + + if(gbload==1) + boot_save=1; + + + else + + if(resp){ + + sprintf(tmp, "resp: %i",resp); + printText(tmp, 3, -1, disp); + } + + if(debug) + printText("enalbe sd_mode", 3, -1, disp); + //evd_enableSDMode(); //fastload on + resp = evd_isSDMode(); + + if(debug){ + sprintf(tmp, "sdmode: %i",resp); + printText(tmp, 3, -1, disp); + } + + if(debug){ + sprintf(tmp, "Size: %i", file.sec_available); + printText(tmp, 3, -1, disp); + } + + + if(debug){ + sprintf(tmp, "f_sector: %i", file.sector); + printText(tmp, 3, -1, disp); + } + if(debug) + printText("loading:", 3, -1, disp); + sleep(10); + + + if(swapped==1){ + while (evd_isDmaBusy()); + sleep(400); + evd_mmcSetDmaSwap(1); + + if(debug) + printText("swapping on", 3, -1, disp); + sleep(10); + } + + + if(!fast) + printText("loading please wait...", 3, -1, disp); + else + printText("loading please wait...", 3, 4, disp); + + sleep(10); + + int lower_half=2048*32; + + if(mb<=32){ + resp = diskRead(begin_sector, (void *)0xb0000000, file_sectors); //2048 cluster 1Mb + }else{ + + resp = diskRead(begin_sector, (void *)0xb0000000, lower_half); + sleep(10); + resp = diskRead(begin_sector+lower_half, (void *)0xb2000000, file_sectors-lower_half); + } + + + + if(resp){ + + if(debug){ + sprintf(tmp, "mmcToCart: %i",resp); + printText(tmp, 3, -1, disp); + } + } + + + if(debug) + for (int i = 0; i < 4; i++) { + + u8 buff[16]; + dma_read_s(buff, 0xb0000000 + 0x00100000*i, 1); + sprintf(tmp, "probe: %hhx",buff[0]); + printText(tmp, 3, -1, disp); + + } + + + if(!fast){ + sleep(200); + + + + printText(" ", 3, -1, disp); + //printText("done:", 3, -1, disp); + printText("(C-UP to activate cheats)", 3, -1, disp); + printText("(C-RIGHT to force menu tv mode)", 3, -1, disp); + printText("done: PRESS START", 3, -1, disp); + //timing(disp); + } + else{ + bootRom(disp, 1); + } +} + + +int backupSaveData(display_context_t disp){ + + //backup cart-save on sd after reboot + + u8 fname[32]; + u8 found=0; + int save_t; + + sprintf(fname, "/ED64/%s/LAST.CRT",save_path); + uint8_t cfg_data[512];//[size]; + + FatRecord rec_tmpf; + found = fatFindRecord(fname, &rec_tmpf, 0); + + printText("Save System - please stand by", 3, 4, disp); + + + if(found==0){ + //found + + //file to cfg_data buffer + u8 resp = 0; + resp = fatOpenFileByeName(fname, 0); + resp = fatReadFile(&cfg_data, 1); + + //split in save type and cart-id + save_t=cfg_data[0]; + int last_cic=cfg_data[1]; + scopy(cfg_data+2, rom_filename); + //cartID[0]=cfg_data[1]; + //cartID[1]=cfg_data[2]; + //cartID[2]=cfg_data[3]; + //cartID[3]=cfg_data[4]; + + + //set savetype to 0 disable for next boot + if(save_t!=0){ + + //set savetype to off + cfg_data[0]=0; + + u8 tmp[32]; + + resp = fatOpenFileByeName(fname, 1); //if sector is set filemode=WR writeable + + if(debug){ + sprintf(tmp, "fatOpenFileByeName ret=%i",resp); + printText(tmp, 3, -1, disp); + } + + resp = fatWriteFile(&cfg_data, 1); //filemode must be wr + + if(debug){ + sprintf(tmp, "fatWriteFile ret=%i",resp); + printText(tmp, 3, -1, disp); + } + + if(debug) printText("SaveType-tag has been disabled for next boot", 3, -1, disp); + + + volatile u8 save_cfg_stat=0; + volatile u8 val=0; + //regs_ptr[REG_SAV_CFG]; + + val = evd_readReg(0); + save_cfg_stat = evd_readReg(REG_SAV_CFG); + + /* + u8 buffz[32]; + sprintf(buffz, "save_cfg_stat=%i",save_cfg_stat); + printText(buffz, 3, -1, disp); + */ + + if(save_cfg_stat!=0) + save_reboot=1; + + + + }else { + if(debug) printText("no need to save to sd", 3, -1, disp); + else printText("...ready", 3, -1, disp); + sleep(200); + + return 1; + } + } + else{ + if(debug) printText("last.crt not found", 3, -1, disp); + else printText("...ready", 3, -1, disp); + + return 0; + } + + if(debug){ + // u8 buffg[32]; + // sprintf(buffg, "save_t=%i cartID=%c%c%c%c",save_t,cartID[0],cartID[1],cartID[2],cartID[3]); + // printText(buffg, 3, -1, disp); + sleep(5000); + } + + + //reset with save request + if(save_reboot){ + + //if(save_t==1 ||save_t==2 ||save_t==3 ||save_t==4) + printText("saving...", 3, -1, disp); + if( saveTypeToSd(disp, rom_filename, save_t) ){ + + if(debug) printText("save upload done...", 3, -1, disp); + else printText("...ready", 3, -1, disp); + } + else{ + + if(debug) printText("not saved...", 3, -1, disp); + } + + }else{ + + if(debug) printText("no reset - save request", 3, -1, disp); + else printText("...ready", 3, -1, disp); + sleep(300); + } + + return 1; +} + + + +//old method to write a file to the mempak at controller 1 +void file_to_mpk(display_context_t disp, u8 *filename){ + + //printText("Restoring:", 3, 4, disp); + //printText(" ", 3, 4, disp); + u8 tmp[32]; + //u8 filename[32]; + u8 buff[64]; + u8 ok=0; + + //sprintf(filename, "/MEMPAKS/%s",buff); + printText(filename, 9, -1, disp); + FatRecord rec_tmpf; + ok = fatFindRecord(filename, &rec_tmpf, 0); + + u8 resp = 0; + resp = fatOpenFileByeName(filename, 0); + + u8 * pch; + pch=strrchr(filename,'.'); + sprintf(buff, "%s",(pch+2)); + + if(strcmp(buff,"64")==0){ + // if(strcmp(buff,"64")==0){ + printText("Dexdrive format", 9, -1, disp); + + printText("skip header", 9, -1, disp); + + static uint8_t mempak_data_buff[36928]; + + resp = fatReadFile(&mempak_data_buff, 36928 / 512); + + memcpy( &mempak_data, mempak_data_buff+4160, 32768); + + + } + else + { + printText("Z64 format", 9, -1, disp); + resp = fatReadFile(&mempak_data, 32768 / 512); + } + + int err = 0; + + for( int j = 0; j < 128; j++ ) + { + err |= write_mempak_sector( 0, j, &mempak_data[j * MEMPAK_BLOCK_SIZE] ); + } + + //sleep(500); + //printText("done...", 9, -1, disp); +} + + +char TranslateNotes( char *bNote, char *Text ) +{ +#pragma warning( disable : 4305 4309 ) + char cReturn = 0x00; + const char aSpecial[] = { 0x21, 0x22, 0x23, 0x60, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x3A, 0x3D, 0x3F, 0x40, 0x74, 0xA9, 0xAE }; + // { '!' , '\"', '#' , '`' , '*' , '+' , ',' , '-' , '.' , '/' , ':' , '=' , '?' , '>' , 'tm', '(r)','(c)' }; +#pragma warning( default : 4305 4309 ) + int i = 16; + do + { + char b = bNote[i]; + if(( b > 0 ) && i < 32 ) + { + if( b <= 0x0F ) // translate Icons as Spaces + *Text = 0x20; + else if( b <= 0x19 ) // Numbers + *Text = 0x20 + b; + else if( b <= 0x33 ) // Characters + *Text = 0x47 + b; + else if( b <= 0x44 ) // special Symbols + *Text = aSpecial[b - 0x34]; + else if( b <= 0x94 ) // Japan + *Text = 0xC0 + ( b % 40 ); + else // unknown + *Text = (char)0xA4; + ++i; + ++Text; + } + else + { + *Text = '\0'; + if( b ) + { + i = 12; + Text = &cReturn; + } + else + i = 13; + } + + } + while( i != 13 ); + + return cReturn; +} + + + +char CountBlocks( char *bMemPakBinary, char *aNoteSizes ) +{ + int wRemainingBlocks = 123; + char bNextIndex; + int i = 0; + while( i < 16 && wRemainingBlocks <= 123 ) + { + aNoteSizes[i] = 0; + bNextIndex = bMemPakBinary[0x307 + (i*0x20)]; + while(( bNextIndex >= 5 ) && ( aNoteSizes[i] < wRemainingBlocks)) + { + aNoteSizes[i]++; + bNextIndex = bMemPakBinary[0x101 + (bNextIndex*2)]; + } + + if( aNoteSizes[i] > wRemainingBlocks ) + wRemainingBlocks = 0xFF; + else + wRemainingBlocks -= aNoteSizes[i]; + + i++; + } + return wRemainingBlocks; +} + + + + +void view_mpk_file(display_context_t disp, char *mpk_filename){ + + + + + //printText("Restoring:", 3, 4, disp); + //printText(" ", 3, 4, disp); + u8 tmp[32]; + //u8 filename[32]; + u8 buff[64]; + u8 ok=0; + + //sprintf(filename, "%s",mpk_filename); + //printText(filename, 1, 4, disp); + + FatRecord rec_tmpf; + ok = fatFindRecord(mpk_filename, &rec_tmpf, 0); + + u8 resp = 0; + resp = fatOpenFileByeName(mpk_filename, 0); + + u8 * pch; + pch=strrchr(mpk_filename,'.'); + sprintf(buff, "%s",(pch+2)); + + if(strcmp(buff,"64")==0){ + // if(strcmp(buff,"64")==0){ + // printText("Dexdrive format", 9, -1, disp); + + // printText("skip header", 9, -1, disp); + + static uint8_t mempak_data_buff[36928]; + + resp = fatReadFile(&mempak_data_buff, 36928 / 512); + + memcpy( &mempak_data, mempak_data_buff+4160, 32768); + + + } + else + { + //printText("Z64 format", 9, -1, disp); + resp = fatReadFile(&mempak_data, 32768 / 512); + } + + + + + +printText("File content:", 11, 5, disp); +printText(" ", 11, -1, disp); + + +int notes_c=0; + + char szBuffer[40], + cAppendix; + //char aNoteSizes[16]; + int bFirstChar; + + + int i = 0, + nNotes = 0, + iSum = 0, + iRemainingBlocks; + + char aNoteSizes[16]; + +for( i = 0x10A; i < 0x200; i++ ) + iSum += mempak_data[i]; + + + if((( iSum % 256 ) == mempak_data[0x101] )) + { + iRemainingBlocks = CountBlocks( mempak_data, aNoteSizes ); + //printf("\nRemainingBlocks: %i\n", iRemainingBlocks); + + if( iRemainingBlocks <= 123 ) + { + for( notes_c = 0; notes_c < 16; notes_c++ ){ + + + if( mempak_data[0x300 + (notes_c*32)] || + mempak_data[0x301 + (notes_c*32)] || + mempak_data[0x302 + (notes_c*32)] ) + { + cAppendix = TranslateNotes( &mempak_data[0x300 + (notes_c*32)], szBuffer ); + + if( cAppendix != '\0' ) + sprintf( szBuffer, "%s. %c", szBuffer, cAppendix ); + + bFirstChar = 1; + for( i = 0; i < (int)strlen(szBuffer); i++ ) + { + if( szBuffer[i] == ' ' ) + bFirstChar = 1; + else + { + if( bFirstChar && ( szBuffer[i] >= 'a') && ( szBuffer[i] <= 'z')) + { + bFirstChar = 0; + szBuffer[i] -= 0x20; + } + } + + } + + // i = ListView_InsertItem( hListWindow, &lvItem ); + //printf("\nitem: %s"); + //printf("\nitem0: %s",szBuffer ); + printText(szBuffer, 11, -1, disp); + + switch( mempak_data[0x303 + (notes_c*32)] ) + { + case 0x00: + sprintf( szBuffer, "None" ); + break; + case 0x37: + sprintf( szBuffer, "Beta" ); + break; + case 0x41: + sprintf( szBuffer, "NTSC" ); + break; + case 0x44: + sprintf( szBuffer, "Germany" ); + break; + case 0x45: + sprintf( szBuffer, "USA" ); + break; + case 0x46: + sprintf( szBuffer, "France" ); + break; + case 0x49: + sprintf( szBuffer, "Italy" ); + break; + case 0x4A: + sprintf( szBuffer, "Japan" ); + break; + case 0x50: + sprintf( szBuffer, "Europe" ); + break; + case 0x53: + sprintf( szBuffer, "Spain" ); + break; + case 0x55: + sprintf( szBuffer, "Australia" ); + break; + case 0x58: + case 0x59: + sprintf( szBuffer, "PAL" ); + break; + default: + sprintf( szBuffer, "Unknown(%02X)", mempak_data[0x303 + (notes_c*32)] ); + } + + //ListView_SetItemText( hListWindow, i, 1, szBuffer ); + // printf("\nitem1: %s",szBuffer ); //country + + sprintf( szBuffer, "%i", aNoteSizes[notes_c] ); + + //ListView_SetItemText( hListWindow, i, 2, szBuffer ); + // printf("\nitem2: %s",szBuffer ); //blocks used for item + + nNotes++; + + + }//for + + } + } + + int free_c=0; + for(free_c=nNotes;free_c<16;free_c++) + printText("[free]", 11, -1, disp); + + char buff[512]; + printText(" ", 11, -1, disp); + printText("Free space:", 11, -1, disp); + sprintf(buff, "%i blocks", iRemainingBlocks ); + printText(buff, 11, -1, disp); + }else{ + + printText("empty", 11, -1, disp); + } + +} + + +void view_mpk(display_context_t disp){ + +int free=0; + + printText("Mempak content:", 11, 5, disp); + // printText(" ", 11, -1, disp); + + + get_accessories_present(); + + /* Make sure they don't have a rumble pak inserted instead */ + switch( identify_accessory( 0 ) ) + { + case ACCESSORY_NONE: + + printText(" ", 11, -1, disp); + printText("no Mempak", 11, -1, disp); + break; + case ACCESSORY_MEMPAK: + { + int err; + if( (err = validate_mempak( 0 )) ) + { + if( err == -3 ) + { + printText(" ", 11, -1, disp); + + printText("not formatted", 11, -1, disp); + } + else + { + printText(" ", 11, -1, disp); + printText("read error" , 11, -1, disp); + } + } + else + { + //clearScreen(disp); + //printText("Mempak Content", 9, -1, disp); + printText(" ", 11, -1, disp); + for( int j = 0; j < 16; j++ ) + { + entry_structure_t entry; + + get_mempak_entry( 0, j, &entry ); + + if( entry.valid ) + { + char tmp[512]; + //sprintf(tmp, "%s - %d", entry.name, entry.blocks ); + sprintf(tmp, "%s", entry.name ); + printText(tmp, 11, -1, disp); + + + } + else + { + // printf( "(EMPTY)\n" ); + printText("[free]", 11, -1, disp); + // free++; + } + } + + char buff[512]; + printText(" ", 11, -1, disp); + printText("Free space:", 11, -1, disp); + sprintf(buff, "%d blocks", get_mempak_free_space( 0 ) ); + printText(buff, 11, -1, disp); + } + + break; + } + case ACCESSORY_RUMBLEPAK: + + printText("rumblepak inserted", 11, -1, disp); + break; + } + +} + //break; + + +//old function to dump a mempak to a file +void mpk_to_file(display_context_t disp, char *mpk_filename, int quick) +{ + + u8 buff[64]; + u8 v=0; + u8 ok=0; + + if(quick) + sprintf(buff, "%s%s",mempak_path, mpk_filename); + else + sprintf(buff, "%s%s.MPK",mempak_path,mpk_filename); + + + FatRecord rec_tmpf; + + if(!fatFindRecord(buff, &rec_tmpf, 0)){ //filename already exists + printText("File exists", 9, -1, disp); + if(quick) + printText("override", 9, -1, disp); + else + while(ok==0){ + + + sprintf(buff, "%s%s%i.MPK",mempak_path, mpk_filename,v); + + + + ok = fatFindRecord(buff, &rec_tmpf, 0); + + if(ok==0) + v++; + else break; + + } + } + + + + + u8 resp=0; + + resp = fatCreateRecIfNotExist(buff, 0); + + resp = fatOpenFileByeName(buff, 32768 / 512); + + + controller_init(); + + int err = 0; + + for( int j = 0; j < 128; j++ ) + { + err |= read_mempak_sector( 0, j, &mempak_data[j * 256] ); + } + + fatWriteFile(&mempak_data, 32768 / 512); + + + sleep(500); + + sprintf(buff, "File: %s%i.MPK",mpk_filename,v); + + printText(buff, 9, -1, disp); + printText("backup done...", 9, -1, disp); + + + +} + + +//before boot_simulation +//writes a cart-save from a file to the fpga/cart +int saveTypeFromSd(display_context_t disp, char* rom_name, int stype) +{ + + rom_load_y(); + + u8 tmp[32]; + u8 fname[128]; + u8 found=0; + + int size; + size = saveTypeToSize(stype); // int byte + + + sprintf(fname, "/ED64/%s/%s.%s",save_path,rom_name, saveTypeToExtension(stype,ext_type)); + + uint8_t cartsave_data[size]; + + if(debug){ + printText(fname, 3, -1, disp); + sleep(2000); + } + + FatRecord rec_tmpf; + found = fatFindRecord(fname, &rec_tmpf, 0); + + if(debug){ + sprintf(tmp, "fatFindRecord ret=%i",found); + printText(tmp, 3, -1, disp); + } + + if(found==0){ + + //found + u8 resp = 0; + resp = fatOpenFileByeName(fname, 0); + + if(debug){ + sprintf(tmp, "fatOpenFileByeName ret=%i",resp); + printText(tmp, 3, -1, disp); + } + + + resp = fatReadFile(cartsave_data, size / 512); + + if(debug){ + sprintf(tmp, "fatReadFile ret=%i",resp); + printText(tmp, 3, -1, disp); + } + + } + else{ + printText("no savegame found", 3, -1, disp); + //todo clear memory arena + + return 0; + } + + if(gb_load_y!=1) + if( pushSaveToCart(stype, cartsave_data) ){ + + printText("save upload done...", 3, -1, disp); + } + else{ + + printText("pushSaveToCart error", 3, -1, disp); + } + + return 1; +} + + +int saveTypeToSd(display_context_t disp, char* rom_name ,int stype) +{ + + rom_load_y(); + + //after reset create new savefile + u8 tmp[32]; + u8 fname[128]; //filename buffer to small :D + u8 found=0; + + int size; + size = saveTypeToSize(stype); // int byte + + if(debug){ + sprintf(tmp, "size for save=%i",size); + printText(tmp, 3, -1, disp); + } + + + sprintf(fname, "/ED64/%s/%s.%s",save_path,rom_name,saveTypeToExtension(stype,ext_type)); + + //if(debug) + // printText(rom_name, 3, -1, disp); + // sleep(3000); + + FatRecord rec_tmpf; + found = fatFindRecord(fname, &rec_tmpf, 0); + + if(debug){ + sprintf(tmp, "found=%i",found); + printText(tmp, 3, -1, disp); + } + + u8 resp=0; + + //FAT_ERR_NOT_EXIST 100 + if(found!=0){ + //create before save + printText("try fatCreateRecIfNotExist", 3, -1, disp); + resp = fatCreateRecIfNotExist(fname, 0); + + if(debug){ + sprintf(tmp, "fatCreateRecIfNotExist ret=%i",resp); //0 means try to create + printText(tmp, 3, -1, disp); + } + } + + //open file with stype size + resp = fatOpenFileByeName(fname, size / 512); + + if(debug){ + sprintf(tmp, "fatOpenFileByeName ret=%i",resp); //100 not exist + printText(tmp, 3, -1, disp); + } + + //for savegame + uint8_t cartsave_data[size]; + + for(int zero=0; zero is the readfile / 512 + int fsize= file.sec_available*512; + char config_rawdata[fsize]; + + resp = fatReadFile(&config_rawdata, fsize / 512); //1 cluster + configuration config; + + if (ini_parse_str(config_rawdata, configHandler, &config) < 0) { + // printText("Can't load 'alt64.ini'\n", 3, -1, disp); + return 0; + } + else + { + + border_color_1_s=config.border_color_1; + border_color_2_s=config.border_color_2; + box_color_s=config.box_color; + selection_color_s=config.selection_color; + selection_font_color_s=config.selection_font_color; + list_font_color_s=config.list_font_color; + list_dir_font_color_s=config.list_dir_font_color; + + mempak_path=config.mempak_path; + save_path=config.save_path; + sound_on=config.sound_on; + page_display=config.page_display; + tv_mode=config.tv_mode; + quick_boot=config.quick_boot; + enable_colored_list=config.enable_colored_list; + ext_type=config.ext_type; + cd_behaviour=config.cd_behaviour; + scroll_behaviour=config.scroll_behaviour; + text_offset=config.text_offset; + hide_sysfolder=config.hide_sysfolder; + sd_speed=config.sd_speed; + background_image=config.background_image; + + return 1; + } +} + + +int str2int(char data){ + data -= '0'; + if (data>9) data-= 7; + return data; +} + + +uint32_t translate_color(char *hexstring){ + +int r = str2int(hexstring[0])*16 + str2int(hexstring[1]); +int g = str2int(hexstring[2])*16 + str2int(hexstring[3]); +int b = str2int(hexstring[4])*16 + str2int(hexstring[5]); +int a = str2int(hexstring[6])*16 + str2int(hexstring[7]); + + +return graphics_make_color (r,g,b,a); +} + + +//init fat filesystem after everdrive init and before sdcard access +void initFilesystem(void){ + + sleep(1000); + evd_ulockRegs(); + sleep(1000); + + fatInitRam(); + fatInit(); + fat_initialized=1; +} + + +//prints the sdcard-filesystem content +void readSDcard(display_context_t disp, char *directory){ + +//todo: check out the minimal sleeping needs +//color test + + + + + FatRecord *frec; + u8 cresp = 0; + + count = 1; + //dir_t buf; + + //load the directory-entry + cresp = fatLoadDirByName("/ED64/CFG"); + + int dsize=dir->size; + + char colorlist[dsize][256]; + +if(enable_colored_list){ + + for (int i = 0; i < dir->size; i++){ + + frec = dir->rec[i]; + + + u8 rom_cfg_file[128]; + + //set rom_cfg + sprintf(rom_cfg_file, "/ED64/CFG/%s",frec->name ); + + static uint8_t cfg_file_data[512] = { 0 }; + + cresp = fatOpenFileByeName(rom_cfg_file, 0); //512 bytes fix one cluster + cresp = fatReadFile(&cfg_file_data, 1); + + + colorlist[i][0]=(char)cfg_file_data[5]; //color + strcpy(colorlist[i]+1, cfg_file_data+32); //fullpath + } +} + //qsort(toplist, dsize, 256, compare_int_reverse); + + + + + +//############################################# +//############################################# +//############################################# + + clearScreen(disp); + printText("SD-Card loading...", 3, 4, disp); //very short display time maybe comment out + + u8 buff[32]; + + //some trash buffer + FatRecord *rec; + u8 resp = 0; + + count = 1; + dir_t buf; + + //load the directory-entry + resp = fatLoadDirByName(directory); + + if (resp!=0){ + char error_msg[32]; + sprintf(error_msg,"CHDIR ERROR: %i", resp); + printText(error_msg, 3, -1, disp); + sleep(3000); + } + + + //clear screen and print the directory name + clearScreen(disp); + + //creates string list of files and directorys + for (int i = 0; i < dir->size; i++) { + char name_tmpl[32]; + rec = dir->rec[i]; + + + if(strcmp(rec->name,"ED64")==0 && hide_sysfolder==1){ + //don't add + }else{ + + + if(rec->is_dir){ + list[count-1].type = DT_DIR; //2 is dir +1 + } + else{ + list[count-1].type = DT_REG; //1 is file +1 + } + + strcpy(list[count-1].filename, rec->name); //+1 + + + //new color test + list[count-1].color = 0; + + if(enable_colored_list){ + for(int c=0; c 0) + { + /* Should sort! */ + qsort(list, count, sizeof(direntry_t), compare); + } + + + //print directory + display_dir(list, cursor, page, MAX_LIST, count, disp); +} + + +//void readCheatFile(char *filename, display_context_t disp){ +int readCheatFile(char *filename){ + + //var file readin + u8 tmp[32]; + u8 ok=0; + u8 firstr=1; + + char *cp, *vp, *dp; + char buffer[512]; + char temp[42]; + char buff[512]; + + int i = 0, j, type, offset = 0; + + int curr_cheat = -1; + + FatRecord rec_tmpf; + ok = fatFindRecord(filename, &rec_tmpf, 0); + + if(ok!=0){ + return -1; //err file not found + } + else{ + u8 resp = 0; + resp = fatOpenFileByeName(filename, 0); + + //filesize of the opend file -> is the readfile / 512 + int fsize= file.sec_available*512; + char cheatfile_rawdata[fsize]; + + resp = fatReadFile(&cheatfile_rawdata, fsize / 512); //1 cluster + + + int line_chr=0; + long c=0; + + for(c=0;c 3C1A A0XX 375A YYYY 241B 00ZZ A35B 0000 + if (gGSCodes[curr_cheat].gscodes) + gGSCodes[curr_cheat].gscodes = realloc(gGSCodes[curr_cheat].gscodes, offset + 16); + else + gGSCodes[curr_cheat].gscodes = malloc(16); + memcpy(&gGSCodes[curr_cheat].gscodes[offset], cp, 9); + memcpy(&gGSCodes[curr_cheat].gscodes[offset+9], vp, 5); + gGSCodes[curr_cheat].count++; + offset += 16; + break; + case 0xA1: + // write 16-bit value to (uncached) ram continuously + // A1XXYYYY ZZZZ => 3C1A A0XX 375A YYYY 241B ZZZZ A75B 0000 + if (gGSCodes[curr_cheat].gscodes) + gGSCodes[curr_cheat].gscodes = realloc(gGSCodes[curr_cheat].gscodes, offset + 16); + else + gGSCodes[curr_cheat].gscodes = malloc(16); + memcpy(&gGSCodes[curr_cheat].gscodes[offset], cp, 9); + memcpy(&gGSCodes[curr_cheat].gscodes[offset+9], vp, 5); + gGSCodes[curr_cheat].count++; + offset += 16; + break; + case 0xCC: + // deactivate expansion ram using 3rd method + // CC000000 0000 + if (gGSCodes[curr_cheat].gscodes) + gGSCodes[curr_cheat].gscodes = realloc(gGSCodes[curr_cheat].gscodes, offset + 16); + else + gGSCodes[curr_cheat].gscodes = malloc(16); + memcpy(&gGSCodes[curr_cheat].gscodes[offset], cp, 9); + memcpy(&gGSCodes[curr_cheat].gscodes[offset+9], vp, 5); + gGSCodes[curr_cheat].count++; + offset += 16; + break; + case 0xD0: + // do next gs code if ram location is equal to 8-bit value + // D0XXYYYY 00ZZ + if (gGSCodes[curr_cheat].gscodes) + gGSCodes[curr_cheat].gscodes = realloc(gGSCodes[curr_cheat].gscodes, offset + 16); + else + gGSCodes[curr_cheat].gscodes = malloc(16); + memcpy(&gGSCodes[curr_cheat].gscodes[offset], cp, 9); + memcpy(&gGSCodes[curr_cheat].gscodes[offset+9], vp, 5); + gGSCodes[curr_cheat].count++; + offset += 16; + break; + case 0xD1: + // do next gs code if ram location is equal to 16-bit value + // D1XXYYYY ZZZZ + if (gGSCodes[curr_cheat].gscodes) + gGSCodes[curr_cheat].gscodes = realloc(gGSCodes[curr_cheat].gscodes, offset + 16); + else + gGSCodes[curr_cheat].gscodes = malloc(16); + memcpy(&gGSCodes[curr_cheat].gscodes[offset], cp, 9); + memcpy(&gGSCodes[curr_cheat].gscodes[offset+9], vp, 5); + gGSCodes[curr_cheat].count++; + offset += 16; + break; + case 0xD2: + // do next gs code if ram location is not equal to 8-bit value + // D2XXYYYY 00ZZ + if (gGSCodes[curr_cheat].gscodes) + gGSCodes[curr_cheat].gscodes = realloc(gGSCodes[curr_cheat].gscodes, offset + 16); + else + gGSCodes[curr_cheat].gscodes = malloc(16); + memcpy(&gGSCodes[curr_cheat].gscodes[offset], cp, 9); + memcpy(&gGSCodes[curr_cheat].gscodes[offset+9], vp, 5); + gGSCodes[curr_cheat].count++; + offset += 16; + break; + case 0xD3: + // do next gs code if ram location is not equal to 16-bit value + // D1XXYYYY ZZZZ + if (gGSCodes[curr_cheat].gscodes) + gGSCodes[curr_cheat].gscodes = realloc(gGSCodes[curr_cheat].gscodes, offset + 16); + else + gGSCodes[curr_cheat].gscodes = malloc(16); + memcpy(&gGSCodes[curr_cheat].gscodes[offset], cp, 9); + memcpy(&gGSCodes[curr_cheat].gscodes[offset+9], vp, 5); + gGSCodes[curr_cheat].count++; + offset += 16; + break; + case 0xDD: + // deactivate expansion ram using 2nd method + // DD000000 0000 + if (gGSCodes[curr_cheat].gscodes) + gGSCodes[curr_cheat].gscodes = realloc(gGSCodes[curr_cheat].gscodes, offset + 16); + else + gGSCodes[curr_cheat].gscodes = malloc(16); + memcpy(&gGSCodes[curr_cheat].gscodes[offset], cp, 9); + memcpy(&gGSCodes[curr_cheat].gscodes[offset+9], vp, 5); + gGSCodes[curr_cheat].count++; + offset += 16; + break; + case 0xDE: + // set game boot address + // DEXXXXXX 0000 + if (gGSCodes[curr_cheat].gscodes) + gGSCodes[curr_cheat].gscodes = realloc(gGSCodes[curr_cheat].gscodes, offset + 16); + else + gGSCodes[curr_cheat].gscodes = malloc(16); + memcpy(&gGSCodes[curr_cheat].gscodes[offset], cp, 9); + memcpy(&gGSCodes[curr_cheat].gscodes[offset+9], vp, 5); + gGSCodes[curr_cheat].count++; + offset += 16; + break; + case 0xEE: + // deactivate expansion ram using 1st method + // EE000000 0000 + if (gGSCodes[curr_cheat].gscodes) + gGSCodes[curr_cheat].gscodes = realloc(gGSCodes[curr_cheat].gscodes, offset + 16); + else + gGSCodes[curr_cheat].gscodes = malloc(16); + memcpy(&gGSCodes[curr_cheat].gscodes[offset], cp, 9); + memcpy(&gGSCodes[curr_cheat].gscodes[offset+9], vp, 5); + gGSCodes[curr_cheat].count++; + offset += 16; + break; + case 0xF0: + // write 8-bit value to (cached) ram before boot + // F0XXXXXX 00YY + if (gGSCodes[curr_cheat].gscodes) + gGSCodes[curr_cheat].gscodes = realloc(gGSCodes[curr_cheat].gscodes, offset + 16); + else + gGSCodes[curr_cheat].gscodes = malloc(16); + memcpy(&gGSCodes[curr_cheat].gscodes[offset], cp, 9); + memcpy(&gGSCodes[curr_cheat].gscodes[offset+9], vp, 5); + gGSCodes[curr_cheat].count++; + offset += 16; + break; + case 0xF1: + // write 16-bit value to (cached) ram before boot + // F1XXXXXX YYYY + if (gGSCodes[curr_cheat].gscodes) + gGSCodes[curr_cheat].gscodes = realloc(gGSCodes[curr_cheat].gscodes, offset + 16); + else + gGSCodes[curr_cheat].gscodes = malloc(16); + memcpy(&gGSCodes[curr_cheat].gscodes[offset], cp, 9); + memcpy(&gGSCodes[curr_cheat].gscodes[offset+9], vp, 5); + gGSCodes[curr_cheat].count++; + offset += 16; + break; + case 0xFF: + // set code base + // FFXXXXXX 0000 + if (gGSCodes[curr_cheat].gscodes) + gGSCodes[curr_cheat].gscodes = realloc(gGSCodes[curr_cheat].gscodes, offset + 16); + else + gGSCodes[curr_cheat].gscodes = malloc(16); + memcpy(&gGSCodes[curr_cheat].gscodes[offset], cp, 9); + memcpy(&gGSCodes[curr_cheat].gscodes[offset+9], vp, 5); + gGSCodes[curr_cheat].count++; + offset += 16; + break; + } + + line_chr=0; + + + } + + + } + curr_cheat++; + gGSCodes[curr_cheat].count = 0xFFFF; // end of table + gGSCodes[curr_cheat].gscodes = NULL; + gGSCodes[curr_cheat].state = 0; + } + return 0; //ok + } + + + + + +void timing(display_context_t disp){ + + unsigned char tmp[32]; + + IO_WRITE(PI_STATUS_REG, 0x02); + + u32 pi0 = IO_READ(PI_BSD_DOM1_LAT_REG); + u32 pi1 = IO_READ(PI_BSD_DOM1_PWD_REG); + u32 pi2 = IO_READ(PI_BSD_DOM1_PGS_REG); + u32 pi3 = IO_READ(PI_BSD_DOM1_RLS_REG); + + printText("timing dom1:", 3, -1, disp); + sprintf(tmp, "lat=%x pwd=%x\npgs=%x rls=%x",pi0,pi1,pi2,pi3); + printText(tmp, 3, -1, disp); +} + + + +void bootRom(display_context_t disp, int silent){ + + + + + if(boot_cic!=0){ + + if(boot_save!=0){ + + u8 cfg_file[32]; + u8 found=0; + u8 resp=0; + u8 tmp[32]; + + + + + //set cfg file with last loaded cart info and save-type + sprintf(cfg_file, "/ED64/%s/LAST.CRT",save_path); + + resp = fatCreateRecIfNotExist(cfg_file, 0); + resp = fatOpenFileByeName(cfg_file, 1); //512 bytes fix one cluster + + //rom_filename[strlen(rom_filename)-4]='\0'; //cut extension + + static uint8_t cfg_file_data[512] = { 0 }; + cfg_file_data[0]=boot_save; + cfg_file_data[1]=boot_cic; + scopy(rom_filename, cfg_file_data+2); + //cfg_file_data[1]=cartID[0]; + //cfg_file_data[2]=cartID[1]; + //cfg_file_data[3]=cartID[2]; + //cfg_file_data[4]=cartID[3]; + + fatWriteFile(&cfg_file_data, 1); + + + sleep(500); + //set the fpga cart-save tpye + + // if(boot_save!=5) + evd_setSaveType(boot_save); + + + if(debug) printText("try to restore save from sd", 3, -1, disp); + resp = saveTypeFromSd(disp, rom_filename, boot_save); + + if(debug){ + sprintf(tmp, "saveTypeFromSd ret=%i",resp); + printText(tmp, 3, -1, disp); + } + + + + + + + } + + if(debug) + printText("Cartridge-Savetype set", 3, -1, disp); + + if(debug) + printText("information stored for reboot-save...", 3, -1, disp); + sleep(50); + + u32 cart, country; + u32 info = *(vu32 *)0xB000003C; + cart = info >> 16; + country = (info >> 8) & 0xFF; + + + + if(cheats_on){ + + gCheats=1; + printText("try to load cheat-file...", 3, -1, disp); + + char cheat_filename[64]; + //rom_filename[strlen(rom_filename)-4]='\0'; // cut extension - already cut + sprintf(cheat_filename,"/ED64/CHEATS/%s.cht",rom_filename); + + int ok = readCheatFile(cheat_filename); + + if(ok==0) + { + if(!silent) + printText("cheats found...", 3, -1, disp); + sleep(600); + }else{ + if(!silent) + printText("cheats not found...", 3, -1, disp); + gCheats=0; + sleep(2000); + } + + }else{ + gCheats=0; + + } + + disable_interrupts(); + if(!silent){ + if(gCheats) + printText("cheat boot", 3, -1, disp); + else + printText("normal boot", 3, -1, disp); + } + int bios_cic=getCicType(1); + + if(checksum_fix_on) + checksum_sdram(); + + + evd_lockRegs(); + sleep(1000); + + while( !(disp = display_lock()) ); + //blank screen to avoid glitches + graphics_fill_screen(disp, 0x000000FF); + display_show(disp); + + + simulate_boot(boot_cic, bios_cic); // boot_cic + + } +} + +void playSound(int snd){ + +//no thread support in libdragon yet, sounds pause the menu for a time :/ + + //maybe global + int v1; + + static SAMPLE *add_sfx = NULL; + if(snd==1) + add_sfx = Sample_Load("rom://ed64_mono.wav"); + + if(snd==2) + add_sfx = Sample_Load("rom://bamboo.wav"); + + if(snd==3) + add_sfx = Sample_Load("rom://warning.wav"); + + if(snd==4) + add_sfx = Sample_Load("rom://done.wav"); + + MikMod_SetNumVoices(-1, 2); + + + if (!add_sfx) { + MikMod_Exit(); + //return; + }else{ + + MikMod_EnableOutput(); + + audio_write_silence(); + audio_write_silence(); + + v1 = Sample_Play(add_sfx, 0, 0); + Voice_SetVolume(v1, 100); + + + //maybe put update function into a int/vblank callback + for(int s=0;s<50;s++){ + + MikMod_Update(); + sleep(10); + }//for + + MikMod_DisableOutput(); + Sample_Free(add_sfx); + } +} + +//draws the next char at the text input screen +void drawInputAdd(display_context_t disp, char *msg){ + + graphics_draw_box_trans(disp, 23, 5, 272, 18, 0x00000090); + position++; + sprintf(input_text, "%s%s",input_text, msg); + drawTextInput(disp,input_text); + +} + +//del the last char at the text input screen +void drawInputDel(display_context_t disp){ + + graphics_draw_box_trans(disp, 23, 5, 272, 18, 0x00000090); + if(position){ + input_text[position-1]='\0'; + drawTextInput(disp,input_text); + + position--; + } + +} + +void drawTextInput(display_context_t disp,char *msg){ + graphics_draw_text( disp, 40, 15, msg ); +} + + +void drawConfirmBox(display_context_t disp){ + + + drawBoxNumber(disp,5); + + display_show(disp); + + printText(" ", 9, 9, disp); + printText("Confirmation required:", 9, -1, disp); + printText(" ", 9, -1, disp); + printText(" ", 9, -1, disp); + printText(" Are you sure?", 9, -1, disp); + printText(" ", 9, -1, disp); + printText(" C-UP Continue ", 9, -1, disp); //set mapping 3 + printText(" ", 9, -1, disp); + printText(" B Cancel", 9, -1, disp); + + if(sound_on) playSound(3); + sleep(500); + +} + +void drawShortInfoBox(display_context_t disp, char* text, u8 mode){ + + if(mode==0) + drawBoxNumber(disp,7); + else if(mode==1) + drawBoxNumber(disp,8); + else if(mode==2) + drawBoxNumber(disp,10); + + printText(text, 9, 14, disp); + + display_show(disp); + + if(sound_on){ + if(mode==0) + playSound(4); + else if(mode==1) + playSound(3); + else if(mode==2) + playSound(4); + + } + sleep(300); + +} + + +void readRomConfig(display_context_t disp, char* short_filename, char* full_filename){ + + u8 found=0; + char cfg_filename[128]; + sprintf(rom_filename,"%s", short_filename); + rom_filename[strlen(rom_filename)-4]='\0'; // cut extension + sprintf(cfg_filename,"/ED64/CFG/%s.CFG",rom_filename); + + uint8_t rom_cfg_data[512];//[size]; + + FatRecord rec_tmpf; + found = fatFindRecord(cfg_filename, &rec_tmpf, 0); + + + if(found==0){ + //read rom-config + + u8 resp = 0; + resp = fatOpenFileByeName(cfg_filename, 0); + resp = fatReadFile(&rom_cfg_data, 1); + + + rom_config[1]=rom_cfg_data[0]; + rom_config[2]=rom_cfg_data[1]; + rom_config[3]=rom_cfg_data[2]; + rom_config[4]=rom_cfg_data[3]; + rom_config[5]=rom_cfg_data[4]; + rom_config[6]=rom_cfg_data[5]; + rom_config[7]=rom_cfg_data[6]; + rom_config[8]=rom_cfg_data[7]; + rom_config[9]=rom_cfg_data[8]; + + + + + }else{ + //preload with header data + + romInfoScreen(disp, full_filename, 1); //silent info screen with readout + + } + + + //preload cursor position 1 cic + rom_config[0]=1; + + + +} + +void alterRomConfig(int type, int mode){ + + + //mode 1 = increae mode 2 = decrease + + //cic + u8 min_cic=0; + u8 max_cic=5; + + //save + u8 min_save=0; + u8 max_save=5; + + //tv-type + u8 min_tv=0; + u8 max_tv=3; + + //cheat + u8 min_cheat=0; + u8 max_cheat=1; + + //chk fix + u8 min_chk_sum=0; + u8 max_chk_sum=1; + + //quality + u8 min_quality=0; + u8 max_quality=5; + + //country + u8 min_country=0; + u8 max_country=2; + + if(type==1){//start cic + + if(mode==1){ + //down + if(rom_config[1]min_cic) + rom_config[1]--; + if(rom_config[1]==3) rom_config[1]--; + } + }//end cic + else + if(type==2){//start save + + if(mode==1){ + //down + if(rom_config[2]min_save) + rom_config[2]--; + } + }//end save + else + if(type==3){//start tv + + if(mode==1){ + //down + if(rom_config[3]min_tv) + rom_config[3]--; + } + }//end tv + else + if(type==4){//start cheat + + if(mode==1){ + //down + if(rom_config[4]min_cheat) + rom_config[4]--; + } + }//end cheat + else + if(type==5){//start chk sum + + if(mode==1){ + //down + if(rom_config[5]min_chk_sum) + rom_config[5]--; + } + }//end chk sum + else + if(type==6){ //start quality + + if(mode==1){ + //down + if(rom_config[6]min_quality) + rom_config[6]--; + } + } + else + if(type==7){ //start country + + if(mode==1){ + //down + if(rom_config[7]min_country) + rom_config[7]--; + } + } + +} + +void drawToplistBox(display_context_t disp,int line){ + +list_pos_backup[0]=cursor; +list_pos_backup[1]=page; + +u8 list_size=0; + +if(line==0){ +//if(toplist_reload){ + + FatRecord *rec; + u8 resp = 0; + + count = 1; + dir_t buf; + + //load the directory-entry + resp = fatLoadDirByName("/ED64/CFG"); + + int dsize=dir->size; + + char toplist[dsize][256]; + + for (int i = 0; i < dir->size; i++){ + + rec = dir->rec[i]; + + + u8 rom_cfg_file[128]; + + //set rom_cfg + sprintf(rom_cfg_file, "/ED64/CFG/%s",rec->name ); + + static uint8_t cfg_file_data[512] = { 0 }; + + resp = fatOpenFileByeName(rom_cfg_file, 0); //512 bytes fix one cluster + resp = fatReadFile(&cfg_file_data, 1); + + + toplist[i][0]=(char)cfg_file_data[5]; //quality + strcpy(toplist[i]+1, cfg_file_data+32); //fullpath + + + } + + qsort(toplist, dsize, 256, compare_int_reverse); + + + if(dsize>15) + list_size=15; + else + list_size=dsize; + + for(int c = 0; c < list_size; c++) + strcpy(toplist15[c], toplist[c]); + + list_pos_backup[2]=list_size; +//toplist_reload=0; +} + + list_size=list_pos_backup[2]; + + + + u8 min=1; + u8 max=15; + u8 real_max=0; + + for(int c = 0; c < list_size; c++) + if(toplist15[c][0]!=0) + real_max++; + + max=real_max; + + //cursor line + if(line!=0){ + + if(line==1){ + //down + if(toplist_cursormin) + toplist_cursor--; + } + } + + + + + + drawBoxNumber(disp,9); //toplist +//drawToplistSelection(disp, toplist_cursor); + + printText(" -Toplist 15-", 4, 7, disp); + printText(" ", 4, -1, disp); + + uint32_t forecolor; + uint32_t backcolor; + backcolor = graphics_make_color(0x00, 0x00, 0x00, 0xFF); //bg + forecolor = graphics_make_color(0xFF, 0xFF, 0xFF, 0xFF); //fg + + + + for(int t = 0; t < 15; t++){ + + int quality_level=toplist15[t][0]; //quality + + if(quality_level!=0){ + + switch(quality_level){ + + case 1: forecolor = graphics_make_color(0xFF, 0xFF, 0xFF, 0xFF); //common (white) + break; + case 2: forecolor = graphics_make_color(0x00, 0xFF, 0x00, 0xCF); //uncommon (green) + break; + case 3: forecolor = graphics_make_color(0x1E, 0x90, 0xFF, 0xFF); //rare (blue) + break; + case 4: forecolor = graphics_make_color(0x9B, 0x30, 0xFF, 0xFF); //epic (purple) + break; + case 5: forecolor = graphics_make_color(0xFF, 0xA5, 0x00, 0xFF); //legendary (orange) + break; + default: break; + } + + graphics_set_color (forecolor, backcolor); + //max 32 chr + + u8 short_name[256]; + + sprintf(short_name, "%s", toplist15[t]+1); + + u8 * pch_s; // point-offset + pch_s=strrchr(short_name,'/'); + + /* + u8 * pch; // point-offset + pch=strrchr(short_name,'.'); + short_name[31]='\0'; + short_name[pch-short_name]='\0'; + */ + u8 * pch; // point-offset + pch=strrchr(pch_s,'.'); + pch_s[30]='\0'; //was 31 + pch_s[pch-pch_s]='\0'; + + //printText(short_name, 4, -1, disp); + if(t+1==toplist_cursor) + printText(pch_s+1, 5, -1, disp); + else + printText(pch_s+1, 4, -1, disp); + + //restore color + graphics_set_color(graphics_make_color(0xFF, 0xFF, 0xFF, 0xFF), graphics_make_color(0x00, 0x00, 0x00, 0x00)); + } + + }//for15 + +/* +if(line==0){ + if(sound_on) playSound(4); + sleep(500); +} +*/ + + +} + + + +void drawRomConfigBox(display_context_t disp,int line){ + + u8 min=1; + u8 max=7; + + //cursor line + if(line!=0){ + + if(line==1){ + //down + if(rom_config[0]min) + rom_config[0]--; + } + } + + drawBoxNumber(disp,6); + + drawConfigSelection(disp, rom_config[0]); + //display_show(disp); + + printText(" ", 9, 9, disp); + printText("Rom configuration:", 9, -1, disp); + printText(" ", 9, -1, disp); + + + + switch(rom_config[1]){ + case 0: printText(" CIC: 6101", 9, -1, disp); break; + case 1: printText(" CIC: 6102", 9, -1, disp); break; + case 2: printText(" CIC: 6103", 9, -1, disp); break; + case 3: printText(" CIC: 6104", 9, -1, disp); break; //do i really need 6104 in that list? :D + case 4: printText(" CIC: 6105", 9, -1, disp); break; + case 5: printText(" CIC: 6106", 9, -1, disp); break; + default: break; + + } + + switch(rom_config[2]){ + case 0: printText(" Save: Off/Mempak", 9, -1, disp); break; + case 1: printText(" Save: Sram 32", 9, -1, disp); break; + case 2: printText(" Save: Sram 128", 9, -1, disp); break; + case 3: printText(" Save: Eeprom 4k", 9, -1, disp); break; + case 4: printText(" Save: Eeprom 16k", 9, -1, disp); break; + case 5: printText(" Save: Flashram", 9, -1, disp); break; + default: break; + + } + + switch(rom_config[3]){ + case 0: printText(" Tv: Force off", 9, -1, disp); break; + case 1: printText(" Tv: NTSC", 9, -1, disp); break; + case 2: printText(" Tv: PAL", 9, -1, disp); break; + case 3: printText(" Tv: M-PAL", 9, -1, disp); break; + + default: break; + + + } + + switch(rom_config[4]){ + case 0: printText(" Cheat: off", 9, -1, disp); break; + case 1: printText(" Cheat: on", 9, -1, disp); break; + default: break; + + +} + + switch(rom_config[5]){ + case 0: printText("Checksum: disable fix", 9, -1, disp); break; + case 1: printText("Checksum: enable fix", 9, -1, disp); break; + default: break; + + +} + + switch(rom_config[6]){ + case 0: printText(" Rating: off", 9, -1, disp); break; + case 1: printText(" Rating: common", 9, -1, disp); break; + case 2: printText(" Rating: uncommon", 9, -1, disp); break; + case 3: printText(" Rating: rare", 9, -1, disp); break; + case 4: printText(" Rating: epic", 9, -1, disp); break; + case 5: printText(" Rating: legendary", 9, -1, disp); break; + + default: break; + + +} + + switch(rom_config[7]){ + case 0: printText(" Country: default", 9, -1, disp); break; + case 1: printText(" Country: NTSC", 9, -1, disp); break; + case 2: printText(" Country: PAL", 9, -1, disp); break; + default: break; + + +} + + + printText(" ", 9, -1, disp); + printText("B Cancel", 9, -1, disp); + printText("A Save config", 9, -1, disp); + + + + + //cursor position + // if(line=0) + // rom_config[0]=1; + +} + + + +//draws the charset for the textinputscreen +void drawSet1(display_context_t disp){ + + set=1; + uint32_t forecolor; + uint32_t backcolor; + backcolor = graphics_make_color(0x00, 0x00, 0x00, 0xFF); + + forecolor = graphics_make_color(0xFF, 0xFF, 0x00, 0xFF); //yellow + + + graphics_draw_text( disp, 80, 40, "<" ); //L + graphics_set_color (forecolor, backcolor); + graphics_draw_text( disp, 233, 40, "A" ); //R + graphics_draw_text( disp, 223, 62, "B" ); //G up + graphics_draw_text( disp, 210, 74, "C" ); //G left + graphics_draw_text( disp, 235, 74, "D" ); //G right + graphics_draw_text( disp, 193, 86, "E" ); //B + graphics_draw_text( disp, 223, 86, "F" ); //G down + graphics_draw_text( disp, 209, 100, "G" ); //A + +} + + +void drawSet2(display_context_t disp){ + + set=2; + uint32_t forecolor; + uint32_t backcolor; + backcolor = graphics_make_color(0x00, 0x00, 0x00, 0xFF); + + forecolor = graphics_make_color(0xFF, 0xFF, 0x00, 0xFF); + + + graphics_draw_text( disp, 80, 40, "<" ); + graphics_set_color (forecolor, backcolor); + graphics_draw_text( disp, 233, 40, "H" ); + graphics_draw_text( disp, 223, 62, "I" ); + graphics_draw_text( disp, 210, 74, "J" ); + graphics_draw_text( disp, 235, 74, "K" ); + graphics_draw_text( disp, 193, 86, "L" ); + graphics_draw_text( disp, 223, 86, "M" ); + graphics_draw_text( disp, 209, 100, "N" ); + +} + +void drawSet3(display_context_t disp){ + + set=3; + uint32_t forecolor; + uint32_t backcolor; + backcolor = graphics_make_color(0x00, 0x00, 0x00, 0xFF); + + forecolor = graphics_make_color(0xFF, 0xFF, 0x00, 0xFF); + + + graphics_draw_text( disp, 80, 40, "<" ); + graphics_set_color (forecolor, backcolor); + graphics_draw_text( disp, 233, 40, "O" ); + graphics_draw_text( disp, 223, 62, "P" ); + graphics_draw_text( disp, 210, 74, "Q" ); + graphics_draw_text( disp, 235, 74, "R" ); + graphics_draw_text( disp, 193, 86, "S" ); + graphics_draw_text( disp, 223, 86, "T" ); + graphics_draw_text( disp, 209, 100, "U" ); + +} + +display_context_t lockVideo(int wait) +{ + display_context_t dc; + + if (wait) + while (!(dc = display_lock())); + else + dc = display_lock(); + return dc; +} + + +void drawSet4(display_context_t disp){ + + set=4; + uint32_t forecolor; + uint32_t backcolor; + backcolor = graphics_make_color(0x00, 0x00, 0x00, 0xFF); + + forecolor = graphics_make_color(0xFF, 0xFF, 0x00, 0xFF); + + + graphics_draw_text( disp, 80, 40, "<" ); + graphics_set_color (forecolor, backcolor); + graphics_draw_text( disp, 233, 40, "V" ); + graphics_draw_text( disp, 223, 62, "W" ); + graphics_draw_text( disp, 210, 74, "X" ); + graphics_draw_text( disp, 235, 74, "Y" ); + graphics_draw_text( disp, 193, 86, "Z" ); + graphics_draw_text( disp, 223, 86, "-" ); + graphics_draw_text( disp, 209, 100, "_" ); + +} + + +//entry point +int main(void) +{ + + int fast_boot=0; + + + //reserve memory + list = malloc(sizeof(direntry_t)); + //list = malloc(sizeof(direntry_t)); + + + //dfs init for the rom-attached virtual filesystem + if(dfs_init( DFS_DEFAULT_LOCATION ) != DFS_ESUCCESS) + { + printf("Filesystem failed to start!\n"); + } + else + { + + int fpf = dfs_open("/firmware.bin"); + firmware = malloc( dfs_size( fpf ) ); + dfs_read( firmware, 1, dfs_size( fpf ), fpf ); + dfs_close( fpf ); + + + //everdirve initial function + configure(); + + + //fast boot for backup-save data + int sj = evd_readReg(0); + int save_job = evd_readReg(REG_SAV_CFG); + + if(save_job!=0) + fast_boot=1; + + + //not gamepads more or less the n64 hardware-controllers + controller_init(); + + //filesystem on + initFilesystem(); + sleep(200); + + + readConfigFile(); + //n64 initialization + + + if(tv_mode!=0){ + *(u32 *) 0x80000300 = tv_mode; + } + + + + init_interrupts(); + + + //background + display_init( res, DEPTH_32_BPP, 3, GAMMA_NONE, ANTIALIAS_RESAMPLE ); + + + //bg buffer + static display_context_t disp; + + //Grab a render buffer + while( !(disp = display_lock()) ); + //backgrounds from ramfs/libdragonfs + + if(!fast_boot){ + background0 = read_sprite( "rom://sprites/splash.sprite" ); + graphics_draw_sprite( disp, 0, 0, background0 ); //start-picture + display_show(disp); + } + + char background_path[64]; + sprintf(background_path, "/ED64/wallpaper/%s", background_image); + int found; + FatRecord rec_tmpf; + found = fatFindRecord(background_path, &rec_tmpf, 0); + if(found==0){ + + background = loadPng(background_path); + }else{ + background = read_sprite( "rom://sprites/background.sprite" ); + } + sleep(200); + + //mp3 + int buf_size; + char *buf_ptr; + + if(sound_on){ + + audio_init(44100,2); + //load soundsystem + timer_init(); + + + MikMod_RegisterAllDrivers(); + MikMod_RegisterAllLoaders(); + + md_mode = 0; + md_mode |= DMODE_16BITS; + md_mode |= DMODE_SOFT_MUSIC; + md_mode |= DMODE_SOFT_SNDFX; + + //md_mode |= DMODE_STEREO; + + md_mixfreq = audio_get_frequency(); + + MikMod_Init(""); + } + + + + if(!fast_boot){ + if(sound_on) playSound(1); + + sleep(2000); //splash screen duration + } + + + border_color_1 = translate_color(border_color_1_s); + border_color_2= translate_color(border_color_2_s); + box_color= translate_color(box_color_s); + selection_color= translate_color(selection_color_s); + selection_font_color= translate_color(selection_font_color_s); + list_font_color= translate_color(list_font_color_s); + list_dir_font_color= translate_color(list_dir_font_color_s); + + + + while( !(disp = display_lock()) ); + + drawBg(disp); //new + drawBoxNumber(disp,1); //new + + uint32_t *buffer = (uint32_t *)__get_buffer( disp ); //fg disp = 2 + + display_show(disp); //new + + backupSaveData(disp); + + + + while( !(disp = display_lock()) ); + + + sprintf(pwd,"%s", "/"); + readSDcard(disp,"/"); + + display_show(disp); + //chr input coord + x=30; + y=30; + + position=0; + set=1; + sprintf(input_text, ""); + + //sprite for chr input + int fp = dfs_open("/n64controller.sprite"); + sprite_t *contr = malloc( dfs_size( fp ) ); + dfs_read( contr, 1, dfs_size( fp ), fp ); + dfs_close( fp ); + + + + //wip font support + //init_fonts(); + + //sd card speed settings from config + if(sd_speed==2){ + bi_speed50(); + } + else{ + bi_speed25(); + } + + + //system main-loop with controller inputs-scan + while(1) + { + + if (playing==1) + playing = update_mp3(buf_ptr, buf_size); + + + + + if(input_mapping==1) + sleep(60); + + if(input_mapping==3){ + + while( !(disp = display_lock()) ); + + graphics_draw_sprite( disp, 0, 0, contr ); + /* Set the text output color */ + graphics_set_color( 0x0, 0xFFFFFFFF ); + + chr_forecolor = graphics_make_color(0xFF, 0x14, 0x94, 0xFF); //pink + graphics_set_color (chr_forecolor, chr_backcolor); + + graphics_draw_text( disp, 85, 55, "SETS" ); + graphics_draw_text( disp, 94, 70, "1" ); //u + graphics_draw_text( disp, 104, 82, "2" ); //r + graphics_draw_text( disp, 94, 93, "3" ); //d + graphics_draw_text( disp, 82, 82, "4" ); //l + + graphics_draw_text( disp, 208, 206, "press START" ); + + if(set==1) + drawSet1(disp); + if(set==2) + drawSet2(disp); + if(set==3) + drawSet3(disp); + if(set==4) + drawSet4(disp); + + drawTextInput(disp, input_text); + + /* Force backbuffer flip */ + display_show(disp); + + + } //mapping 2 chr input drawings + + + + //request controller + controller_scan(); + struct controller_data keys = get_keys_down(); + struct controller_data keys_held = get_keys_held(); + + if(keys.c[0].up || keys_held.c[0].up || keys_held.c[0].y > +25) + { + if(input_mapping==1){ + if(select_mode){ + + if(count!=0){ + + if(scroll_behaviour==1) + cursor--; + else + if(cursor!=0) + if((cursor+0)%20==0){ + + cursor--; + page-=20; + } + else{ + + cursor--; + } + + //end + while( !(disp = display_lock()) ); + + new_scroll_pos(&cursor, &page, MAX_LIST, count); + + clearScreen(disp); //part clear? + display_dir(list, cursor, page, MAX_LIST, count, disp); + + display_show(disp); + } + } + } + else + if(input_mapping==2){ + + } + else + if(input_mapping==3){ + //chr input screen + set=1; + } + else + if(input_mapping==7){ + + while( !(disp = display_lock()) ); + + new_scroll_pos(&cursor, &page, MAX_LIST, count); + clearScreen(disp); //part clear? + //display_show(disp_bg); + display_dir(list, cursor, page, MAX_LIST, count, disp); + + drawRomConfigBox(disp,2); + display_show(disp); + input_mapping=7; + sleep(80); + + } + else + if(input_mapping==8){ + + + + while( !(disp = display_lock()) ); + + /* + readSDcard(disp,list_pwd_backup); + + if(scroll_behaviour==0){ + cursor=list_pos_backup[0]; + page=list_pos_backup[1]; + } + else{ + cursor_line=0; + } + */ + //clearScreen(disp); //part clear? + drawBg(disp); //background + //display_dir(list, cursor, page, MAX_LIST, count, disp); + + // display_show(disp); + + + + drawToplistBox(disp,2); + + display_show(disp); + input_mapping=8; + sleep(80); + + } + + + } + + if(keys.c[0].down || keys_held.c[0].down || keys_held.c[0].y < -25) + { + + if(input_mapping==1){ + if(select_mode){ + + if(count!=0){ + if(scroll_behaviour==1) + cursor++; + else + if(cursor+1!=count) + if((cursor+1)%20==0){ + + cursor++; + page+=20; + } + else{ + + cursor++; + } + + + + while( !(disp = display_lock()) ); + + new_scroll_pos(&cursor, &page, MAX_LIST, count); + clearScreen(disp); //part clear? + //display_show(disp_bg); + display_dir(list, cursor, page, MAX_LIST, count, disp); + + + display_show(disp); + } + } + } + else + if(input_mapping==2){ + + } + else + if(input_mapping==3){ + //chr input screen + set=3; + } + else + if(input_mapping==7){ + + while( !(disp = display_lock()) ); + + new_scroll_pos(&cursor, &page, MAX_LIST, count); + clearScreen(disp); //part clear? + + //display_show(disp_bg); + display_dir(list, cursor, page, MAX_LIST, count, disp); + + + + + drawRomConfigBox(disp,1); + + display_show(disp); + input_mapping=7; + sleep(80); + + } + else + if(input_mapping==8){ + + + + while( !(disp = display_lock()) ); + +/* + readSDcard(disp,list_pwd_backup); + + if(scroll_behaviour==0){ + cursor=list_pos_backup[0]; + page=list_pos_backup[1]; + } + else{ + cursor_line=0; + } + */ + //clearScreen(disp); //part clear? + drawBg(disp); + //display_dir(list, cursor, page, MAX_LIST, count, disp); + + // display_show(disp); + + + + drawToplistBox(disp,1); + + display_show(disp); + input_mapping=8; + sleep(80); + + } + + } + else + if(keys.c[0].left || keys_held.c[0].left || keys_held.c[0].x < -25) + { + if(input_mapping==1){ + if(select_mode){ + + if(count!=0){ + if(scroll_behaviour==0) + if(cursor-20>=0){ + page-=20; + cursor=page; + } + } + + while( !(disp = display_lock()) ); + + new_scroll_pos(&cursor, &page, MAX_LIST, count); + clearScreen(disp); //part clear? + //display_show(disp_bg); + display_dir(list, cursor, page, MAX_LIST, count, disp); + + + display_show(disp); + } + + + } + else + if(input_mapping==2){ + + } + else + if(input_mapping==3){ + //chr input screen + set=4; + } + else + if(input_mapping==7){ + + while( !(disp = display_lock()) ); + + new_scroll_pos(&cursor, &page, MAX_LIST, count); + clearScreen(disp); //part clear? + //display_show(disp_bg); + display_dir(list, cursor, page, MAX_LIST, count, disp); + + + alterRomConfig(rom_config[0], 2); + + + drawRomConfigBox(disp,0); + display_show(disp); + input_mapping=7; + sleep(80); + + } + + } + else + if(keys.c[0].right || keys_held.c[0].right || keys_held.c[0].x > +25) + { + if(input_mapping==1){ + if(select_mode){ + + if(count!=0){ + if(scroll_behaviour==0){ + if(page+20!=count) + if(cursor+20 <= ( (count/20)*20 +19 ) ){ + page+=20; + cursor=page; + } + } + } + + while( !(disp = display_lock()) ); + + new_scroll_pos(&cursor, &page, MAX_LIST, count); + clearScreen(disp); //part clear? + //display_show(disp_bg); + display_dir(list, cursor, page, MAX_LIST, count, disp); + + + display_show(disp); + } + + + } + else + if(input_mapping==2){ + + } + else + if(input_mapping==3){ + //chr input screen + set=2; + } + else + if(input_mapping==7){ + + while( !(disp = display_lock()) ); + + new_scroll_pos(&cursor, &page, MAX_LIST, count); + clearScreen(disp); //part clear? + //display_show(disp_bg); + display_dir(list, cursor, page, MAX_LIST, count, disp); + + + alterRomConfig(rom_config[0], 1); + + drawRomConfigBox(disp,0); + display_show(disp); + input_mapping=7; + sleep(80); + + } + + } + else if( keys.c[0].start ){ + + + if(input_mapping==1){ + //quick boot + + if(quick_boot){ + + FatRecord rec_last; + uint8_t lastrom_cfg_data[512];//[size]; + + + if(fatFindRecord("/ED64/LASTROM.CFG", &rec_last, 0)==0){ + + //drawShortInfoBox(disp, " quick boot",0); + + u8 resp = 0; + resp = fatOpenFileByeName("/ED64/LASTROM.CFG", 0); + resp = fatReadFile(&lastrom_cfg_data, 1); + + + + u8 * short_s; + short_s=strrchr(lastrom_cfg_data,'/'); + + while( !(disp = display_lock()) ); + clearScreen(disp); + + sleep(100); + evd_ulockRegs(); + sleep(100); + + select_mode=9; + //short fullpath + readRomConfig(disp, short_s+1, lastrom_cfg_data); + + loadrom(disp, lastrom_cfg_data, 1); + display_show(disp); + + } + //nothing else :> + + drawShortInfoBox(disp, " rom not found",0); + + + } + else + if(list[cursor].type != DT_DIR && empty==0){ + + + char name_file[64]; + + if(strcmp(pwd,"/")==0 ) + sprintf(name_file,"/%s", list[cursor].filename); + else + sprintf(name_file,"%s/%s", pwd, list[cursor].filename); + + /*filetype + * 1 rom + * 2 mempak + * 3 background + * 4 mp3 + */ + + int ft=0; + char _upper_name_file[64]; + + strcpy(_upper_name_file, name_file); + + strhicase(_upper_name_file, strlen (_upper_name_file)); + sprintf(_upper_name_file, "%s", _upper_name_file ); + + u8 extension[4]; + u8 * pch; + pch=strrchr(_upper_name_file,'.'); //asd.n64 + + + sprintf(extension, "%s",(pch+1)); //0123456 + + + if(!strcmp(extension,"GB" )) + ft=5; + if(!strcmp(extension,"GBC" )) + ft=6; + if(!strcmp(extension,"NES" )) + ft=7; + if(!strcmp(extension,"GG" )) + ft=8; + if(!strcmp(extension,"MSX" )) + ft=9; + + if(!strcmp(extension,"MPK" )) + ft=2; + if(!strcmp(extension,"Z64") || !strcmp(extension,"V64" ) || !strcmp(extension,"N64" ) ) + ft=1; + + + + if(ft==1){ //rom + //load rom + + while( !(disp = display_lock()) ); + clearScreen(disp); + u16 msg = 0; + sleep(300); + evd_ulockRegs(); + sleep(300); + sprintf(rom_filename,"%s", list[cursor].filename); + + + select_mode=9; + + //read rom_config data + readRomConfig(disp, rom_filename, name_file); + + loadrom(disp,name_file, 1); + display_show(disp); + //display_show(disp); + + //rom loaded mapping + input_mapping=4; + + }else + if(ft==5 || ft==6){ //gb/gbc rom + //load rom + + while( !(disp = display_lock()) ); + clearScreen(disp); + u16 msg = 0; + sleep(300); + evd_ulockRegs(); + sleep(300); + sprintf(rom_filename,"%s", list[cursor].filename); + display_show(disp); + + select_mode=9; + + loadgbrom(disp,name_file); + + display_show(disp); + }else + if(ft==2){ //mempak + + + + + } + else + if(ft==7){ //nes + //load rom + + while( !(disp = display_lock()) ); + clearScreen(disp); + u16 msg = 0; + sleep(300); + evd_ulockRegs(); + sleep(300); + sprintf(rom_filename,"%s", list[cursor].filename); + display_show(disp); + + select_mode=9; + + loadnesrom(disp,name_file); + + display_show(disp); + } + else + if(ft==8){ //gg + //load gg rom + + while( !(disp = display_lock()) ); + clearScreen(disp); + u16 msg = 0; + sleep(300); + evd_ulockRegs(); + sleep(300); + sprintf(rom_filename,"%s", list[cursor].filename); + display_show(disp); + + select_mode=9; + + loadggrom(disp,name_file); + + display_show(disp); + } + else + if(ft==9){ //msx2 + //load msx2 rom + + while( !(disp = display_lock()) ); + clearScreen(disp); + u16 msg = 0; + sleep(300); + evd_ulockRegs(); + sleep(300); + sprintf(rom_filename,"%s", list[cursor].filename); + display_show(disp); + + select_mode=9; + + loadmsx2rom(disp,name_file); + + display_show(disp); + } + + + } + } + else + if(input_mapping==2){ + + + } + else + if(input_mapping==3){ + + + //better config color-set + graphics_set_color(graphics_make_color(0xFF, 0xFF, 0xFF, 0xFF), graphics_make_color(0x00, 0x00, 0x00, 0x00)); + clearScreen(disp); + display_dir(list, cursor, page, MAX_LIST, count, disp); + + if(input_text[0]!='\0'){ //input_text is set - do backup + drawBoxNumber(disp,2); + + display_show(disp); + + printText("Mempak-Backup:", 9, 9, disp); + printText(" ", 9, -1, disp); + printText("search...", 9, -1, disp); + mpk_to_file(disp, input_text, 0); + sleep(300); + + drawShortInfoBox(disp, " done",0); + //input_mapping=98; + sleep(2000); + + //reread filesystem + cursor_line=0; + readSDcard(disp,"/"); + } + + input_mapping=1; + + } + else + if(input_mapping==4){ + //rom start screen + + //normal boot + //boot the loaded rom + bootRom(disp, 0); + //never return + + } + + + + } + else if( keys.c[0].L ) + { + if(input_mapping==1){ + + input_mapping=2; + + drawBoxNumber(disp,2); + + display_show(disp); + + printText("Mempak-Subsystem:", 9, 9, disp); + printText(" ", 9, -1, disp); + printText(" ", 9, -1, disp); + printText(" Z: View content", 9, -1, disp); + printText(" ", 9, -1, disp); + printText(" A: Backup - new", 9, -1, disp); //set mapping 3 + printText(" ", 9, -1, disp); + printText(" R: Format", 9, -1, disp); + printText(" ", 9, -1, disp); + printText(" B: Abort", 9, -1, disp); + if(sound_on) playSound(2); + sleep(500); + } + else + if(input_mapping==2){ + + } + else + if(input_mapping==3){ + //chr input screen + drawInputDel(disp); + } + else + if(input_mapping==9){ + //c-up or A + drawConfirmBox(disp); + //confirm restore mpk + input_mapping=6; + } + + + //placeholder + } + else if( keys.c[0].R ) + { + if(input_mapping==1){ + + + + } + else + if(input_mapping==2){ + + //c-up or A + drawConfirmBox(disp); + //confirm format mpk + input_mapping=5; + + } + else + if(input_mapping==3){ + //chr input screen + if(set==1) + drawInputAdd(disp, "A"); //P X ) + if(set==2) + drawInputAdd(disp, "H"); + if(set==3) + drawInputAdd(disp, "O"); + if(set==4) + drawInputAdd(disp, "V"); + } + else + if(input_mapping==9){ + //c-up or A + drawConfirmBox(disp); + //confirm quick-backup + input_mapping=10; + + + } + + //placeholder + } + else if( keys.c[0].C_up ) + { + if(input_mapping==1){ + + + if(list[cursor].type != DT_DIR && empty==0){ + drawBoxNumber(disp,11); + + char *part; + + part = malloc(slen(list[cursor].filename)); + sprintf(part,"%s", list[cursor].filename); + part[31]='\0'; + + printText(part, 4, 14, disp); + + + if(slen(list[cursor].filename)>31){ + sprintf(part,"%s", list[cursor].filename+31); + part[31]='\0'; + printText(part, 4, -1, disp); + } + + free(part); + input_mapping=98; + } + + } + else + if(input_mapping==2){ + + } + else + if(input_mapping==3){ + //chr input screen + if(set==1) + drawInputAdd(disp, "B"); //P X ) + if(set==2) + drawInputAdd(disp, "I"); + if(set==3) + drawInputAdd(disp, "P"); + if(set==4) + drawInputAdd(disp, "W"); + } + else + if(input_mapping==4){ + //rom start screen + if(cheats_on==0){ + printText("cheat system activated...", 3, -1, disp); + cheats_on=1; + } + + } + else //format mpk + if(input_mapping==5){ + + drawBoxNumber(disp,2); + // writeInitText(disp); + + display_show(disp); + + printText("Mempak-Format:", 9, 9, disp); + printText(" ", 9, -1, disp); + //printText("search...", 9, -1, disp); + + printText("formating...", 9, -1, disp); + + /* Make sure they don't have a rumble pak inserted instead */ + switch( identify_accessory( 0 ) ) + { + + + case ACCESSORY_NONE: + + printText("No Mempak", 9, -1, disp); + break; + case ACCESSORY_MEMPAK: + printText("Please wait...", 9, -1, disp); + if( format_mempak( 0 ) ) + { + printText("Error formatting!", 9, -1, disp); + } + else + { + // printText("done...", 9, -1, disp); + + drawShortInfoBox(disp, " done",0); + input_mapping=98; + + } + + break; + case ACCESSORY_RUMBLEPAK: + + printText("Cannot format rumblepak!", 9, -1, disp); + break; + } + + + sleep(500); + + //reread filesystem + //readSDcard(disp,"/"); + + + input_mapping=98; + } + else //restore mpk + if(input_mapping==6){ + + + drawBoxNumber(disp,2); + + + display_show(disp); + + printText("Mempak-Restore:", 9, 9, disp); + printText(" ", 9, -1, disp); + + file_to_mpk(disp, rom_filename); + + sleep(300); + + drawShortInfoBox(disp, " done",0); + input_mapping=98; + + // input_mapping=98; + display_show(disp); + + + } + else //quick-backup + if(input_mapping==10){ + drawBoxNumber(disp,2); + + display_show(disp); + + printText("Quick-Backup:", 9, 9, disp); + printText(" ", 9, -1, disp); + printText("search...", 9, -1, disp); + mpk_to_file(disp, list[cursor].filename ,1); //quick + sleep(300); + + drawShortInfoBox(disp, " done",0); + //input_mapping=98; + sleep(500); + input_mapping=98; + //reread filesystem + // cursor_line=0; + //readSDcard(disp,"/"); + } + + + + } + else + if( keys.c[0].C_right ) + { + //placeholder + if(input_mapping==1 && list[cursor].type != DT_DIR){ + //show rom cfg screen + + char name_file[64]; + + if(strcmp(pwd,"/")==0 ) + sprintf(name_file,"/%s", list[cursor].filename); + else + sprintf(name_file,"%s/%s", pwd, list[cursor].filename); + + /*filetype + * 1 rom + */ + + int ft=0; + char _upper_name_file[64]; + + strcpy(_upper_name_file, name_file); + + strhicase(_upper_name_file, strlen (_upper_name_file)); + sprintf(_upper_name_file, "%s", _upper_name_file ); + + u8 extension[4]; + u8 * pch; + pch=strrchr(_upper_name_file,'.'); //asd.n64 + + + sprintf(extension, "%s",(pch+1)); //0123456 + + + if(!strcmp(extension,"Z64") || !strcmp(extension,"V64" ) || !strcmp(extension,"N64" ) ) + ft=1; + + if(ft==1){ //rom + //cfg rom + + sprintf(rom_filename,"%s", list[cursor].filename); + + + //preload config or file header + readRomConfig(disp, rom_filename, name_file); + + drawRomConfigBox(disp,0); + display_show(disp); + input_mapping=7; + + } + + + } + else + if(input_mapping==2){ + + } + else + if(input_mapping==3){ + //chr input screen + if(set==1) + drawInputAdd(disp, "D"); //P X ) + if(set==2) + drawInputAdd(disp, "K"); + if(set==3) + drawInputAdd(disp, "R"); + if(set==4) + drawInputAdd(disp, "Y"); + } + else + if(input_mapping==4){ + //rom start screen + + if(force_tv!=0){ + printText("force tv mode...", 3, -1, disp); + + } + + + } + + + } + else + if( keys.c[0].C_down ) + { + //placeholder + if(input_mapping==1){ + + input_mapping=99; + + //sprintf(list_pwd_backup,"%s",pwd); + scopy(pwd, list_pwd_backup); + while( !(disp = display_lock()) ); + + drawBg(disp); //background + + + toplist_cursor=1; + drawToplistBox(disp,0); //0 = load entries + + display_show(disp); + + input_mapping=8; + //input_mapping=97; + + } + else + if(input_mapping==2){ + + } + else + if(input_mapping==3){ + //chr input screen + if(set==1) + drawInputAdd(disp, "F"); //P X ) + if(set==2) + drawInputAdd(disp, "M"); + if(set==3) + drawInputAdd(disp, "T"); + if(set==4) + drawInputAdd(disp, "-"); //GR Set4 + } + } + else + if( keys.c[0].C_left ) + { + //placeholder + if(input_mapping==1){ + + if(input_mapping==1 && list[cursor].type != DT_DIR ){//open + + char name_file[64]; + + if(strcmp(pwd,"/")==0 ) + sprintf(name_file,"/%s", list[cursor].filename); + else + sprintf(name_file,"%s/%s", pwd, list[cursor].filename); + + /*filetype + * 1 rom + * 2 mempak + * 3 background + * 4 mp3 + */ + + int ft=0; + char _upper_name_file[64]; + + strcpy(_upper_name_file, name_file); + + strhicase(_upper_name_file, strlen (_upper_name_file)); + sprintf(_upper_name_file, "%s", _upper_name_file ); + + u8 extension[4]; + u8 * pch; + pch=strrchr(_upper_name_file,'.'); + + + sprintf(extension, "%s",(pch+1)); + + if(!strcmp(extension,"MPK" )) + ft=2; + if(!strcmp(extension,"Z64") || !strcmp(extension,"V64" ) || !strcmp(extension,"N64" ) ) + ft=1; + + + if(ft==1){ //rom + //load rom + + + input_mapping=99; + + drawBoxNumber(disp,3); //rominfo + + u16 msg = 0; + sleep(300); + evd_ulockRegs(); + sleep(300); + sprintf(rom_filename,"%s", list[cursor].filename); + romInfoScreen(disp, name_file, 0); + + + if(sound_on) playSound(2); + sleep(500); + input_mapping=98; + + } + if(ft==2){ //mpk file + + drawBoxNumber(disp,4); + // writeInitText(disp); + + display_show(disp); + + if(strcmp(pwd,"/")==0 ) + sprintf(rom_filename,"/%s", list[cursor].filename); + else + sprintf(rom_filename,"%s/%s", pwd, list[cursor].filename); + + + // sprintf(rom_filename,"%s", list[cursor].filename); + view_mpk_file(disp, rom_filename); + + if(sound_on) playSound(2); + sleep(500); + input_mapping=98; + + + } + + } //mapping and not dir + + } + else + if(input_mapping==2){ + + } + else + if(input_mapping==3){ + //chr input screen + if(set==1) + drawInputAdd(disp, "C"); //P X ) + if(set==2) + drawInputAdd(disp, "J"); + if(set==3) + drawInputAdd(disp, "Q"); + if(set==4) + drawInputAdd(disp, "X"); + } + } + else + if(keys.c[0].Z){ + + if(input_mapping==1){ + + input_mapping=99; + + drawBoxNumber(disp,2); + + display_show(disp); + + printText("About: ", 9, 9, disp); + printText(" ", 9, -1, disp); + printText("ALT64: v0.1.8.6", 9, -1, disp); + printText("by saturnu", 9, -1, disp); + printText(" ", 9, -1, disp); + printText("thanks to:", 9, -1, disp); + printText("Krikzz", 9, -1, disp); + printText("ChillyWilly", 9, -1, disp); + printText("ShaunTaylor", 9, -1, disp); + printText("Conle", 9, -1, disp); + + /* + char mpkp[64]; + sprintf(mpkp, "%s", mempak_path); + printText(mpkp, 9, -1, disp); + */ + + if(sound_on) playSound(2); + sleep(500); + input_mapping=98; + + + + } + else + if(input_mapping==2){ + + + drawBoxNumber(disp,4); + // writeInitText(disp); + + display_show(disp); + + + view_mpk(disp); + + if(sound_on) playSound(2); + sleep(500); + input_mapping=98; + + } + + + //placeholder + } + else + if(keys.c[0].A) //open + { + + + if(input_mapping==1){ + while( !(disp = display_lock()) ); + + if(input_mapping==1 && list[cursor].type == DT_DIR && empty==0){ + char name_dir[256]; + + /* init pwd=/ + * / + * + * cursor=ED64 + * /ED64 + * + * cursor=SAVE + * /ED64/SAVE + */ + + + if(strcmp(pwd,"/")==0 ) + sprintf(name_dir,"/%s", list[cursor].filename); + else + sprintf(name_dir,"%s/%s", pwd, list[cursor].filename); + + sprintf(curr_dirname,"%s", list[cursor].filename); + sprintf(pwd,"%s", name_dir); + + //load dir + + cursor_lastline=0; + cursor_line=0; + + + //backup tree cursor postions + + if(cd_behaviour==1){ + //if(cursor){ + cursor_history[cursor_history_pos]=cursor; + cursor_history_pos++; + //} + } + + readSDcard(disp,name_dir); + display_show(disp); + + + + }//mapping 1 and dir + else + if(input_mapping==1 && list[cursor].type != DT_DIR && empty==0){//open + + char name_file[256]; + + if(strcmp(pwd,"/")==0 ) + sprintf(name_file,"/%s", list[cursor].filename); + else + sprintf(name_file,"%s/%s", pwd, list[cursor].filename); + + /*filetype + * 1 rom + * 2 mempak + * 3 background + * 4 mp3 + */ + + int ft=0; + char _upper_name_file[256]; + + strcpy(_upper_name_file, name_file); + + strhicase(_upper_name_file, strlen (_upper_name_file)); + sprintf(_upper_name_file, "%s", _upper_name_file ); + + u8 extension[4]; + u8 * pch; + pch=strrchr(_upper_name_file,'.'); //asd.n64 + + + sprintf(extension, "%s",(pch+1)); //0123456 + + + if(!strcmp(extension,"GB" )) + ft=5; + if(!strcmp(extension,"GBC" )) + ft=6; + if(!strcmp(extension,"NES" )) + ft=7; + if(!strcmp(extension,"GG" )) + ft=8; + if(!strcmp(extension,"MSX" )) + ft=9; + if(!strcmp(extension,"MP3" )) + ft=10; + + if(!strcmp(extension,"MPK" )) + ft=2; + if(!strcmp(extension,"Z64") || !strcmp(extension,"V64" ) || !strcmp(extension,"N64" ) ) + ft=1; + + if(ft==1){ //rom + //load rom + + while( !(disp = display_lock()) ); + clearScreen(disp); + u16 msg = 0; + sleep(300); + evd_ulockRegs(); + sleep(300); + sprintf(rom_filename,"%s", list[cursor].filename); + + + if(quick_boot){ + + u8 resp=0; + resp = fatCreateRecIfNotExist("/ED64/LASTROM.CFG", 0); + resp = fatOpenFileByeName("/ED64/LASTROM.CFG", 1); //512 bytes fix one cluster + static uint8_t lastrom_file_data[512] = { 0 }; + scopy(name_file, lastrom_file_data); + + fatWriteFile(&lastrom_file_data, 1); + } + + select_mode=9; + + //read rom_config data + readRomConfig(disp, rom_filename, name_file); + + loadrom(disp,name_file, 1); + display_show(disp); + //display_show(disp); + + //rom loaded mapping + input_mapping=4; + + + }else + if(ft==5 || ft==6){ //gb/gbc rom + //load rom + + while( !(disp = display_lock()) ); + + clearScreen(disp); + u16 msg = 0; + sleep(300); + evd_ulockRegs(); + sleep(300); + sprintf(rom_filename,"%s", list[cursor].filename); + display_show(disp); + + select_mode=9; + + loadgbrom(disp,name_file); + + display_show(disp); + }else + if(ft==2){ //mempak + + + while( !(disp = display_lock()) ); + + + clearScreen(disp); //part clear? + display_dir(list, cursor, page, MAX_LIST, count, disp); + + display_show(disp); + + + + /* + //c-up or A + drawConfirmBox(disp); + //confirm format mpk + input_mapping=6; + * + */ + + drawShortInfoBox(disp, " L=Restore R=Backup", 2); + input_mapping=9; + + sprintf(rom_filename,"%s", name_file); + + + } + else + if(ft==7){ //nes + //load rom + + while( !(disp = display_lock()) ); + clearScreen(disp); + u16 msg = 0; + sleep(300); + evd_ulockRegs(); + sleep(300); + sprintf(rom_filename,"%s", list[cursor].filename); + display_show(disp); + + select_mode=9; + + loadnesrom(disp,name_file); + + display_show(disp); + } + else + if(ft==8){ //gg + //load gg rom + + while( !(disp = display_lock()) ); + clearScreen(disp); + u16 msg = 0; + sleep(300); + evd_ulockRegs(); + sleep(300); + sprintf(rom_filename,"%s", list[cursor].filename); + display_show(disp); + + select_mode=9; + + loadggrom(disp,name_file); + + display_show(disp); + } + else + if(ft==9){ //msx2 + //load msx2 rom + + while( !(disp = display_lock()) ); + clearScreen(disp); + u16 msg = 0; + sleep(300); + evd_ulockRegs(); + sleep(300); + sprintf(rom_filename,"%s", list[cursor].filename); + display_show(disp); + + select_mode=9; + + loadmsx2rom(disp,name_file); + + display_show(disp); + } + else + if(ft==10){ //mp3 + //load mp3 + buf_size = audio_get_buffer_length() * 4; + buf_ptr = malloc(buf_size); + + + while( !(disp = display_lock()) ); + clearScreen(disp); + drawShortInfoBox(disp, " playback",0); + + long long start = 0, end = 0, curr, pause = 0, samples; + int rate = 44100, last_rate = 44100, channels = 2; + + audio_init(44100,2); + + start_mp3(name_file, &samples, &rate, &channels); + playing=1; + select_mode=9; + + input_mapping=11;//mp3 stop + + display_show(disp); + + } + + + + } //mapping and not dir + + + }//mapping 1 end + else + if(input_mapping==2){ + + //open up charinput screen + input_mapping=3; + //inputText(, contr,disp); + input_text[0]='\0'; + graphics_draw_sprite( disp, 0, 0, contr ); + + + } + else + if(input_mapping==3){ + //chr input screen + + // mode = 1 - mode; + if(set==1) + drawInputAdd(disp, "G"); //P X ) + if(set==2) + drawInputAdd(disp, "N"); + if(set==3) + drawInputAdd(disp, "U"); + if(set==4) + drawInputAdd(disp, "_"); + } + else + if(input_mapping==7){ + + //save rom_cfg[] to + // /ED64/CFG/Romname.cfg if not exist create + // if exist open/write + + //print confirm msg + char name_file[256]; + + if(strcmp(pwd,"/")==0 ) + sprintf(name_file,"/%s", list[cursor].filename); + else + sprintf(name_file,"%s/%s", pwd, list[cursor].filename); + + + + u8 rom_cfg_file[128]; + + u8 resp=0; + + //set rom_cfg + sprintf(rom_cfg_file, "/ED64/CFG/%s.CFG",rom_filename ); + + resp = fatCreateRecIfNotExist(rom_cfg_file, 0); + resp = fatOpenFileByeName(rom_cfg_file, 1); //512 bytes fix one cluster + + + static uint8_t cfg_file_data[512] = { 0 }; + cfg_file_data[0]=rom_config[1]; //cic + cfg_file_data[1]=rom_config[2]; //save + cfg_file_data[2]=rom_config[3]; //tv + cfg_file_data[3]=rom_config[4]; //cheat + cfg_file_data[4]=rom_config[5]; //chksum + cfg_file_data[5]=rom_config[6]; //rating + cfg_file_data[6]=rom_config[7]; //country + cfg_file_data[7]=rom_config[8]; + cfg_file_data[8]=rom_config[9]; + + //copy full rom path to offset at 32 byte - 32 bytes reversed + scopy(name_file, cfg_file_data+32); //filename to rom_cfg file + + + + fatWriteFile(&cfg_file_data, 1); + + + sleep(200); + + drawShortInfoBox(disp, " done",0); + toplist_reload=1; + + + input_mapping=98; + + + /* + //back to list mode + while( !(disp = display_lock()) ); + + + clearScreen(disp); //part clear? + display_dir(list, cursor, page, MAX_LIST, count, disp); + + display_show(disp); + + input_mapping=1; + * + * + */ + } + else + if(input_mapping==8){ + //run from toplist + + + + u8 * pch_s; + pch_s=strrchr(toplist15[toplist_cursor-1]+1,'/'); + //drawShortInfoBox(disp,pch_s,0); + + readRomConfig(disp, pch_s+1, toplist15[toplist_cursor-1]+1); + + loadrom(disp,toplist15[toplist_cursor-1]+1, 1); + //display_show(disp); + //display_show(disp); + + //rom loaded mapping + input_mapping=4; + + } + else + if(input_mapping==98){ + //rom info screen + + while( !(disp = display_lock()) ); + + + clearScreen(disp); //part clear? + display_dir(list, cursor, page, MAX_LIST, count, disp); + + display_show(disp); + + input_mapping=1; + } + + + }//key a + + + else if(keys.c[0].B ) //go back + { + + if(input_mapping==1){ + + + if(!(strcmp(pwd,"/")==0)){ + while( !(disp = display_lock()) ); + + //replace by strstr()? :> + int slash_pos=0; + int i = 0; + while(pwd[i] != '\0'){ + if(pwd[i] == '/') + slash_pos=i; + i++; + } + char new_pwd[64]; + + int j; + for(j = 0; j < slash_pos; j++) + new_pwd[j] = pwd[j]; + + if(j==0) j++; + new_pwd[j] = '\0'; + + sprintf(pwd,"%s", new_pwd); + + cursor_lastline=0; + cursor_line=0; + + + + + readSDcard(disp,pwd); + + + if(cd_behaviour==1){ + cursor_history_pos--; + cursor=cursor_history[cursor_history_pos]; + + if(cursor_history[cursor_history_pos]>0){ + + cursor_line=cursor_history[cursor_history_pos]-1; + + if(scroll_behaviour==0){ + + int p = cursor_line/20; + page=p*20; + } + else{ + if(cursor_line>19) + cursor_line=19; + } + } + else + cursor_line=0; + } + + + + + + while( !(disp = display_lock()) ); + + new_scroll_pos(&cursor, &page, MAX_LIST, count); + + clearScreen(disp); //part clear? + display_dir(list, cursor, page, MAX_LIST, count, disp); + + display_show(disp); + + + + + + + + + display_show(disp); + }//not root + + + } + else + if(input_mapping==2){ + while( !(disp = display_lock()) ); + + graphics_set_color(graphics_make_color(0xFF, 0xFF, 0xFF, 0xFF), graphics_make_color(0x00, 0x00, 0x00, 0x00)); + clearScreen(disp); + + display_show(disp); + + display_dir(list, cursor, page, MAX_LIST, count, disp); + input_mapping=1; + display_show(disp); + } + else + if(input_mapping==3){ + //chr input screen + + /* Lazy switching */ + // mode = 1 - mode; + if(set==1) + drawInputAdd(disp, "E"); //P X ) + if(set==2) + drawInputAdd(disp, "L"); + if(set==3) + drawInputAdd(disp, "S"); + if(set==4) + drawInputAdd(disp, "Z"); + + } + else + if(input_mapping==98 || input_mapping==5 || input_mapping==6 || input_mapping==7 || input_mapping==10){ + //rom info screen + + while( !(disp = display_lock()) ); + + clearScreen(disp); //part clear? + display_dir(list, cursor, page, MAX_LIST, count, disp); + + display_show(disp); + + input_mapping=1; + } + else + if(input_mapping==8){ + //leave toplist + + while( !(disp = display_lock()) ); + + + readSDcard(disp,list_pwd_backup); + + if(scroll_behaviour==0){ + cursor=list_pos_backup[0]; + page=list_pos_backup[1]; + } + else{ + cursor_line=0; + } + + clearScreen(disp); //part clear? + display_dir(list, cursor, page, MAX_LIST, count, disp); + + display_show(disp); + + input_mapping=1; + } + else + if(input_mapping==11){ + //stop mp3 + + stop_mp3(); + playing=0; + + clearScreen(disp); //part clear? + display_dir(list, cursor, page, MAX_LIST, count, disp); + + display_show(disp); + + input_mapping=1; + } + + + + + + }//key b + //if(input_mapping==2) + sleep(10); + + } + } + + //never return + while(1); + + return 0; +} + diff --git a/menu.h b/menu.h new file mode 100644 index 0000000..30f70ed --- /dev/null +++ b/menu.h @@ -0,0 +1,108 @@ +//protos maybe some aren't necessary any longer +void strhicase(u8 *str, u8 len); +void PI_DMAWait(void); +void evd_writeReg(u8 reg, u16 val); +void bootRom(display_context_t disp, int silent); +void loadrom(display_context_t disp, u8 *buff, int fast); +void loadgbrom(display_context_t disp, u8 *buff); +void view_mpk_file(display_context_t disp, char *mpk_filename); +char TranslateNotes( char *bNote, char *Text ); +inline char CountBlocks( char *bMemPakBinary, char *aNoteSizes ); +void view_mpk(display_context_t disp); +void evd_ulockRegs(void); +u8 fatReadCluster(void *dst); +u8 fatGetNextCluster(u32 *cluster); +u8 fatSkipCluster(); +void memRomWrite32(u32 addr, u32 val); +u32 memRomRead32(u32 addr); +uint32_t translate_color(char *hexstring); +void evd_init(void); +void memSpiSetDma(u8 mode); +u16 evd_getFirmVersion(void); +u8 evd_isSDMode(void); +void dma_write_s(void * ram_address, unsigned long pi_address, unsigned long len); +void dma_read_s(void * ram_address, unsigned long pi_address, unsigned long len); +void readSDcard(display_context_t disp, char *directory); +int readConfigFile(void); +//void readCheatFile(display_context_t disp); +int readCheatFile(char *filename); +static int configHandler(void* user, const char* section, const char* name, const char* value); +int saveTypeToSd(display_context_t disp, char* save_filename ,int tpye); +int saveTypeFromSd(display_context_t disp, char* rom_name, int stype); +int backupSaveData(display_context_t disp); +void romInfoScreen(display_context_t disp, u8 *buff, int silent); +void checksum_sdram(void); +void drawShortInfoBox(display_context_t disp, char* text, u8 mode); +void drawToplistSelection(display_context_t disp,int l); +//boxes +void drawBox(short x, short y, short width, short height, display_context_t disp); +void drawBoxNumber(display_context_t disp, int box); + +void printText(char *msg, int x, int y, display_context_t dcon); +void lprintText(char *msg, int x, int y, display_context_t dcon); +void sleep(unsigned long int ms); +void clearScreen(display_context_t disp); + +//mp3 +void start_mp3(char *fname, long long *samples, int *rate, int *channels); + +//character input functions +void drawTextInput(display_context_t disp,char *msg); +void drawInputAdd(display_context_t disp, char *msg); +void drawInputDel(display_context_t disp); + +void readRomConfig(display_context_t disp, char* short_filename, char* full_filename); +void alterRomConfig(int type, int mode); +void drawConfigSelection(display_context_t disp,int l); +void drawRomConfigBox(display_context_t disp,int line); + +#define MAX_LIST 20 +#define REG_VER 11 +#define ED_CFG_SDRAM_ON 0 + +#define ishexchar(c) (((c >= '0') && (c <= '9')) || ((c >= 'A') && (c <= 'F')) || ((c >= 'a') && (c <= 'f'))) + + +//debug flag to enable some debug outputs +/////////////////////////////////////////// +#define DBG_MODE 0 +/////////////////////////////////////////// + +/** + * @brief Return the uncached memory address of a cached address + * + * @param[in] x + * The cached address + *uint32_t + * @return The uncached address + */ +#define UNCACHED_ADDR(x) ((void *)(((uint32_t)(x)) | 0xA0000000)) + +/** + * @brief Align a memory address to 16 byte offset + * + * @param[in] x + * Unaligned memory address + * + * @return An aligned address guaranteed to be >= the unaligned address + */ +#define ALIGN_16BYTE(x) ((void *)(((uint32_t)(x)+15) & 0xFFFFFFF0)) + + + + + + + + + + + + + + + + + + + diff --git a/mp3.c b/mp3.c new file mode 100644 index 0000000..f8e86c9 --- /dev/null +++ b/mp3.c @@ -0,0 +1,446 @@ +#include +#include +#include +#include +#include +#include "fat.h" + +#include + +static struct mad_stream Stream; +static struct mad_header Header; +static struct mad_frame Frame; +static struct mad_synth Synth; +static mad_timer_t Timer; + +typedef struct { + short left; + short right; +} Sample; + +static int eos; + +#define INPUT_BUFFER_SIZE 2048 +static unsigned char fileBuffer[INPUT_BUFFER_SIZE]; +static unsigned char readBuffer[INPUT_BUFFER_SIZE]; +static int useReadBuffer; +static int readPos; +static unsigned int readLen; +static int samplesRead; + +char * mp3File; +char * mp3Fd; +long mp3File_fptr=0; +int mp3File_fsize; + +extern int gBrowser; +extern char path[1024]; + +extern void c2wstrcpy(void *dst, void *src); +extern void c2wstrcat(void *dst, void *src); + + +static int mp3_seek(char* fd, int offset, int whence) +{ + +//todo filesize and mp3File_fptr; + + + long offs = 0; + // libff routine + switch (whence) + { + case SEEK_SET: + offs = offset; + break; + case SEEK_CUR: + offs = mp3File_fptr + offset; + break; + case SEEK_END: + offs = mp3File_fsize + offset; + break; + } + //f_lseek(&mp3File, offs); + mp3File_fptr=offs; + + return offs; + +} + +static int mp3_size(char* fd) +{ + FatRecord rec_tmpf; + u8 resp=0; + resp = fatOpenFileByeName(fd, 0); //err if not found ^^ + + int fsize = file.sec_available*512; //fsize in bytes + mp3File_fsize = fsize; + //todo filesize + return mp3File_fsize; + +} + +static void _f_read(char* fname, unsigned char *readBuffer, int size){ + + +/* + FatRecord rec_tmpf; + u8 resp=0; + resp = fatOpenFileByeName(fname, 0); //err if not found ^^ + + int fsize = file.sec_available*512; //fsize in bytes + mp3File_fsize = fsize; + + + + //injecting in buffer... slow but working :/ + if(file.sec_available*512>=size){ + resp = fatReadPartialFile(readBuffer, size/512, mp3File_fptr); + //resp = fatReadFile(readBuffer+mp3File_fptr, size/512);//file.sec_available); + mp3File_fptr+=size; + + } + //dma_write_s(buffer, 0xb0000000, fsize); + + +*/ + +} + +static int mp3_read(char* fd, unsigned char *ptr, int size) +{ + int ts=size; + _f_read(fd, ptr, size); + return ts; + +} + +static int id3_tag_size(unsigned char const *buf, int remaining) +{ + int size; + + if (remaining < 10) + return 0; + + if (!strncmp((char*)buf, "ID3", 3) || !strncmp((char*)buf, "ea3", 3)) //skip past id3v2 header, which can cause a false sync to be found + { + //get the real size from the syncsafe int + size = buf[6]; + size = (size<<7) | buf[7]; + size = (size<<7) | buf[8]; + size = (size<<7) | buf[9]; + + size += 10; + + if (buf[5] & 0x10) //has footer + size += 10; + } + return size; +} + +//Seek next valid frame after ID3/EA3 header +//NOTE: adapted from Music prx 0.55 source +// credit goes to joek2100. +static int MP3_SkipHdr(char* fd) +{ + int offset = 0; + unsigned char buf[1024]; + unsigned char *pBuffer; + int i; + int size = 0; + + offset = mp3_seek(fd, 0, SEEK_CUR); + mp3_read(fd, buf, sizeof(buf)); + if (!strncmp((char*)buf, "ID3", 3) || !strncmp((char*)buf, "ea3", 3)) //skip past id3v2 header, which can cause a false sync to be found + { + //get the real size from the syncsafe int + size = buf[6]; + size = (size<<7) | buf[7]; + size = (size<<7) | buf[8]; + size = (size<<7) | buf[9]; + + size += 10; + + if (buf[5] & 0x10) //has footer + size += 10; + + offset += size; + } + mp3_seek(fd, offset, SEEK_SET); + + //now seek for a sync + while(1) + { + offset = mp3_seek(fd, 0, SEEK_CUR); + size = mp3_read(fd, buf, sizeof(buf)); + + if (size <= 2)//at end of file + return -1; + + if (!strncmp((char*)buf, "EA3", 3)) //oma mp3 files have non-safe ints in the EA3 header + { + mp3_seek(fd, (buf[4]<<8)+buf[5], SEEK_CUR); + continue; + } + + pBuffer = buf; + for( i = 0; i < size; i++) + { + //if this is a valid frame sync (0xe0 is for mpeg version 2.5,2+1) + if ( (pBuffer[i] == 0xff) && ((pBuffer[i+1] & 0xE0) == 0xE0) ) + { + offset += i; + mp3_seek(fd, offset, SEEK_SET); + return offset; + } + } + //go back two bytes to catch any syncs that on the boundary + mp3_seek(fd, -2, SEEK_CUR); + } +} + +static short convertSample(mad_fixed_t Fixed) +{ + /* Clipping */ + if (Fixed >= MAD_F_ONE) + return (32767); + if (Fixed <= -MAD_F_ONE) + return (-32768); + + /* Conversion. */ + Fixed = Fixed >> (MAD_F_FRACBITS - 15); + return ((short)Fixed); +} + +static int fillFileBuffer() +{ + int leftOver = Stream.bufend - Stream.next_frame; + int want = INPUT_BUFFER_SIZE - leftOver; + + // move left-over bytes + if (leftOver > 0) + memmove(fileBuffer, fileBuffer + want, leftOver); + + // fill remainder of buffer + unsigned char* bufferPos = fileBuffer + leftOver; + while (want > 0) + { + int got = mp3_read(mp3Fd, bufferPos, want); + if (got <= 0) + return 1; // EOF + + want -= got; + bufferPos += got; + } + return 0; +} + +static void decode() +{ + while (mad_frame_decode(&Frame, &Stream) == -1) + { + if ((Stream.error == MAD_ERROR_BUFLEN) || (Stream.error == MAD_ERROR_BUFPTR)) + { + if (fillFileBuffer()) + { + eos = 1; + break; + } + mad_stream_buffer(&Stream, fileBuffer, INPUT_BUFFER_SIZE); + } + else if (Stream.error == MAD_ERROR_LOSTSYNC) + { + /* LOSTSYNC - due to ID3 tags? */ + int tagsize = id3_tag_size(Stream.this_frame, Stream.bufend - Stream.this_frame); + if (tagsize > 0) + { + mad_stream_skip (&Stream, tagsize); + continue; + } + } + } + + mad_timer_add(&Timer, Frame.header.duration); + mad_synth_frame(&Synth, &Frame); +} + +static void convertLeftSamples(Sample* first, Sample* last, const mad_fixed_t* src) +{ + for (Sample *dst = first; dst != last; ++dst) + dst->left = convertSample(*src++); +} + +static void convertRightSamples(Sample* first, Sample* last, const mad_fixed_t* src) +{ + for (Sample *dst = first; dst != last; ++dst) + dst->right = convertSample(*src++); +} + +static void MP3_Callback(void *buffer, unsigned int samplesToWrite) +{ + Sample *destination = (Sample*)buffer; + + while (samplesToWrite > 0) + { + while (!eos && (Synth.pcm.length == 0)) + decode(); + + if (eos) + { + // done + memset(destination, 0, samplesToWrite*4); + break; + } + + unsigned int samplesAvailable = Synth.pcm.length - samplesRead; + if (samplesAvailable > samplesToWrite) + { + convertLeftSamples(destination, destination + samplesToWrite, &Synth.pcm.samples[0][samplesRead]); + convertRightSamples(destination, destination + samplesToWrite, &Synth.pcm.samples[1][samplesRead]); + + samplesRead += samplesToWrite; + samplesToWrite = 0; + } + else + { + convertLeftSamples(destination, destination + samplesAvailable, &Synth.pcm.samples[0][samplesRead]); + convertRightSamples(destination, destination + samplesAvailable, &Synth.pcm.samples[1][samplesRead]); + + destination += samplesAvailable; + samplesToWrite -= samplesAvailable; + + samplesRead = 0; + decode(); + } + } +} + +static void MP3_Init() +{ + /* First the structures used by libmad must be initialized. */ + mad_stream_init(&Stream); + mad_header_init(&Header); + mad_frame_init(&Frame); + mad_synth_init(&Synth); + mad_timer_reset(&Timer); +} + +static void MP3_Exit() +{ + mad_synth_finish(&Synth); + mad_header_finish(&Header); + mad_frame_finish(&Frame); + mad_stream_finish(&Stream); +} + +static void MP3_GetInfo(long long *samples, int *rate) +{ + unsigned long FrameCount = 0; + int bufferSize = 1024*512; + unsigned char *localBuffer; + long red = 0; + double totalBitrate = 0.0; + double mediumBitrate = 0.0; + struct mad_stream stream; + struct mad_header header; + int size = mp3_size(mp3Fd); + long count = size; + + mad_stream_init (&stream); + mad_header_init (&header); + + localBuffer = (unsigned char *)malloc(bufferSize); + + for (int i=0; i<3; i++) + { + memset(localBuffer, 0, bufferSize); + + if (count > bufferSize) + red = mp3_read(mp3Fd, localBuffer, bufferSize); + else + red = mp3_read(mp3Fd, localBuffer, count); + count -= red; + if (!red) + break; // ran out of data + + mad_stream_buffer (&stream, localBuffer, red); + + while (1) + { + if (mad_header_decode(&header, &stream) == -1) + { + if (stream.buffer == NULL || stream.error == MAD_ERROR_BUFLEN) + break; + else if (MAD_RECOVERABLE(stream.error)) + { + continue; + } + else + { + break; + } + } + if (FrameCount++ == 0) + *rate = header.samplerate; + totalBitrate += header.bitrate; + } + } + + mediumBitrate = totalBitrate / (double)FrameCount; + int secs = size * 8 / mediumBitrate; + *samples = *rate * secs; + + mad_header_finish (&header); + mad_stream_finish (&stream); + + if (localBuffer) + free(localBuffer); + + mp3_seek(mp3Fd, 0, SEEK_SET); +} + + +void start_mp3(char *fname, long long *samples, int *rate, int *channels) +{ + + sprintf(mp3Fd, "%s", fname); + + + //if (mp3Fd[0]!=0) + //{ + useReadBuffer = 0; + MP3_GetInfo(samples, rate); + *channels = 2; + + MP3_Init(); + MP3_SkipHdr(mp3Fd); + eos = readLen = readPos = 0; + useReadBuffer = 1; + return; + //} + + //*samples = 0; + //return; +} + +void stop_mp3(void) +{ + MP3_Exit(); + mp3File_fptr=0; +/* + if (mp3Fd > 0) + { + if (gBrowser) + f_close(&mp3File); + else + dfs_close(mp3Fd); + } + mp3Fd = -1; + */ +} + +int update_mp3(char *buf, int bytes) +{ + MP3_Callback(buf, bytes/4); + return eos ? 0 : 1; +} diff --git a/sram.c b/sram.c new file mode 100644 index 0000000..eaee972 --- /dev/null +++ b/sram.c @@ -0,0 +1,127 @@ +#include +#include +#include +#include "sys.h" +#include "types.h" +#include "utils.h" +#include "sram.h" + + +void PI_Init(void) { + PI_DMAWait(); + IO_WRITE(PI_STATUS_REG, 0x03); +} + +// Inits PI for sram transfer +void PI_Init_SRAM(void) { + + + IO_WRITE(PI_BSD_DOM2_LAT_REG, 0x05); + IO_WRITE(PI_BSD_DOM2_PWD_REG, 0x0C); + IO_WRITE(PI_BSD_DOM2_PGS_REG, 0x0D); + IO_WRITE(PI_BSD_DOM2_RLS_REG, 0x02); + +} + +void PI_DMAWait(void) { + + + /*PI DMA wait + + 1. Read PI_STATUS_REG then AND it with 0x3, if its true... then wait until + it is not true. + */ + + while (IO_READ(PI_STATUS_REG) & (PI_STATUS_IO_BUSY | PI_STATUS_DMA_BUSY)); +} + + +void PI_DMAFromSRAM(void *dest, u32 offset, u32 size) { + + + IO_WRITE(PI_DRAM_ADDR_REG, K1_TO_PHYS(dest)); + IO_WRITE(PI_CART_ADDR_REG, (0xA8000000 + offset)); + asm volatile ("" : : : "memory"); + IO_WRITE(PI_WR_LEN_REG, (size - 1)); + asm volatile ("" : : : "memory"); + + + /* + PI_DMAWait(); + + IO_WRITE(PI_STATUS_REG, 0x03); + IO_WRITE(PI_DRAM_ADDR_REG, K1_TO_PHYS(dest)); + IO_WRITE(PI_CART_ADDR_REG, (0xA8000000 + offset)); + _data_cache_invalidate_all(); + IO_WRITE(PI_WR_LEN_REG, (size - 1)); +*/ +} + + +void PI_DMAToSRAM(void *src, u32 offset, u32 size) { //void* + PI_DMAWait(); + + IO_WRITE(PI_STATUS_REG, 2); + IO_WRITE(PI_DRAM_ADDR_REG, K1_TO_PHYS(src)); + IO_WRITE(PI_CART_ADDR_REG, (0xA8000000 + offset)); + _data_cache_invalidate_all(); + //data_cache_hit_writeback_invalidate(src,size); + + /* Write back . nusys - only writeback + osWritebackDCache((void*)buf_ptr, (s32)size); + */ + //libdragon equivalent + // data_cache_hit_writeback (src, size); + + IO_WRITE(PI_RD_LEN_REG, (size - 1)); +} + +void PI_DMAFromCart(void* dest, void* src, u32 size) { + PI_DMAWait(); + + IO_WRITE(PI_STATUS_REG, 0x03); + IO_WRITE(PI_DRAM_ADDR_REG, K1_TO_PHYS(dest)); + IO_WRITE(PI_CART_ADDR_REG, K0_TO_PHYS(src)); + //_data_cache_invalidate_all(); + IO_WRITE(PI_WR_LEN_REG, (size - 1)); +} + + +void PI_DMAToCart(void* dest, void* src, u32 size) { + PI_DMAWait(); + + IO_WRITE(PI_STATUS_REG, 0x02); + IO_WRITE(PI_DRAM_ADDR_REG, K1_TO_PHYS(src)); + IO_WRITE(PI_CART_ADDR_REG, K0_TO_PHYS(dest)); + //_data_cache_invalidate_all(); + IO_WRITE(PI_RD_LEN_REG, (size - 1)); +} + + +// Wrapper to support unaligned access to memory +void PI_SafeDMAFromCart(void *dest, void *src, u32 size) { + if (!dest || !src || !size) return; + + u32 unalignedSrc = ((u32)src) % 2; + u32 unalignedDest = ((u32)dest) % 8; + + //FIXME: Do i really need to check if size is 16bit aligned? + if (!unalignedDest && !unalignedSrc && !(size % 2)) { + PI_DMAFromCart(dest, src, size); + PI_DMAWait(); + + return; + } + + void* newSrc = (void*)(((u32)src) - unalignedSrc); + u32 newSize = (size + unalignedSrc) + ((size + unalignedSrc) % 2); + + u8 *buffer = memalign(8, newSize); + PI_DMAFromCart(buffer, newSrc, newSize); + PI_DMAWait(); + + memcpy(dest, (buffer + unalignedSrc), size); + + free(buffer); +} + diff --git a/sram.h b/sram.h new file mode 100644 index 0000000..913a238 --- /dev/null +++ b/sram.h @@ -0,0 +1,32 @@ +//sram.h +#include +#include +#include "types.h" + +void data_cache_hit_writeback_invalidate(volatile void *, unsigned long); +unsigned int CRC_Calculate(unsigned int crc, unsigned char* buf, unsigned int len); +void dma_write_sram(void* src, u32 offset, u32 size); +void dma_read_sram(void *dest, u32 offset, u32 size); +void dma_write_s(void * ram_address, unsigned long pi_address, unsigned long len); +void dma_read_s(void * ram_address, unsigned long pi_address, unsigned long len); +int writeSram(void* src, u32 size); +void setSDTiming(void); + + +void PI_Init(void); +void PI_Init_SRAM(void); +void PI_DMAWait(void); +void PI_DMAFromCart(void* dest, void* src, u32 size); +void PI_DMAToCart(void* dest, void* src, u32 size); +void PI_DMAFromSRAM(void *dest, u32 offset, u32 size); +void PI_DMAToSRAM(void* src, u32 offset, u32 size); +void PI_SafeDMAFromCart(void *dest, void *src, u32 size); + +//memory +/*** MEMORY ***/ +void *safe_memalign(size_t boundary, size_t size); +void *safe_calloc(size_t nmemb, size_t size); +void *safe_malloc(size_t size); +void safe_free(void *ptr); +void *safe_memset(void *s, int c, size_t n); +void *safe_memcpy(void *dest, const void *src, size_t n); diff --git a/stb_image.c b/stb_image.c new file mode 100644 index 0000000..918dd80 --- /dev/null +++ b/stb_image.c @@ -0,0 +1,4940 @@ +/* stbi-1.28 - public domain JPEG/PNG reader - http://nothings.org/stb_image.c + when you control the images you're loading + no warranty implied; use at your own risk + + QUICK NOTES: + Primarily of interest to game developers and other people who can + avoid problematic images and only need the trivial interface + + JPEG baseline (no JPEG progressive) + PNG 8-bit only + + TGA (not sure what subset, if a subset) + BMP non-1bpp, non-RLE + PSD (composited view only, no extra channels) + + GIF (*comp always reports as 4-channel) + HDR (radiance rgbE format) + PIC (Softimage PIC) + + - decoded from memory or through stdio FILE (define STBI_NO_STDIO to remove code) + - supports installable dequantizing-IDCT, YCbCr-to-RGB conversion (define STBI_SIMD) + + Latest revisions: + 1.28 (2010-08-01) fix bug in GIF palette transparency (SpartanJ) + 1.27 (2010-08-01) cast-to-uint8 to fix warnings (Laurent Gomila) + allow trailing 0s at end of image data (Laurent Gomila) + 1.26 (2010-07-24) fix bug in file buffering for PNG reported by SpartanJ + 1.25 (2010-07-17) refix trans_data warning (Won Chun) + 1.24 (2010-07-12) perf improvements reading from files + minor perf improvements for jpeg + deprecated type-specific functions in hope of feedback + attempt to fix trans_data warning (Won Chun) + 1.23 fixed bug in iPhone support + 1.22 (2010-07-10) removed image *writing* support to stb_image_write.h + stbi_info support from Jetro Lauha + GIF support from Jean-Marc Lienher + iPhone PNG-extensions from James Brown + warning-fixes from Nicolas Schulz and Janez Zemva + 1.21 fix use of 'uint8' in header (reported by jon blow) + 1.20 added support for Softimage PIC, by Tom Seddon + + See end of file for full revision history. + + TODO: + stbi_info support for BMP,PSD,HDR,PIC + rewrite stbi_info and load_file variations to share file handling code + (current system allows individual functions to be called directly, + since each does all the work, but I doubt anyone uses this in practice) + + + ============================ Contributors ========================= + + Image formats Optimizations & bugfixes + Sean Barrett (jpeg, png, bmp) Fabian "ryg" Giesen + Nicolas Schulz (hdr, psd) + Jonathan Dummer (tga) Bug fixes & warning fixes + Jean-Marc Lienher (gif) Marc LeBlanc + Tom Seddon (pic) Christpher Lloyd + Thatcher Ulrich (psd) Dave Moore + Won Chun + the Horde3D community + Extensions, features Janez Zemva + Jetro Lauha (stbi_info) Jonathan Blow + James "moose2000" Brown (iPhone PNG) Laurent Gomila + + If your name should be here but isn't, let Sean know. + +*/ + +#ifndef STBI_INCLUDE_STB_IMAGE_H +#define STBI_INCLUDE_STB_IMAGE_H + +// To get a header file for this, either cut and paste the header, +// or create stb_image.h, #define STBI_HEADER_FILE_ONLY, and +// then include stb_image.c from it. + +//// begin header file //////////////////////////////////////////////////// +// +// Limitations: +// - no jpeg progressive support +// - non-HDR formats support 8-bit samples only (jpeg, png) +// - no delayed line count (jpeg) -- IJG doesn't support either +// - no 1-bit BMP +// - GIF always returns *comp=4 +// +// Basic usage (see HDR discussion below): +// int x,y,n; +// unsigned char *data = stbi_load(filename, &x, &y, &n, 0); +// // ... process data if not NULL ... +// // ... x = width, y = height, n = # 8-bit components per pixel ... +// // ... replace '0' with '1'..'4' to force that many components per pixel +// stbi_image_free(data) +// +// Standard parameters: +// int *x -- outputs image width in pixels +// int *y -- outputs image height in pixels +// int *comp -- outputs # of image components in image file +// int req_comp -- if non-zero, # of image components requested in result +// +// The return value from an image loader is an 'unsigned char *' which points +// to the pixel data. The pixel data consists of *y scanlines of *x pixels, +// with each pixel consisting of N interleaved 8-bit components; the first +// pixel pointed to is top-left-most in the image. There is no padding between +// image scanlines or between pixels, regardless of format. The number of +// components N is 'req_comp' if req_comp is non-zero, or *comp otherwise. +// If req_comp is non-zero, *comp has the number of components that _would_ +// have been output otherwise. E.g. if you set req_comp to 4, you will always +// get RGBA output, but you can check *comp to easily see if it's opaque. +// +// An output image with N components has the following components interleaved +// in this order in each pixel: +// +// N=#comp components +// 1 grey +// 2 grey, alpha +// 3 red, green, blue +// 4 red, green, blue, alpha +// +// If image loading fails for any reason, the return value will be NULL, +// and *x, *y, *comp will be unchanged. The function stbi_failure_reason() +// can be queried for an extremely brief, end-user unfriendly explanation +// of why the load failed. Define STBI_NO_FAILURE_STRINGS to avoid +// compiling these strings at all, and STBI_FAILURE_USERMSG to get slightly +// more user-friendly ones. +// +// Paletted PNG, BMP, GIF, and PIC images are automatically depalettized. +// +// =========================================================================== +// +// iPhone PNG support: +// +// By default we convert iphone-formatted PNGs back to RGB; nominally they +// would silently load as BGR, except the existing code should have just +// failed on such iPhone PNGs. But you can disable this conversion by +// by calling stbi_convert_iphone_png_to_rgb(0), in which case +// you will always just get the native iphone "format" through. +// +// Call stbi_set_unpremultiply_on_load(1) as well to force a divide per +// pixel to remove any premultiplied alpha *only* if the image file explicitly +// says there's premultiplied data (currently only happens in iPhone images, +// and only if iPhone convert-to-rgb processing is on). +// +// =========================================================================== +// +// HDR image support (disable by defining STBI_NO_HDR) +// +// stb_image now supports loading HDR images in general, and currently +// the Radiance .HDR file format, although the support is provided +// generically. You can still load any file through the existing interface; +// if you attempt to load an HDR file, it will be automatically remapped to +// LDR, assuming gamma 2.2 and an arbitrary scale factor defaulting to 1; +// both of these constants can be reconfigured through this interface: +// +// stbi_hdr_to_ldr_gamma(2.2f); +// stbi_hdr_to_ldr_scale(1.0f); +// +// (note, do not use _inverse_ constants; stbi_image will invert them +// appropriately). +// +// Additionally, there is a new, parallel interface for loading files as +// (linear) floats to preserve the full dynamic range: +// +// float *data = stbi_loadf(filename, &x, &y, &n, 0); +// +// If you load LDR images through this interface, those images will +// be promoted to floating point values, run through the inverse of +// constants corresponding to the above: +// +// stbi_ldr_to_hdr_scale(1.0f); +// stbi_ldr_to_hdr_gamma(2.2f); +// +// Finally, given a filename (or an open file or memory block--see header +// file for details) containing image data, you can query for the "most +// appropriate" interface to use (that is, whether the image is HDR or +// not), using: +// +// stbi_is_hdr(char *filename); + +#ifndef STBI_NO_STDIO +#include +#endif + +#define STBI_VERSION 1 + +enum +{ + STBI_default = 0, // only used for req_comp + + STBI_grey = 1, + STBI_grey_alpha = 2, + STBI_rgb = 3, + STBI_rgb_alpha = 4, +}; + +typedef unsigned char stbi_uc; + +#ifdef __cplusplus +extern "C" { +#endif + +// PRIMARY API - works on images of any type + +// load image by filename, open file, or memory buffer +extern stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp); + +#ifndef STBI_NO_STDIO +extern stbi_uc *stbi_load (char const *filename, int *x, int *y, int *comp, int req_comp); +extern stbi_uc *stbi_load_from_file (FILE *f, int *x, int *y, int *comp, int req_comp); +// for stbi_load_from_file, file pointer is left pointing immediately after image +#endif + +#ifndef STBI_NO_HDR + extern float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp); + + #ifndef STBI_NO_STDIO + extern float *stbi_loadf (char const *filename, int *x, int *y, int *comp, int req_comp); + extern float *stbi_loadf_from_file (FILE *f, int *x, int *y, int *comp, int req_comp); + #endif + + extern void stbi_hdr_to_ldr_gamma(float gamma); + extern void stbi_hdr_to_ldr_scale(float scale); + + extern void stbi_ldr_to_hdr_gamma(float gamma); + extern void stbi_ldr_to_hdr_scale(float scale); +#endif // STBI_NO_HDR + +// get a VERY brief reason for failure +// NOT THREADSAFE +extern const char *stbi_failure_reason (void); + +// free the loaded image -- this is just free() +extern void stbi_image_free (void *retval_from_stbi_load); + +// get image dimensions & components without fully decoding +extern int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp); +extern int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len); + +#ifndef STBI_NO_STDIO +extern int stbi_info (char const *filename, int *x, int *y, int *comp); +extern int stbi_info_from_file (FILE *f, int *x, int *y, int *comp); + +extern int stbi_is_hdr (char const *filename); +extern int stbi_is_hdr_from_file(FILE *f); +#endif + +// for image formats that explicitly notate that they have premultiplied alpha, +// we just return the colors as stored in the file. set this flag to force +// unpremultiplication. results are undefined if the unpremultiply overflow. +extern void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply); + +// indicate whether we should process iphone images back to canonical format, +// or just pass them through "as-is" +extern void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert); + + +// ZLIB client - used by PNG, available for other purposes + +extern char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen); +extern char *stbi_zlib_decode_malloc(const char *buffer, int len, int *outlen); +extern int stbi_zlib_decode_buffer(char *obuffer, int olen, const char *ibuffer, int ilen); + +extern char *stbi_zlib_decode_noheader_malloc(const char *buffer, int len, int *outlen); +extern int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen); + +// define new loaders +typedef struct +{ + int (*test_memory)(stbi_uc const *buffer, int len); + stbi_uc * (*load_from_memory)(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp); + #ifndef STBI_NO_STDIO + int (*test_file)(FILE *f); + stbi_uc * (*load_from_file)(FILE *f, int *x, int *y, int *comp, int req_comp); + #endif +} stbi_loader; + +// register a loader by filling out the above structure (you must define ALL functions) +// returns 1 if added or already added, 0 if not added (too many loaders) +// NOT THREADSAFE +extern int stbi_register_loader(stbi_loader *loader); + +// define faster low-level operations (typically SIMD support) +#if STBI_SIMD +typedef void (*stbi_idct_8x8)(stbi_uc *out, int out_stride, short data[64], unsigned short *dequantize); +// compute an integer IDCT on "input" +// input[x] = data[x] * dequantize[x] +// write results to 'out': 64 samples, each run of 8 spaced by 'out_stride' +// CLAMP results to 0..255 +typedef void (*stbi_YCbCr_to_RGB_run)(stbi_uc *output, stbi_uc const *y, stbi_uc const *cb, stbi_uc const *cr, int count, int step); +// compute a conversion from YCbCr to RGB +// 'count' pixels +// write pixels to 'output'; each pixel is 'step' bytes (either 3 or 4; if 4, write '255' as 4th), order R,G,B +// y: Y input channel +// cb: Cb input channel; scale/biased to be 0..255 +// cr: Cr input channel; scale/biased to be 0..255 + +extern void stbi_install_idct(stbi_idct_8x8 func); +extern void stbi_install_YCbCr_to_RGB(stbi_YCbCr_to_RGB_run func); +#endif // STBI_SIMD + + + + +// TYPE-SPECIFIC ACCESS + +#ifdef STBI_TYPE_SPECIFIC_FUNCTIONS + +// is it a jpeg? +extern int stbi_jpeg_test_memory (stbi_uc const *buffer, int len); +extern stbi_uc *stbi_jpeg_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp); +extern int stbi_jpeg_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp); + +#ifndef STBI_NO_STDIO +extern stbi_uc *stbi_jpeg_load (char const *filename, int *x, int *y, int *comp, int req_comp); +extern int stbi_jpeg_test_file (FILE *f); +extern stbi_uc *stbi_jpeg_load_from_file (FILE *f, int *x, int *y, int *comp, int req_comp); + +extern int stbi_jpeg_info (char const *filename, int *x, int *y, int *comp); +extern int stbi_jpeg_info_from_file (FILE *f, int *x, int *y, int *comp); +#endif + +// is it a png? +extern int stbi_png_test_memory (stbi_uc const *buffer, int len); +extern stbi_uc *stbi_png_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp); +extern int stbi_png_info_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp); + +#ifndef STBI_NO_STDIO +extern stbi_uc *stbi_png_load (char const *filename, int *x, int *y, int *comp, int req_comp); +extern int stbi_png_info (char const *filename, int *x, int *y, int *comp); +extern int stbi_png_test_file (FILE *f); +extern stbi_uc *stbi_png_load_from_file (FILE *f, int *x, int *y, int *comp, int req_comp); +extern int stbi_png_info_from_file (FILE *f, int *x, int *y, int *comp); +#endif + +// is it a bmp? +extern int stbi_bmp_test_memory (stbi_uc const *buffer, int len); + +extern stbi_uc *stbi_bmp_load (char const *filename, int *x, int *y, int *comp, int req_comp); +extern stbi_uc *stbi_bmp_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp); +#ifndef STBI_NO_STDIO +extern int stbi_bmp_test_file (FILE *f); +extern stbi_uc *stbi_bmp_load_from_file (FILE *f, int *x, int *y, int *comp, int req_comp); +#endif + +// is it a tga? +extern int stbi_tga_test_memory (stbi_uc const *buffer, int len); + +extern stbi_uc *stbi_tga_load (char const *filename, int *x, int *y, int *comp, int req_comp); +extern stbi_uc *stbi_tga_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp); +#ifndef STBI_NO_STDIO +extern int stbi_tga_test_file (FILE *f); +extern stbi_uc *stbi_tga_load_from_file (FILE *f, int *x, int *y, int *comp, int req_comp); +#endif + +// is it a psd? +extern int stbi_psd_test_memory (stbi_uc const *buffer, int len); + +extern stbi_uc *stbi_psd_load (char const *filename, int *x, int *y, int *comp, int req_comp); +extern stbi_uc *stbi_psd_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp); +#ifndef STBI_NO_STDIO +extern int stbi_psd_test_file (FILE *f); +extern stbi_uc *stbi_psd_load_from_file (FILE *f, int *x, int *y, int *comp, int req_comp); +#endif + +// is it an hdr? +extern int stbi_hdr_test_memory (stbi_uc const *buffer, int len); + +extern float * stbi_hdr_load (char const *filename, int *x, int *y, int *comp, int req_comp); +extern float * stbi_hdr_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp); +#ifndef STBI_NO_STDIO +extern int stbi_hdr_test_file (FILE *f); +extern float * stbi_hdr_load_from_file (FILE *f, int *x, int *y, int *comp, int req_comp); +#endif + +// is it a pic? +extern int stbi_pic_test_memory (stbi_uc const *buffer, int len); + +extern stbi_uc *stbi_pic_load (char const *filename, int *x, int *y, int *comp, int req_comp); +extern stbi_uc *stbi_pic_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp); +#ifndef STBI_NO_STDIO +extern int stbi_pic_test_file (FILE *f); +extern stbi_uc *stbi_pic_load_from_file (FILE *f, int *x, int *y, int *comp, int req_comp); +#endif + +// is it a gif? +extern int stbi_gif_test_memory (stbi_uc const *buffer, int len); + +extern stbi_uc *stbi_gif_load (char const *filename, int *x, int *y, int *comp, int req_comp); +extern stbi_uc *stbi_gif_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp); +extern int stbi_gif_info_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp); + +#ifndef STBI_NO_STDIO +extern int stbi_gif_test_file (FILE *f); +extern stbi_uc *stbi_gif_load_from_file (FILE *f, int *x, int *y, int *comp, int req_comp); +extern int stbi_gif_info (char const *filename, int *x, int *y, int *comp); +extern int stbi_gif_info_from_file (FILE *f, int *x, int *y, int *comp); +#endif + +#endif//STBI_TYPE_SPECIFIC_FUNCTIONS + + + + +#ifdef __cplusplus +} +#endif + +// +// +//// end header file ///////////////////////////////////////////////////// +#endif // STBI_INCLUDE_STB_IMAGE_H + +#ifndef STBI_HEADER_FILE_ONLY + +#ifndef STBI_NO_HDR +#include // ldexp +#include // strcmp +#endif + +#ifndef STBI_NO_STDIO +#include +#endif +#include +#include +#include +//#include +#include +#include + +#ifndef _MSC_VER + #ifdef __cplusplus + #define __forceinline inline + #else + #define __forceinline + #endif +#endif + + +// implementation: +typedef unsigned char uint8; +typedef unsigned short uint16; +typedef signed short int16; +typedef unsigned int uint32; +typedef signed int int32; +typedef unsigned int uint; + +// should produce compiler error if size is wrong +typedef unsigned char validate_uint32[sizeof(uint32)==4 ? 1 : -1]; + +#if defined(STBI_NO_STDIO) && !defined(STBI_NO_WRITE) +#define STBI_NO_WRITE +#endif + +#define STBI_NOTUSED(v) v=v + +#ifdef _MSC_VER +#define STBI_HAS_LRTOL +#endif + +#ifdef STBI_HAS_LRTOL + #define stbi_lrot(x,y) _lrotl(x,y) +#else + #define stbi_lrot(x,y) (((x) << (y)) | ((x) >> (32 - (y)))) +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// Generic API that works on all image types +// + +// deprecated functions + +// is it a jpeg? +extern int stbi_jpeg_test_memory (stbi_uc const *buffer, int len); +extern stbi_uc *stbi_jpeg_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp); +extern int stbi_jpeg_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp); + +#ifndef STBI_NO_STDIO +extern stbi_uc *stbi_jpeg_load (char const *filename, int *x, int *y, int *comp, int req_comp); +extern int stbi_jpeg_test_file (FILE *f); +extern stbi_uc *stbi_jpeg_load_from_file (FILE *f, int *x, int *y, int *comp, int req_comp); + +extern int stbi_jpeg_info (char const *filename, int *x, int *y, int *comp); +extern int stbi_jpeg_info_from_file (FILE *f, int *x, int *y, int *comp); +#endif + +// is it a png? +extern int stbi_png_test_memory (stbi_uc const *buffer, int len); +extern stbi_uc *stbi_png_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp); +extern int stbi_png_info_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp); + +#ifndef STBI_NO_STDIO +extern stbi_uc *stbi_png_load (char const *filename, int *x, int *y, int *comp, int req_comp); +extern int stbi_png_info (char const *filename, int *x, int *y, int *comp); +extern int stbi_png_test_file (FILE *f); +extern stbi_uc *stbi_png_load_from_file (FILE *f, int *x, int *y, int *comp, int req_comp); +extern int stbi_png_info_from_file (FILE *f, int *x, int *y, int *comp); +#endif + +// is it a bmp? +extern int stbi_bmp_test_memory (stbi_uc const *buffer, int len); + +extern stbi_uc *stbi_bmp_load (char const *filename, int *x, int *y, int *comp, int req_comp); +extern stbi_uc *stbi_bmp_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp); +#ifndef STBI_NO_STDIO +extern int stbi_bmp_test_file (FILE *f); +extern stbi_uc *stbi_bmp_load_from_file (FILE *f, int *x, int *y, int *comp, int req_comp); +#endif + +// is it a tga? +extern int stbi_tga_test_memory (stbi_uc const *buffer, int len); + +extern stbi_uc *stbi_tga_load (char const *filename, int *x, int *y, int *comp, int req_comp); +extern stbi_uc *stbi_tga_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp); +#ifndef STBI_NO_STDIO +extern int stbi_tga_test_file (FILE *f); +extern stbi_uc *stbi_tga_load_from_file (FILE *f, int *x, int *y, int *comp, int req_comp); +#endif + +// is it a psd? +extern int stbi_psd_test_memory (stbi_uc const *buffer, int len); + +extern stbi_uc *stbi_psd_load (char const *filename, int *x, int *y, int *comp, int req_comp); +extern stbi_uc *stbi_psd_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp); +#ifndef STBI_NO_STDIO +extern int stbi_psd_test_file (FILE *f); +extern stbi_uc *stbi_psd_load_from_file (FILE *f, int *x, int *y, int *comp, int req_comp); +#endif + +// is it an hdr? +extern int stbi_hdr_test_memory (stbi_uc const *buffer, int len); + +extern float * stbi_hdr_load (char const *filename, int *x, int *y, int *comp, int req_comp); +extern float * stbi_hdr_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp); +#ifndef STBI_NO_STDIO +extern int stbi_hdr_test_file (FILE *f); +extern float * stbi_hdr_load_from_file (FILE *f, int *x, int *y, int *comp, int req_comp); +#endif + +// is it a pic? +extern int stbi_pic_test_memory (stbi_uc const *buffer, int len); + +extern stbi_uc *stbi_pic_load (char const *filename, int *x, int *y, int *comp, int req_comp); +extern stbi_uc *stbi_pic_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp); +#ifndef STBI_NO_STDIO +extern int stbi_pic_test_file (FILE *f); +extern stbi_uc *stbi_pic_load_from_file (FILE *f, int *x, int *y, int *comp, int req_comp); +#endif + +// is it a gif? +extern int stbi_gif_test_memory (stbi_uc const *buffer, int len); + +extern stbi_uc *stbi_gif_load (char const *filename, int *x, int *y, int *comp, int req_comp); +extern stbi_uc *stbi_gif_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp); +extern int stbi_gif_info_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp); + +#ifndef STBI_NO_STDIO +extern int stbi_gif_test_file (FILE *f); +extern stbi_uc *stbi_gif_load_from_file (FILE *f, int *x, int *y, int *comp, int req_comp); +extern int stbi_gif_info (char const *filename, int *x, int *y, int *comp); +extern int stbi_gif_info_from_file (FILE *f, int *x, int *y, int *comp); +#endif + + +// this is not threadsafe +static const char *failure_reason; + +const char *stbi_failure_reason(void) +{ + return failure_reason; +} + +static int e(const char *str) +{ + failure_reason = str; + return 0; +} + +#ifdef STBI_NO_FAILURE_STRINGS + #define e(x,y) 0 +#elif defined(STBI_FAILURE_USERMSG) + #define e(x,y) e(y) +#else + #define e(x,y) e(x) +#endif + +#define epf(x,y) ((float *) (e(x,y)?NULL:NULL)) +#define epuc(x,y) ((unsigned char *) (e(x,y)?NULL:NULL)) + +void stbi_image_free(void *retval_from_stbi_load) +{ + free(retval_from_stbi_load); +} + +#define MAX_LOADERS 32 +stbi_loader *loaders[MAX_LOADERS]; +static int max_loaders = 0; + +int stbi_register_loader(stbi_loader *loader) +{ + int i; + for (i=0; i < MAX_LOADERS; ++i) { + // already present? + if (loaders[i] == loader) + return 1; + // end of the list? + if (loaders[i] == NULL) { + loaders[i] = loader; + max_loaders = i+1; + return 1; + } + } + // no room for it + return 0; +} + +#ifndef STBI_NO_HDR +static float *ldr_to_hdr(stbi_uc *data, int x, int y, int comp); +static stbi_uc *hdr_to_ldr(float *data, int x, int y, int comp); +#endif + +#ifndef STBI_NO_STDIO +unsigned char *stbi_load(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + FILE *f = fopen(filename, "rb"); + unsigned char *result; + if (!f) return epuc("can't fopen", "Unable to open file"); + result = stbi_load_from_file(f,x,y,comp,req_comp); + fclose(f); + return result; +} + +unsigned char *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + int i; + if (stbi_jpeg_test_file(f)) return stbi_jpeg_load_from_file(f,x,y,comp,req_comp); + if (stbi_png_test_file(f)) return stbi_png_load_from_file(f,x,y,comp,req_comp); + if (stbi_bmp_test_file(f)) return stbi_bmp_load_from_file(f,x,y,comp,req_comp); + if (stbi_gif_test_file(f)) return stbi_gif_load_from_file(f,x,y,comp,req_comp); + if (stbi_psd_test_file(f)) return stbi_psd_load_from_file(f,x,y,comp,req_comp); + if (stbi_pic_test_file(f)) return stbi_pic_load_from_file(f,x,y,comp,req_comp); + + #ifndef STBI_NO_HDR + if (stbi_hdr_test_file(f)) { + float *hdr = stbi_hdr_load_from_file(f, x,y,comp,req_comp); + return hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp); + } + #endif + + for (i=0; i < max_loaders; ++i) + if (loaders[i]->test_file(f)) + return loaders[i]->load_from_file(f,x,y,comp,req_comp); + // test tga last because it's a crappy test! + if (stbi_tga_test_file(f)) + return stbi_tga_load_from_file(f,x,y,comp,req_comp); + return epuc("unknown image type", "Image not of any known type, or corrupt"); +} +#endif + +unsigned char *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + int i; + if (stbi_jpeg_test_memory(buffer,len)) return stbi_jpeg_load_from_memory(buffer,len,x,y,comp,req_comp); + if (stbi_png_test_memory(buffer,len)) return stbi_png_load_from_memory(buffer,len,x,y,comp,req_comp); + if (stbi_bmp_test_memory(buffer,len)) return stbi_bmp_load_from_memory(buffer,len,x,y,comp,req_comp); + if (stbi_gif_test_memory(buffer,len)) return stbi_gif_load_from_memory(buffer,len,x,y,comp,req_comp); + if (stbi_psd_test_memory(buffer,len)) return stbi_psd_load_from_memory(buffer,len,x,y,comp,req_comp); + if (stbi_pic_test_memory(buffer,len)) return stbi_pic_load_from_memory(buffer,len,x,y,comp,req_comp); + + #ifndef STBI_NO_HDR + if (stbi_hdr_test_memory(buffer, len)) { + float *hdr = stbi_hdr_load_from_memory(buffer, len,x,y,comp,req_comp); + return hdr_to_ldr(hdr, *x, *y, req_comp ? req_comp : *comp); + } + #endif + + for (i=0; i < max_loaders; ++i) + if (loaders[i]->test_memory(buffer,len)) + return loaders[i]->load_from_memory(buffer,len,x,y,comp,req_comp); + // test tga last because it's a crappy test! + if (stbi_tga_test_memory(buffer,len)) + return stbi_tga_load_from_memory(buffer,len,x,y,comp,req_comp); + return epuc("unknown image type", "Image not of any known type, or corrupt"); +} + +#ifndef STBI_NO_HDR + +#ifndef STBI_NO_STDIO +float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + FILE *f = fopen(filename, "rb"); + float *result; + if (!f) return epf("can't fopen", "Unable to open file"); + result = stbi_loadf_from_file(f,x,y,comp,req_comp); + fclose(f); + return result; +} + +float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + unsigned char *data; + #ifndef STBI_NO_HDR + if (stbi_hdr_test_file(f)) + return stbi_hdr_load_from_file(f,x,y,comp,req_comp); + #endif + data = stbi_load_from_file(f, x, y, comp, req_comp); + if (data) + return ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp); + return epf("unknown image type", "Image not of any known type, or corrupt"); +} +#endif + +float *stbi_loadf_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + stbi_uc *data; + #ifndef STBI_NO_HDR + if (stbi_hdr_test_memory(buffer, len)) + return stbi_hdr_load_from_memory(buffer, len,x,y,comp,req_comp); + #endif + data = stbi_load_from_memory(buffer, len, x, y, comp, req_comp); + if (data) + return ldr_to_hdr(data, *x, *y, req_comp ? req_comp : *comp); + return epf("unknown image type", "Image not of any known type, or corrupt"); +} +#endif + +// these is-hdr-or-not is defined independent of whether STBI_NO_HDR is +// defined, for API simplicity; if STBI_NO_HDR is defined, it always +// reports false! + +int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len) +{ + #ifndef STBI_NO_HDR + return stbi_hdr_test_memory(buffer, len); + #else + return 0; + #endif +} + +#ifndef STBI_NO_STDIO +extern int stbi_is_hdr (char const *filename) +{ + FILE *f = fopen(filename, "rb"); + int result=0; + if (f) { + result = stbi_is_hdr_from_file(f); + fclose(f); + } + return result; +} + +extern int stbi_is_hdr_from_file(FILE *f) +{ + #ifndef STBI_NO_HDR + return stbi_hdr_test_file(f); + #else + return 0; + #endif +} + +#endif + +#ifndef STBI_NO_HDR +static float h2l_gamma_i=1.0f/2.2f, h2l_scale_i=1.0f; +static float l2h_gamma=2.2f, l2h_scale=1.0f; + +void stbi_hdr_to_ldr_gamma(float gamma) { h2l_gamma_i = 1/gamma; } +void stbi_hdr_to_ldr_scale(float scale) { h2l_scale_i = 1/scale; } + +void stbi_ldr_to_hdr_gamma(float gamma) { l2h_gamma = gamma; } +void stbi_ldr_to_hdr_scale(float scale) { l2h_scale = scale; } +#endif + + +////////////////////////////////////////////////////////////////////////////// +// +// Common code used by all image loaders +// + +enum +{ + SCAN_load=0, + SCAN_type, + SCAN_header, +}; + +typedef struct +{ + uint32 img_x, img_y; + int img_n, img_out_n; + + #ifndef STBI_NO_STDIO + FILE *img_file; + int buflen; + uint8 buffer_start[128]; + int from_file; + #endif + uint8 *img_buffer, *img_buffer_end; +} stbi; + +#ifndef STBI_NO_STDIO +static void start_file(stbi *s, FILE *f) +{ + s->img_file = f; + s->buflen = sizeof(s->buffer_start); + s->img_buffer_end = s->buffer_start + s->buflen; + s->img_buffer = s->img_buffer_end; + s->from_file = 1; +} +#endif + +static void start_mem(stbi *s, uint8 const *buffer, int len) +{ +#ifndef STBI_NO_STDIO + s->img_file = NULL; + s->from_file = 0; +#endif + s->img_buffer = (uint8 *) buffer; + s->img_buffer_end = (uint8 *) buffer+len; +} + +#ifndef STBI_NO_STDIO +static void refill_buffer(stbi *s) +{ + int n = fread(s->buffer_start, 1, s->buflen, s->img_file); + if (n == 0) { + s->from_file = 0; + s->img_buffer = s->img_buffer_end-1; + *s->img_buffer = 0; + } else { + s->img_buffer = s->buffer_start; + s->img_buffer_end = s->buffer_start + n; + } +} +#endif + +__forceinline static int get8(stbi *s) +{ + if (s->img_buffer < s->img_buffer_end) + return *s->img_buffer++; +#ifndef STBI_NO_STDIO + if (s->from_file) { + refill_buffer(s); + return *s->img_buffer++; + } +#endif + return 0; +} + +__forceinline static int at_eof(stbi *s) +{ +#ifndef STBI_NO_STDIO + if (s->img_file) { + if (!feof(s->img_file)) return 0; + // if feof() is true, check if buffer = end + // special case: we've only got the special 0 character at the end + if (s->from_file == 0) return 1; + } +#endif + return s->img_buffer >= s->img_buffer_end; +} + +__forceinline static uint8 get8u(stbi *s) +{ + return (uint8) get8(s); +} + +static void skip(stbi *s, int n) +{ +#ifndef STBI_NO_STDIO + if (s->img_file) { + int blen = s->img_buffer_end - s->img_buffer; + if (blen < n) { + s->img_buffer = s->img_buffer_end; + fseek(s->img_file, n - blen, SEEK_CUR); + return; + } + } +#endif + s->img_buffer += n; +} + +static int getn(stbi *s, stbi_uc *buffer, int n) +{ +#ifndef STBI_NO_STDIO + if (s->img_file) { + int blen = s->img_buffer_end - s->img_buffer; + if (blen < n) { + int res; + memcpy(buffer, s->img_buffer, blen); + res = ((int) fread(buffer + blen, 1, n - blen, s->img_file) == (n-blen)); + s->img_buffer = s->img_buffer_end; + return res; + } + } +#endif + if (s->img_buffer+n <= s->img_buffer_end) { + memcpy(buffer, s->img_buffer, n); + s->img_buffer += n; + return 1; + } else + return 0; +} + +static int get16(stbi *s) +{ + int z = get8(s); + return (z << 8) + get8(s); +} + +static uint32 get32(stbi *s) +{ + uint32 z = get16(s); + return (z << 16) + get16(s); +} + +static int get16le(stbi *s) +{ + int z = get8(s); + return z + (get8(s) << 8); +} + +static uint32 get32le(stbi *s) +{ + uint32 z = get16le(s); + return z + (get16le(s) << 16); +} + +////////////////////////////////////////////////////////////////////////////// +// +// generic converter from built-in img_n to req_comp +// individual types do this automatically as much as possible (e.g. jpeg +// does all cases internally since it needs to colorspace convert anyway, +// and it never has alpha, so very few cases ). png can automatically +// interleave an alpha=255 channel, but falls back to this for other cases +// +// assume data buffer is malloced, so malloc a new one and free that one +// only failure mode is malloc failing + +static uint8 compute_y(int r, int g, int b) +{ + return (uint8) (((r*77) + (g*150) + (29*b)) >> 8); +} + +static unsigned char *convert_format(unsigned char *data, int img_n, int req_comp, uint x, uint y) +{ + int i,j; + unsigned char *good; + + if (req_comp == img_n) return data; + assert(req_comp >= 1 && req_comp <= 4); + + good = (unsigned char *) malloc(req_comp * x * y); + if (good == NULL) { + free(data); + return epuc("outofmem", "Out of memory"); + } + + for (j=0; j < (int) y; ++j) { + unsigned char *src = data + j * x * img_n ; + unsigned char *dest = good + j * x * req_comp; + + #define COMBO(a,b) ((a)*8+(b)) + #define CASE(a,b) case COMBO(a,b): for(i=x-1; i >= 0; --i, src += a, dest += b) + // convert source image with img_n components to one with req_comp components; + // avoid switch per pixel, so use switch per scanline and massive macros + switch (COMBO(img_n, req_comp)) { + CASE(1,2) dest[0]=src[0], dest[1]=255; break; + CASE(1,3) dest[0]=dest[1]=dest[2]=src[0]; break; + CASE(1,4) dest[0]=dest[1]=dest[2]=src[0], dest[3]=255; break; + CASE(2,1) dest[0]=src[0]; break; + CASE(2,3) dest[0]=dest[1]=dest[2]=src[0]; break; + CASE(2,4) dest[0]=dest[1]=dest[2]=src[0], dest[3]=src[1]; break; + CASE(3,4) dest[0]=src[0],dest[1]=src[1],dest[2]=src[2],dest[3]=255; break; + CASE(3,1) dest[0]=compute_y(src[0],src[1],src[2]); break; + CASE(3,2) dest[0]=compute_y(src[0],src[1],src[2]), dest[1] = 255; break; + CASE(4,1) dest[0]=compute_y(src[0],src[1],src[2]); break; + CASE(4,2) dest[0]=compute_y(src[0],src[1],src[2]), dest[1] = src[3]; break; + CASE(4,3) dest[0]=src[0],dest[1]=src[1],dest[2]=src[2]; break; + default: assert(0); + } + #undef CASE + } + + free(data); + return good; +} + +#ifndef STBI_NO_HDR +static float *ldr_to_hdr(stbi_uc *data, int x, int y, int comp) +{ + int i,k,n; + float *output = (float *) malloc(x * y * comp * sizeof(float)); + if (output == NULL) { free(data); return epf("outofmem", "Out of memory"); } + // compute number of non-alpha components + if (comp & 1) n = comp; else n = comp-1; + for (i=0; i < x*y; ++i) { + for (k=0; k < n; ++k) { + output[i*comp + k] = (float) pow(data[i*comp+k]/255.0f, l2h_gamma) * l2h_scale; + } + if (k < comp) output[i*comp + k] = data[i*comp+k]/255.0f; + } + free(data); + return output; +} + +#define float2int(x) ((int) (x)) +static stbi_uc *hdr_to_ldr(float *data, int x, int y, int comp) +{ + int i,k,n; + stbi_uc *output = (stbi_uc *) malloc(x * y * comp); + if (output == NULL) { free(data); return epuc("outofmem", "Out of memory"); } + // compute number of non-alpha components + if (comp & 1) n = comp; else n = comp-1; + for (i=0; i < x*y; ++i) { + for (k=0; k < n; ++k) { + float z = (float) pow(data[i*comp+k]*h2l_scale_i, h2l_gamma_i) * 255 + 0.5f; + if (z < 0) z = 0; + if (z > 255) z = 255; + output[i*comp + k] = (uint8) float2int(z); + } + if (k < comp) { + float z = data[i*comp+k] * 255 + 0.5f; + if (z < 0) z = 0; + if (z > 255) z = 255; + output[i*comp + k] = (uint8) float2int(z); + } + } + free(data); + return output; +} +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// "baseline" JPEG/JFIF decoder (not actually fully baseline implementation) +// +// simple implementation +// - channel subsampling of at most 2 in each dimension +// - doesn't support delayed output of y-dimension +// - simple interface (only one output format: 8-bit interleaved RGB) +// - doesn't try to recover corrupt jpegs +// - doesn't allow partial loading, loading multiple at once +// - still fast on x86 (copying globals into locals doesn't help x86) +// - allocates lots of intermediate memory (full size of all components) +// - non-interleaved case requires this anyway +// - allows good upsampling (see next) +// high-quality +// - upsampled channels are bilinearly interpolated, even across blocks +// - quality integer IDCT derived from IJG's 'slow' +// performance +// - fast huffman; reasonable integer IDCT +// - uses a lot of intermediate memory, could cache poorly +// - load http://nothings.org/remote/anemones.jpg 3 times on 2.8Ghz P4 +// stb_jpeg: 1.34 seconds (MSVC6, default release build) +// stb_jpeg: 1.06 seconds (MSVC6, processor = Pentium Pro) +// IJL11.dll: 1.08 seconds (compiled by intel) +// IJG 1998: 0.98 seconds (MSVC6, makefile provided by IJG) +// IJG 1998: 0.95 seconds (MSVC6, makefile + proc=PPro) + +// huffman decoding acceleration +#define FAST_BITS 9 // larger handles more cases; smaller stomps less cache + +typedef struct +{ + uint8 fast[1 << FAST_BITS]; + // weirdly, repacking this into AoS is a 10% speed loss, instead of a win + uint16 code[256]; + uint8 values[256]; + uint8 size[257]; + unsigned int maxcode[18]; + int delta[17]; // old 'firstsymbol' - old 'firstcode' +} huffman; + +typedef struct +{ + #if STBI_SIMD + unsigned short dequant2[4][64]; + #endif + stbi s; + huffman huff_dc[4]; + huffman huff_ac[4]; + uint8 dequant[4][64]; + +// sizes for components, interleaved MCUs + int img_h_max, img_v_max; + int img_mcu_x, img_mcu_y; + int img_mcu_w, img_mcu_h; + +// definition of jpeg image component + struct + { + int id; + int h,v; + int tq; + int hd,ha; + int dc_pred; + + int x,y,w2,h2; + uint8 *data; + void *raw_data; + uint8 *linebuf; + } img_comp[4]; + + uint32 code_buffer; // jpeg entropy-coded buffer + int code_bits; // number of valid bits + unsigned char marker; // marker seen while filling entropy buffer + int nomore; // flag if we saw a marker so must stop + + int scan_n, order[4]; + int restart_interval, todo; +} jpeg; + +static int build_huffman(huffman *h, int *count) +{ + int i,j,k=0,code; + // build size list for each symbol (from JPEG spec) + for (i=0; i < 16; ++i) + for (j=0; j < count[i]; ++j) + h->size[k++] = (uint8) (i+1); + h->size[k] = 0; + + // compute actual symbols (from jpeg spec) + code = 0; + k = 0; + for(j=1; j <= 16; ++j) { + // compute delta to add to code to compute symbol id + h->delta[j] = k - code; + if (h->size[k] == j) { + while (h->size[k] == j) + h->code[k++] = (uint16) (code++); + if (code-1 >= (1 << j)) return e("bad code lengths","Corrupt JPEG"); + } + // compute largest code + 1 for this size, preshifted as needed later + h->maxcode[j] = code << (16-j); + code <<= 1; + } + h->maxcode[j] = 0xffffffff; + + // build non-spec acceleration table; 255 is flag for not-accelerated + memset(h->fast, 255, 1 << FAST_BITS); + for (i=0; i < k; ++i) { + int s = h->size[i]; + if (s <= FAST_BITS) { + int c = h->code[i] << (FAST_BITS-s); + int m = 1 << (FAST_BITS-s); + for (j=0; j < m; ++j) { + h->fast[c+j] = (uint8) i; + } + } + } + return 1; +} + +static void grow_buffer_unsafe(jpeg *j) +{ + do { + int b = j->nomore ? 0 : get8(&j->s); + if (b == 0xff) { + int c = get8(&j->s); + if (c != 0) { + j->marker = (unsigned char) c; + j->nomore = 1; + return; + } + } + j->code_buffer |= b << (24 - j->code_bits); + j->code_bits += 8; + } while (j->code_bits <= 24); +} + +// (1 << n) - 1 +static uint32 bmask[17]={0,1,3,7,15,31,63,127,255,511,1023,2047,4095,8191,16383,32767,65535}; + +// decode a jpeg huffman value from the bitstream +__forceinline static int decode(jpeg *j, huffman *h) +{ + unsigned int temp; + int c,k; + + if (j->code_bits < 16) grow_buffer_unsafe(j); + + // look at the top FAST_BITS and determine what symbol ID it is, + // if the code is <= FAST_BITS + c = (j->code_buffer >> (32 - FAST_BITS)) & ((1 << FAST_BITS)-1); + k = h->fast[c]; + if (k < 255) { + int s = h->size[k]; + if (s > j->code_bits) + return -1; + j->code_buffer <<= s; + j->code_bits -= s; + return h->values[k]; + } + + // naive test is to shift the code_buffer down so k bits are + // valid, then test against maxcode. To speed this up, we've + // preshifted maxcode left so that it has (16-k) 0s at the + // end; in other words, regardless of the number of bits, it + // wants to be compared against something shifted to have 16; + // that way we don't need to shift inside the loop. + temp = j->code_buffer >> 16; + for (k=FAST_BITS+1 ; ; ++k) + if (temp < h->maxcode[k]) + break; + if (k == 17) { + // error! code not found + j->code_bits -= 16; + return -1; + } + + if (k > j->code_bits) + return -1; + + // convert the huffman code to the symbol id + c = ((j->code_buffer >> (32 - k)) & bmask[k]) + h->delta[k]; + assert((((j->code_buffer) >> (32 - h->size[c])) & bmask[h->size[c]]) == h->code[c]); + + // convert the id to a symbol + j->code_bits -= k; + j->code_buffer <<= k; + return h->values[c]; +} + +// combined JPEG 'receive' and JPEG 'extend', since baseline +// always extends everything it receives. +__forceinline static int extend_receive(jpeg *j, int n) +{ + unsigned int m = 1 << (n-1); + unsigned int k; + if (j->code_bits < n) grow_buffer_unsafe(j); + + #if 1 + k = stbi_lrot(j->code_buffer, n); + j->code_buffer = k & ~bmask[n]; + k &= bmask[n]; + j->code_bits -= n; + #else + k = (j->code_buffer >> (32 - n)) & bmask[n]; + j->code_bits -= n; + j->code_buffer <<= n; + #endif + // the following test is probably a random branch that won't + // predict well. I tried to table accelerate it but failed. + // maybe it's compiling as a conditional move? + if (k < m) + return (-1 << n) + k + 1; + else + return k; +} + +// given a value that's at position X in the zigzag stream, +// where does it appear in the 8x8 matrix coded as row-major? +static uint8 dezigzag[64+15] = +{ + 0, 1, 8, 16, 9, 2, 3, 10, + 17, 24, 32, 25, 18, 11, 4, 5, + 12, 19, 26, 33, 40, 48, 41, 34, + 27, 20, 13, 6, 7, 14, 21, 28, + 35, 42, 49, 56, 57, 50, 43, 36, + 29, 22, 15, 23, 30, 37, 44, 51, + 58, 59, 52, 45, 38, 31, 39, 46, + 53, 60, 61, 54, 47, 55, 62, 63, + // let corrupt input sample past end + 63, 63, 63, 63, 63, 63, 63, 63, + 63, 63, 63, 63, 63, 63, 63 +}; + +// decode one 64-entry block-- +static int decode_block(jpeg *j, short data[64], huffman *hdc, huffman *hac, int b) +{ + int diff,dc,k; + int t = decode(j, hdc); + if (t < 0) return e("bad huffman code","Corrupt JPEG"); + + // 0 all the ac values now so we can do it 32-bits at a time + memset(data,0,64*sizeof(data[0])); + + diff = t ? extend_receive(j, t) : 0; + dc = j->img_comp[b].dc_pred + diff; + j->img_comp[b].dc_pred = dc; + data[0] = (short) dc; + + // decode AC components, see JPEG spec + k = 1; + do { + int r,s; + int rs = decode(j, hac); + if (rs < 0) return e("bad huffman code","Corrupt JPEG"); + s = rs & 15; + r = rs >> 4; + if (s == 0) { + if (rs != 0xf0) break; // end block + k += 16; + } else { + k += r; + // decode into unzigzag'd location + data[dezigzag[k++]] = (short) extend_receive(j,s); + } + } while (k < 64); + return 1; +} + +// take a -128..127 value and clamp it and convert to 0..255 +__forceinline static uint8 clamp(int x) +{ + // trick to use a single test to catch both cases + if ((unsigned int) x > 255) { + if (x < 0) return 0; + if (x > 255) return 255; + } + return (uint8) x; +} + +#define f2f(x) (int) (((x) * 4096 + 0.5)) +#define fsh(x) ((x) << 12) + +// derived from jidctint -- DCT_ISLOW +#define IDCT_1D(s0,s1,s2,s3,s4,s5,s6,s7) \ + int t0,t1,t2,t3,p1,p2,p3,p4,p5,x0,x1,x2,x3; \ + p2 = s2; \ + p3 = s6; \ + p1 = (p2+p3) * f2f(0.5411961f); \ + t2 = p1 + p3*f2f(-1.847759065f); \ + t3 = p1 + p2*f2f( 0.765366865f); \ + p2 = s0; \ + p3 = s4; \ + t0 = fsh(p2+p3); \ + t1 = fsh(p2-p3); \ + x0 = t0+t3; \ + x3 = t0-t3; \ + x1 = t1+t2; \ + x2 = t1-t2; \ + t0 = s7; \ + t1 = s5; \ + t2 = s3; \ + t3 = s1; \ + p3 = t0+t2; \ + p4 = t1+t3; \ + p1 = t0+t3; \ + p2 = t1+t2; \ + p5 = (p3+p4)*f2f( 1.175875602f); \ + t0 = t0*f2f( 0.298631336f); \ + t1 = t1*f2f( 2.053119869f); \ + t2 = t2*f2f( 3.072711026f); \ + t3 = t3*f2f( 1.501321110f); \ + p1 = p5 + p1*f2f(-0.899976223f); \ + p2 = p5 + p2*f2f(-2.562915447f); \ + p3 = p3*f2f(-1.961570560f); \ + p4 = p4*f2f(-0.390180644f); \ + t3 += p1+p4; \ + t2 += p2+p3; \ + t1 += p2+p4; \ + t0 += p1+p3; + +#if STBI_SIMD +typedef unsigned short stbi_dequantize_t; +#else +typedef uint8 stbi_dequantize_t; +#endif + +// .344 seconds on 3*anemones.jpg +static void idct_block(uint8 *out, int out_stride, short data[64], stbi_dequantize_t *dequantize) +{ + int i,val[64],*v=val; + stbi_dequantize_t *dq = dequantize; + uint8 *o; + short *d = data; + + // columns + for (i=0; i < 8; ++i,++d,++dq, ++v) { + // if all zeroes, shortcut -- this avoids dequantizing 0s and IDCTing + if (d[ 8]==0 && d[16]==0 && d[24]==0 && d[32]==0 + && d[40]==0 && d[48]==0 && d[56]==0) { + // no shortcut 0 seconds + // (1|2|3|4|5|6|7)==0 0 seconds + // all separate -0.047 seconds + // 1 && 2|3 && 4|5 && 6|7: -0.047 seconds + int dcterm = d[0] * dq[0] << 2; + v[0] = v[8] = v[16] = v[24] = v[32] = v[40] = v[48] = v[56] = dcterm; + } else { + IDCT_1D(d[ 0]*dq[ 0],d[ 8]*dq[ 8],d[16]*dq[16],d[24]*dq[24], + d[32]*dq[32],d[40]*dq[40],d[48]*dq[48],d[56]*dq[56]) + // constants scaled things up by 1<<12; let's bring them back + // down, but keep 2 extra bits of precision + x0 += 512; x1 += 512; x2 += 512; x3 += 512; + v[ 0] = (x0+t3) >> 10; + v[56] = (x0-t3) >> 10; + v[ 8] = (x1+t2) >> 10; + v[48] = (x1-t2) >> 10; + v[16] = (x2+t1) >> 10; + v[40] = (x2-t1) >> 10; + v[24] = (x3+t0) >> 10; + v[32] = (x3-t0) >> 10; + } + } + + for (i=0, v=val, o=out; i < 8; ++i,v+=8,o+=out_stride) { + // no fast case since the first 1D IDCT spread components out + IDCT_1D(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7]) + // constants scaled things up by 1<<12, plus we had 1<<2 from first + // loop, plus horizontal and vertical each scale by sqrt(8) so together + // we've got an extra 1<<3, so 1<<17 total we need to remove. + // so we want to round that, which means adding 0.5 * 1<<17, + // aka 65536. Also, we'll end up with -128 to 127 that we want + // to encode as 0..255 by adding 128, so we'll add that before the shift + x0 += 65536 + (128<<17); + x1 += 65536 + (128<<17); + x2 += 65536 + (128<<17); + x3 += 65536 + (128<<17); + // tried computing the shifts into temps, or'ing the temps to see + // if any were out of range, but that was slower + o[0] = clamp((x0+t3) >> 17); + o[7] = clamp((x0-t3) >> 17); + o[1] = clamp((x1+t2) >> 17); + o[6] = clamp((x1-t2) >> 17); + o[2] = clamp((x2+t1) >> 17); + o[5] = clamp((x2-t1) >> 17); + o[3] = clamp((x3+t0) >> 17); + o[4] = clamp((x3-t0) >> 17); + } +} + +#ifdef STBI_SIMD +static stbi_idct_8x8 stbi_idct_installed = idct_block; + +extern void stbi_install_idct(stbi_idct_8x8 func) +{ + stbi_idct_installed = func; +} +#endif + +#define MARKER_none 0xff +// if there's a pending marker from the entropy stream, return that +// otherwise, fetch from the stream and get a marker. if there's no +// marker, return 0xff, which is never a valid marker value +static uint8 get_marker(jpeg *j) +{ + uint8 x; + if (j->marker != MARKER_none) { x = j->marker; j->marker = MARKER_none; return x; } + x = get8u(&j->s); + if (x != 0xff) return MARKER_none; + while (x == 0xff) + x = get8u(&j->s); + return x; +} + +// in each scan, we'll have scan_n components, and the order +// of the components is specified by order[] +#define RESTART(x) ((x) >= 0xd0 && (x) <= 0xd7) + +// after a restart interval, reset the entropy decoder and +// the dc prediction +static void reset(jpeg *j) +{ + j->code_bits = 0; + j->code_buffer = 0; + j->nomore = 0; + j->img_comp[0].dc_pred = j->img_comp[1].dc_pred = j->img_comp[2].dc_pred = 0; + j->marker = MARKER_none; + j->todo = j->restart_interval ? j->restart_interval : 0x7fffffff; + // no more than 1<<31 MCUs if no restart_interal? that's plenty safe, + // since we don't even allow 1<<30 pixels +} + +static int parse_entropy_coded_data(jpeg *z) +{ + reset(z); + if (z->scan_n == 1) { + int i,j; + #if STBI_SIMD + __declspec(align(16)) + #endif + short data[64]; + int n = z->order[0]; + // non-interleaved data, we just need to process one block at a time, + // in trivial scanline order + // number of blocks to do just depends on how many actual "pixels" this + // component has, independent of interleaved MCU blocking and such + int w = (z->img_comp[n].x+7) >> 3; + int h = (z->img_comp[n].y+7) >> 3; + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) { + if (!decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+z->img_comp[n].ha, n)) return 0; + #if STBI_SIMD + stbi_idct_installed(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data, z->dequant2[z->img_comp[n].tq]); + #else + idct_block(z->img_comp[n].data+z->img_comp[n].w2*j*8+i*8, z->img_comp[n].w2, data, z->dequant[z->img_comp[n].tq]); + #endif + // every data block is an MCU, so countdown the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) grow_buffer_unsafe(z); + // if it's NOT a restart, then just bail, so we get corrupt data + // rather than no data + if (!RESTART(z->marker)) return 1; + reset(z); + } + } + } + } else { // interleaved! + int i,j,k,x,y; + short data[64]; + for (j=0; j < z->img_mcu_y; ++j) { + for (i=0; i < z->img_mcu_x; ++i) { + // scan an interleaved mcu... process scan_n components in order + for (k=0; k < z->scan_n; ++k) { + int n = z->order[k]; + // scan out an mcu's worth of this component; that's just determined + // by the basic H and V specified for the component + for (y=0; y < z->img_comp[n].v; ++y) { + for (x=0; x < z->img_comp[n].h; ++x) { + int x2 = (i*z->img_comp[n].h + x)*8; + int y2 = (j*z->img_comp[n].v + y)*8; + if (!decode_block(z, data, z->huff_dc+z->img_comp[n].hd, z->huff_ac+z->img_comp[n].ha, n)) return 0; + #if STBI_SIMD + stbi_idct_installed(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data, z->dequant2[z->img_comp[n].tq]); + #else + idct_block(z->img_comp[n].data+z->img_comp[n].w2*y2+x2, z->img_comp[n].w2, data, z->dequant[z->img_comp[n].tq]); + #endif + } + } + } + // after all interleaved components, that's an interleaved MCU, + // so now count down the restart interval + if (--z->todo <= 0) { + if (z->code_bits < 24) grow_buffer_unsafe(z); + // if it's NOT a restart, then just bail, so we get corrupt data + // rather than no data + if (!RESTART(z->marker)) return 1; + reset(z); + } + } + } + } + return 1; +} + +static int process_marker(jpeg *z, int m) +{ + int L; + switch (m) { + case MARKER_none: // no marker found + return e("expected marker","Corrupt JPEG"); + + case 0xC2: // SOF - progressive + return e("progressive jpeg","JPEG format not supported (progressive)"); + + case 0xDD: // DRI - specify restart interval + if (get16(&z->s) != 4) return e("bad DRI len","Corrupt JPEG"); + z->restart_interval = get16(&z->s); + return 1; + + case 0xDB: // DQT - define quantization table + L = get16(&z->s)-2; + while (L > 0) { + int q = get8(&z->s); + int p = q >> 4; + int t = q & 15,i; + if (p != 0) return e("bad DQT type","Corrupt JPEG"); + if (t > 3) return e("bad DQT table","Corrupt JPEG"); + for (i=0; i < 64; ++i) + z->dequant[t][dezigzag[i]] = get8u(&z->s); + #if STBI_SIMD + for (i=0; i < 64; ++i) + z->dequant2[t][i] = z->dequant[t][i]; + #endif + L -= 65; + } + return L==0; + + case 0xC4: // DHT - define huffman table + L = get16(&z->s)-2; + while (L > 0) { + uint8 *v; + int sizes[16],i,m=0; + int q = get8(&z->s); + int tc = q >> 4; + int th = q & 15; + if (tc > 1 || th > 3) return e("bad DHT header","Corrupt JPEG"); + for (i=0; i < 16; ++i) { + sizes[i] = get8(&z->s); + m += sizes[i]; + } + L -= 17; + if (tc == 0) { + if (!build_huffman(z->huff_dc+th, sizes)) return 0; + v = z->huff_dc[th].values; + } else { + if (!build_huffman(z->huff_ac+th, sizes)) return 0; + v = z->huff_ac[th].values; + } + for (i=0; i < m; ++i) + v[i] = get8u(&z->s); + L -= m; + } + return L==0; + } + // check for comment block or APP blocks + if ((m >= 0xE0 && m <= 0xEF) || m == 0xFE) { + skip(&z->s, get16(&z->s)-2); + return 1; + } + return 0; +} + +// after we see SOS +static int process_scan_header(jpeg *z) +{ + int i; + int Ls = get16(&z->s); + z->scan_n = get8(&z->s); + if (z->scan_n < 1 || z->scan_n > 4 || z->scan_n > (int) z->s.img_n) return e("bad SOS component count","Corrupt JPEG"); + if (Ls != 6+2*z->scan_n) return e("bad SOS len","Corrupt JPEG"); + for (i=0; i < z->scan_n; ++i) { + int id = get8(&z->s), which; + int q = get8(&z->s); + for (which = 0; which < z->s.img_n; ++which) + if (z->img_comp[which].id == id) + break; + if (which == z->s.img_n) return 0; + z->img_comp[which].hd = q >> 4; if (z->img_comp[which].hd > 3) return e("bad DC huff","Corrupt JPEG"); + z->img_comp[which].ha = q & 15; if (z->img_comp[which].ha > 3) return e("bad AC huff","Corrupt JPEG"); + z->order[i] = which; + } + if (get8(&z->s) != 0) return e("bad SOS","Corrupt JPEG"); + get8(&z->s); // should be 63, but might be 0 + if (get8(&z->s) != 0) return e("bad SOS","Corrupt JPEG"); + + return 1; +} + +static int process_frame_header(jpeg *z, int scan) +{ + stbi *s = &z->s; + int Lf,p,i,q, h_max=1,v_max=1,c; + Lf = get16(s); if (Lf < 11) return e("bad SOF len","Corrupt JPEG"); // JPEG + p = get8(s); if (p != 8) return e("only 8-bit","JPEG format not supported: 8-bit only"); // JPEG baseline + s->img_y = get16(s); if (s->img_y == 0) return e("no header height", "JPEG format not supported: delayed height"); // Legal, but we don't handle it--but neither does IJG + s->img_x = get16(s); if (s->img_x == 0) return e("0 width","Corrupt JPEG"); // JPEG requires + c = get8(s); + if (c != 3 && c != 1) return e("bad component count","Corrupt JPEG"); // JFIF requires + s->img_n = c; + for (i=0; i < c; ++i) { + z->img_comp[i].data = NULL; + z->img_comp[i].linebuf = NULL; + } + + if (Lf != 8+3*s->img_n) return e("bad SOF len","Corrupt JPEG"); + + for (i=0; i < s->img_n; ++i) { + z->img_comp[i].id = get8(s); + if (z->img_comp[i].id != i+1) // JFIF requires + if (z->img_comp[i].id != i) // some version of jpegtran outputs non-JFIF-compliant files! + return e("bad component ID","Corrupt JPEG"); + q = get8(s); + z->img_comp[i].h = (q >> 4); if (!z->img_comp[i].h || z->img_comp[i].h > 4) return e("bad H","Corrupt JPEG"); + z->img_comp[i].v = q & 15; if (!z->img_comp[i].v || z->img_comp[i].v > 4) return e("bad V","Corrupt JPEG"); + z->img_comp[i].tq = get8(s); if (z->img_comp[i].tq > 3) return e("bad TQ","Corrupt JPEG"); + } + + if (scan != SCAN_load) return 1; + + if ((1 << 30) / s->img_x / s->img_n < s->img_y) return e("too large", "Image too large to decode"); + + for (i=0; i < s->img_n; ++i) { + if (z->img_comp[i].h > h_max) h_max = z->img_comp[i].h; + if (z->img_comp[i].v > v_max) v_max = z->img_comp[i].v; + } + + // compute interleaved mcu info + z->img_h_max = h_max; + z->img_v_max = v_max; + z->img_mcu_w = h_max * 8; + z->img_mcu_h = v_max * 8; + z->img_mcu_x = (s->img_x + z->img_mcu_w-1) / z->img_mcu_w; + z->img_mcu_y = (s->img_y + z->img_mcu_h-1) / z->img_mcu_h; + + for (i=0; i < s->img_n; ++i) { + // number of effective pixels (e.g. for non-interleaved MCU) + z->img_comp[i].x = (s->img_x * z->img_comp[i].h + h_max-1) / h_max; + z->img_comp[i].y = (s->img_y * z->img_comp[i].v + v_max-1) / v_max; + // to simplify generation, we'll allocate enough memory to decode + // the bogus oversized data from using interleaved MCUs and their + // big blocks (e.g. a 16x16 iMCU on an image of width 33); we won't + // discard the extra data until colorspace conversion + z->img_comp[i].w2 = z->img_mcu_x * z->img_comp[i].h * 8; + z->img_comp[i].h2 = z->img_mcu_y * z->img_comp[i].v * 8; + z->img_comp[i].raw_data = malloc(z->img_comp[i].w2 * z->img_comp[i].h2+15); + if (z->img_comp[i].raw_data == NULL) { + for(--i; i >= 0; --i) { + free(z->img_comp[i].raw_data); + z->img_comp[i].data = NULL; + } + return e("outofmem", "Out of memory"); + } + // align blocks for installable-idct using mmx/sse + z->img_comp[i].data = (uint8*) (((size_t) z->img_comp[i].raw_data + 15) & ~15); + z->img_comp[i].linebuf = NULL; + } + + return 1; +} + +// use comparisons since in some cases we handle more than one case (e.g. SOF) +#define DNL(x) ((x) == 0xdc) +#define SOI(x) ((x) == 0xd8) +#define EOI(x) ((x) == 0xd9) +#define SOF(x) ((x) == 0xc0 || (x) == 0xc1) +#define SOS(x) ((x) == 0xda) + +static int decode_jpeg_header(jpeg *z, int scan) +{ + int m; + z->marker = MARKER_none; // initialize cached marker to empty + m = get_marker(z); + if (!SOI(m)) return e("no SOI","Corrupt JPEG"); + if (scan == SCAN_type) return 1; + m = get_marker(z); + while (!SOF(m)) { + if (!process_marker(z,m)) return 0; + m = get_marker(z); + while (m == MARKER_none) { + // some files have extra padding after their blocks, so ok, we'll scan + if (at_eof(&z->s)) return e("no SOF", "Corrupt JPEG"); + m = get_marker(z); + } + } + if (!process_frame_header(z, scan)) return 0; + return 1; +} + +static int decode_jpeg_image(jpeg *j) +{ + int m; + j->restart_interval = 0; + if (!decode_jpeg_header(j, SCAN_load)) return 0; + m = get_marker(j); + while (!EOI(m)) { + if (SOS(m)) { + if (!process_scan_header(j)) return 0; + if (!parse_entropy_coded_data(j)) return 0; + if (j->marker == MARKER_none ) { + // handle 0s at the end of image data from IP Kamera 9060 + while (!at_eof(&j->s)) { + int x = get8(&j->s); + if (x == 255) { + j->marker = get8u(&j->s); + break; + } else if (x != 0) { + return 0; + } + } + // if we reach eof without hitting a marker, get_marker() below will fail and we'll eventually return 0 + } + } else { + if (!process_marker(j, m)) return 0; + } + m = get_marker(j); + } + return 1; +} + +// static jfif-centered resampling (across block boundaries) + +typedef uint8 *(*resample_row_func)(uint8 *out, uint8 *in0, uint8 *in1, + int w, int hs); + +#define div4(x) ((uint8) ((x) >> 2)) + +static uint8 *resample_row_1(uint8 *out, uint8 *in_near, uint8 *in_far, int w, int hs) +{ + STBI_NOTUSED(out); + STBI_NOTUSED(in_far); + STBI_NOTUSED(w); + STBI_NOTUSED(hs); + return in_near; +} + +static uint8* resample_row_v_2(uint8 *out, uint8 *in_near, uint8 *in_far, int w, int hs) +{ + // need to generate two samples vertically for every one in input + int i; + STBI_NOTUSED(hs); + for (i=0; i < w; ++i) + out[i] = div4(3*in_near[i] + in_far[i] + 2); + return out; +} + +static uint8* resample_row_h_2(uint8 *out, uint8 *in_near, uint8 *in_far, int w, int hs) +{ + // need to generate two samples horizontally for every one in input + int i; + uint8 *input = in_near; + + if (w == 1) { + // if only one sample, can't do any interpolation + out[0] = out[1] = input[0]; + return out; + } + + out[0] = input[0]; + out[1] = div4(input[0]*3 + input[1] + 2); + for (i=1; i < w-1; ++i) { + int n = 3*input[i]+2; + out[i*2+0] = div4(n+input[i-1]); + out[i*2+1] = div4(n+input[i+1]); + } + out[i*2+0] = div4(input[w-2]*3 + input[w-1] + 2); + out[i*2+1] = input[w-1]; + + STBI_NOTUSED(in_far); + STBI_NOTUSED(hs); + + return out; +} + +#define div16(x) ((uint8) ((x) >> 4)) + +static uint8 *resample_row_hv_2(uint8 *out, uint8 *in_near, uint8 *in_far, int w, int hs) +{ + // need to generate 2x2 samples for every one in input + int i,t0,t1; + if (w == 1) { + out[0] = out[1] = div4(3*in_near[0] + in_far[0] + 2); + return out; + } + + t1 = 3*in_near[0] + in_far[0]; + out[0] = div4(t1+2); + for (i=1; i < w; ++i) { + t0 = t1; + t1 = 3*in_near[i]+in_far[i]; + out[i*2-1] = div16(3*t0 + t1 + 8); + out[i*2 ] = div16(3*t1 + t0 + 8); + } + out[w*2-1] = div4(t1+2); + + STBI_NOTUSED(hs); + + return out; +} + +static uint8 *resample_row_generic(uint8 *out, uint8 *in_near, uint8 *in_far, int w, int hs) +{ + // resample with nearest-neighbor + int i,j; + in_far = in_far; + for (i=0; i < w; ++i) + for (j=0; j < hs; ++j) + out[i*hs+j] = in_near[i]; + return out; +} + +#define float2fixed(x) ((int) ((x) * 65536 + 0.5)) + +// 0.38 seconds on 3*anemones.jpg (0.25 with processor = Pro) +// VC6 without processor=Pro is generating multiple LEAs per multiply! +static void YCbCr_to_RGB_row(uint8 *out, const uint8 *y, const uint8 *pcb, const uint8 *pcr, int count, int step) +{ + int i; + for (i=0; i < count; ++i) { + int y_fixed = (y[i] << 16) + 32768; // rounding + int r,g,b; + int cr = pcr[i] - 128; + int cb = pcb[i] - 128; + r = y_fixed + cr*float2fixed(1.40200f); + g = y_fixed - cr*float2fixed(0.71414f) - cb*float2fixed(0.34414f); + b = y_fixed + cb*float2fixed(1.77200f); + r >>= 16; + g >>= 16; + b >>= 16; + if ((unsigned) r > 255) { if (r < 0) r = 0; else r = 255; } + if ((unsigned) g > 255) { if (g < 0) g = 0; else g = 255; } + if ((unsigned) b > 255) { if (b < 0) b = 0; else b = 255; } + out[0] = (uint8)r; + out[1] = (uint8)g; + out[2] = (uint8)b; + out[3] = 255; + out += step; + } +} + +#if STBI_SIMD +static stbi_YCbCr_to_RGB_run stbi_YCbCr_installed = YCbCr_to_RGB_row; + +void stbi_install_YCbCr_to_RGB(stbi_YCbCr_to_RGB_run func) +{ + stbi_YCbCr_installed = func; +} +#endif + + +// clean up the temporary component buffers +static void cleanup_jpeg(jpeg *j) +{ + int i; + for (i=0; i < j->s.img_n; ++i) { + if (j->img_comp[i].data) { + free(j->img_comp[i].raw_data); + j->img_comp[i].data = NULL; + } + if (j->img_comp[i].linebuf) { + free(j->img_comp[i].linebuf); + j->img_comp[i].linebuf = NULL; + } + } +} + +typedef struct +{ + resample_row_func resample; + uint8 *line0,*line1; + int hs,vs; // expansion factor in each axis + int w_lores; // horizontal pixels pre-expansion + int ystep; // how far through vertical expansion we are + int ypos; // which pre-expansion row we're on +} stbi_resample; + +static uint8 *load_jpeg_image(jpeg *z, int *out_x, int *out_y, int *comp, int req_comp) +{ + int n, decode_n; + // validate req_comp + if (req_comp < 0 || req_comp > 4) return epuc("bad req_comp", "Internal error"); + z->s.img_n = 0; + + // load a jpeg image from whichever source + if (!decode_jpeg_image(z)) { cleanup_jpeg(z); return NULL; } + + // determine actual number of components to generate + n = req_comp ? req_comp : z->s.img_n; + + if (z->s.img_n == 3 && n < 3) + decode_n = 1; + else + decode_n = z->s.img_n; + + // resample and color-convert + { + int k; + uint i,j; + uint8 *output; + uint8 *coutput[4]; + + stbi_resample res_comp[4]; + + for (k=0; k < decode_n; ++k) { + stbi_resample *r = &res_comp[k]; + + // allocate line buffer big enough for upsampling off the edges + // with upsample factor of 4 + z->img_comp[k].linebuf = (uint8 *) malloc(z->s.img_x + 3); + if (!z->img_comp[k].linebuf) { cleanup_jpeg(z); return epuc("outofmem", "Out of memory"); } + + r->hs = z->img_h_max / z->img_comp[k].h; + r->vs = z->img_v_max / z->img_comp[k].v; + r->ystep = r->vs >> 1; + r->w_lores = (z->s.img_x + r->hs-1) / r->hs; + r->ypos = 0; + r->line0 = r->line1 = z->img_comp[k].data; + + if (r->hs == 1 && r->vs == 1) r->resample = resample_row_1; + else if (r->hs == 1 && r->vs == 2) r->resample = resample_row_v_2; + else if (r->hs == 2 && r->vs == 1) r->resample = resample_row_h_2; + else if (r->hs == 2 && r->vs == 2) r->resample = resample_row_hv_2; + else r->resample = resample_row_generic; + } + + // can't error after this so, this is safe + output = (uint8 *) malloc(n * z->s.img_x * z->s.img_y + 1); + if (!output) { cleanup_jpeg(z); return epuc("outofmem", "Out of memory"); } + + // now go ahead and resample + for (j=0; j < z->s.img_y; ++j) { + uint8 *out = output + n * z->s.img_x * j; + for (k=0; k < decode_n; ++k) { + stbi_resample *r = &res_comp[k]; + int y_bot = r->ystep >= (r->vs >> 1); + coutput[k] = r->resample(z->img_comp[k].linebuf, + y_bot ? r->line1 : r->line0, + y_bot ? r->line0 : r->line1, + r->w_lores, r->hs); + if (++r->ystep >= r->vs) { + r->ystep = 0; + r->line0 = r->line1; + if (++r->ypos < z->img_comp[k].y) + r->line1 += z->img_comp[k].w2; + } + } + if (n >= 3) { + uint8 *y = coutput[0]; + if (z->s.img_n == 3) { + #if STBI_SIMD + stbi_YCbCr_installed(out, y, coutput[1], coutput[2], z->s.img_x, n); + #else + YCbCr_to_RGB_row(out, y, coutput[1], coutput[2], z->s.img_x, n); + #endif + } else + for (i=0; i < z->s.img_x; ++i) { + out[0] = out[1] = out[2] = y[i]; + out[3] = 255; // not used if n==3 + out += n; + } + } else { + uint8 *y = coutput[0]; + if (n == 1) + for (i=0; i < z->s.img_x; ++i) out[i] = y[i]; + else + for (i=0; i < z->s.img_x; ++i) *out++ = y[i], *out++ = 255; + } + } + cleanup_jpeg(z); + *out_x = z->s.img_x; + *out_y = z->s.img_y; + if (comp) *comp = z->s.img_n; // report original components, not output + return output; + } +} + +#ifndef STBI_NO_STDIO +unsigned char *stbi_jpeg_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + jpeg j; + start_file(&j.s, f); + return load_jpeg_image(&j, x,y,comp,req_comp); +} + +unsigned char *stbi_jpeg_load(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + unsigned char *data; + FILE *f = fopen(filename, "rb"); + if (!f) return NULL; + data = stbi_jpeg_load_from_file(f,x,y,comp,req_comp); + fclose(f); + return data; +} +#endif + +unsigned char *stbi_jpeg_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + jpeg j; + start_mem(&j.s, buffer,len); + return load_jpeg_image(&j, x,y,comp,req_comp); +} + +static int stbi_jpeg_info_raw(jpeg *j, int *x, int *y, int *comp) +{ + if (!decode_jpeg_header(j, SCAN_header)) + return 0; + if (x) *x = j->s.img_x; + if (y) *y = j->s.img_y; + if (comp) *comp = j->s.img_n; + return 1; +} + +#ifndef STBI_NO_STDIO +int stbi_jpeg_test_file(FILE *f) +{ + int n,r; + jpeg j; + n = ftell(f); + start_file(&j.s, f); + r = decode_jpeg_header(&j, SCAN_type); + fseek(f,n,SEEK_SET); + return r; +} + +int stbi_jpeg_info_from_file(FILE *f, int *x, int *y, int *comp) +{ + jpeg j; + long n = ftell(f); + int res; + start_file(&j.s, f); + res = stbi_jpeg_info_raw(&j, x, y, comp); + fseek(f, n, SEEK_SET); + return res; +} + +int stbi_jpeg_info(char const *filename, int *x, int *y, int *comp) +{ + FILE *f = fopen(filename, "rb"); + int result; + if (!f) return e("can't fopen", "Unable to open file"); + result = stbi_jpeg_info_from_file(f, x, y, comp); + fclose(f); + return result; +} +#endif + +int stbi_jpeg_test_memory(stbi_uc const *buffer, int len) +{ + jpeg j; + start_mem(&j.s, buffer,len); + return decode_jpeg_header(&j, SCAN_type); +} + +int stbi_jpeg_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp) +{ + jpeg j; + start_mem(&j.s, buffer, len); + return stbi_jpeg_info_raw(&j, x, y, comp); +} + +#ifndef STBI_NO_STDIO +extern int stbi_jpeg_info (char const *filename, int *x, int *y, int *comp); +extern int stbi_jpeg_info_from_file (FILE *f, int *x, int *y, int *comp); +#endif +extern int stbi_jpeg_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp); + +// public domain zlib decode v0.2 Sean Barrett 2006-11-18 +// simple implementation +// - all input must be provided in an upfront buffer +// - all output is written to a single output buffer (can malloc/realloc) +// performance +// - fast huffman + +// fast-way is faster to check than jpeg huffman, but slow way is slower +#define ZFAST_BITS 9 // accelerate all cases in default tables +#define ZFAST_MASK ((1 << ZFAST_BITS) - 1) + +// zlib-style huffman encoding +// (jpegs packs from left, zlib from right, so can't share code) +typedef struct +{ + uint16 fast[1 << ZFAST_BITS]; + uint16 firstcode[16]; + int maxcode[17]; + uint16 firstsymbol[16]; + uint8 size[288]; + uint16 value[288]; +} zhuffman; + +__forceinline static int bitreverse16(int n) +{ + n = ((n & 0xAAAA) >> 1) | ((n & 0x5555) << 1); + n = ((n & 0xCCCC) >> 2) | ((n & 0x3333) << 2); + n = ((n & 0xF0F0) >> 4) | ((n & 0x0F0F) << 4); + n = ((n & 0xFF00) >> 8) | ((n & 0x00FF) << 8); + return n; +} + +__forceinline static int bit_reverse(int v, int bits) +{ + assert(bits <= 16); + // to bit reverse n bits, reverse 16 and shift + // e.g. 11 bits, bit reverse and shift away 5 + return bitreverse16(v) >> (16-bits); +} + +static int zbuild_huffman(zhuffman *z, uint8 *sizelist, int num) +{ + int i,k=0; + int code, next_code[16], sizes[17]; + + // DEFLATE spec for generating codes + memset(sizes, 0, sizeof(sizes)); + memset(z->fast, 255, sizeof(z->fast)); + for (i=0; i < num; ++i) + ++sizes[sizelist[i]]; + sizes[0] = 0; + for (i=1; i < 16; ++i) + assert(sizes[i] <= (1 << i)); + code = 0; + for (i=1; i < 16; ++i) { + next_code[i] = code; + z->firstcode[i] = (uint16) code; + z->firstsymbol[i] = (uint16) k; + code = (code + sizes[i]); + if (sizes[i]) + if (code-1 >= (1 << i)) return e("bad codelengths","Corrupt JPEG"); + z->maxcode[i] = code << (16-i); // preshift for inner loop + code <<= 1; + k += sizes[i]; + } + z->maxcode[16] = 0x10000; // sentinel + for (i=0; i < num; ++i) { + int s = sizelist[i]; + if (s) { + int c = next_code[s] - z->firstcode[s] + z->firstsymbol[s]; + z->size[c] = (uint8)s; + z->value[c] = (uint16)i; + if (s <= ZFAST_BITS) { + int k = bit_reverse(next_code[s],s); + while (k < (1 << ZFAST_BITS)) { + z->fast[k] = (uint16) c; + k += (1 << s); + } + } + ++next_code[s]; + } + } + return 1; +} + +// zlib-from-memory implementation for PNG reading +// because PNG allows splitting the zlib stream arbitrarily, +// and it's annoying structurally to have PNG call ZLIB call PNG, +// we require PNG read all the IDATs and combine them into a single +// memory buffer + +typedef struct +{ + uint8 *zbuffer, *zbuffer_end; + int num_bits; + uint32 code_buffer; + + char *zout; + char *zout_start; + char *zout_end; + int z_expandable; + + zhuffman z_length, z_distance; +} zbuf; + +__forceinline static int zget8(zbuf *z) +{ + if (z->zbuffer >= z->zbuffer_end) return 0; + return *z->zbuffer++; +} + +static void fill_bits(zbuf *z) +{ + do { + assert(z->code_buffer < (1U << z->num_bits)); + z->code_buffer |= zget8(z) << z->num_bits; + z->num_bits += 8; + } while (z->num_bits <= 24); +} + +__forceinline static unsigned int zreceive(zbuf *z, int n) +{ + unsigned int k; + if (z->num_bits < n) fill_bits(z); + k = z->code_buffer & ((1 << n) - 1); + z->code_buffer >>= n; + z->num_bits -= n; + return k; +} + +__forceinline static int zhuffman_decode(zbuf *a, zhuffman *z) +{ + int b,s,k; + if (a->num_bits < 16) fill_bits(a); + b = z->fast[a->code_buffer & ZFAST_MASK]; + if (b < 0xffff) { + s = z->size[b]; + a->code_buffer >>= s; + a->num_bits -= s; + return z->value[b]; + } + + // not resolved by fast table, so compute it the slow way + // use jpeg approach, which requires MSbits at top + k = bit_reverse(a->code_buffer, 16); + for (s=ZFAST_BITS+1; ; ++s) + if (k < z->maxcode[s]) + break; + if (s == 16) return -1; // invalid code! + // code size is s, so: + b = (k >> (16-s)) - z->firstcode[s] + z->firstsymbol[s]; + assert(z->size[b] == s); + a->code_buffer >>= s; + a->num_bits -= s; + return z->value[b]; +} + +static int expand(zbuf *z, int n) // need to make room for n bytes +{ + char *q; + int cur, limit; + if (!z->z_expandable) return e("output buffer limit","Corrupt PNG"); + cur = (int) (z->zout - z->zout_start); + limit = (int) (z->zout_end - z->zout_start); + while (cur + n > limit) + limit *= 2; + q = (char *) realloc(z->zout_start, limit); + if (q == NULL) return e("outofmem", "Out of memory"); + z->zout_start = q; + z->zout = q + cur; + z->zout_end = q + limit; + return 1; +} + +static int length_base[31] = { + 3,4,5,6,7,8,9,10,11,13, + 15,17,19,23,27,31,35,43,51,59, + 67,83,99,115,131,163,195,227,258,0,0 }; + +static int length_extra[31]= +{ 0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0,0,0 }; + +static int dist_base[32] = { 1,2,3,4,5,7,9,13,17,25,33,49,65,97,129,193, +257,385,513,769,1025,1537,2049,3073,4097,6145,8193,12289,16385,24577,0,0}; + +static int dist_extra[32] = +{ 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13}; + +static int parse_huffman_block(zbuf *a) +{ + for(;;) { + int z = zhuffman_decode(a, &a->z_length); + if (z < 256) { + if (z < 0) return e("bad huffman code","Corrupt PNG"); // error in huffman codes + if (a->zout >= a->zout_end) if (!expand(a, 1)) return 0; + *a->zout++ = (char) z; + } else { + uint8 *p; + int len,dist; + if (z == 256) return 1; + z -= 257; + len = length_base[z]; + if (length_extra[z]) len += zreceive(a, length_extra[z]); + z = zhuffman_decode(a, &a->z_distance); + if (z < 0) return e("bad huffman code","Corrupt PNG"); + dist = dist_base[z]; + if (dist_extra[z]) dist += zreceive(a, dist_extra[z]); + if (a->zout - a->zout_start < dist) return e("bad dist","Corrupt PNG"); + if (a->zout + len > a->zout_end) if (!expand(a, len)) return 0; + p = (uint8 *) (a->zout - dist); + while (len--) + *a->zout++ = *p++; + } + } +} + +static int compute_huffman_codes(zbuf *a) +{ + static uint8 length_dezigzag[19] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 }; + zhuffman z_codelength; + uint8 lencodes[286+32+137];//padding for maximum single op + uint8 codelength_sizes[19]; + int i,n; + + int hlit = zreceive(a,5) + 257; + int hdist = zreceive(a,5) + 1; + int hclen = zreceive(a,4) + 4; + + memset(codelength_sizes, 0, sizeof(codelength_sizes)); + for (i=0; i < hclen; ++i) { + int s = zreceive(a,3); + codelength_sizes[length_dezigzag[i]] = (uint8) s; + } + if (!zbuild_huffman(&z_codelength, codelength_sizes, 19)) return 0; + + n = 0; + while (n < hlit + hdist) { + int c = zhuffman_decode(a, &z_codelength); + assert(c >= 0 && c < 19); + if (c < 16) + lencodes[n++] = (uint8) c; + else if (c == 16) { + c = zreceive(a,2)+3; + memset(lencodes+n, lencodes[n-1], c); + n += c; + } else if (c == 17) { + c = zreceive(a,3)+3; + memset(lencodes+n, 0, c); + n += c; + } else { + assert(c == 18); + c = zreceive(a,7)+11; + memset(lencodes+n, 0, c); + n += c; + } + } + if (n != hlit+hdist) return e("bad codelengths","Corrupt PNG"); + if (!zbuild_huffman(&a->z_length, lencodes, hlit)) return 0; + if (!zbuild_huffman(&a->z_distance, lencodes+hlit, hdist)) return 0; + return 1; +} + +static int parse_uncompressed_block(zbuf *a) +{ + uint8 header[4]; + int len,nlen,k; + if (a->num_bits & 7) + zreceive(a, a->num_bits & 7); // discard + // drain the bit-packed data into header + k = 0; + while (a->num_bits > 0) { + header[k++] = (uint8) (a->code_buffer & 255); // wtf this warns? + a->code_buffer >>= 8; + a->num_bits -= 8; + } + assert(a->num_bits == 0); + // now fill header the normal way + while (k < 4) + header[k++] = (uint8) zget8(a); + len = header[1] * 256 + header[0]; + nlen = header[3] * 256 + header[2]; + if (nlen != (len ^ 0xffff)) return e("zlib corrupt","Corrupt PNG"); + if (a->zbuffer + len > a->zbuffer_end) return e("read past buffer","Corrupt PNG"); + if (a->zout + len > a->zout_end) + if (!expand(a, len)) return 0; + memcpy(a->zout, a->zbuffer, len); + a->zbuffer += len; + a->zout += len; + return 1; +} + +static int parse_zlib_header(zbuf *a) +{ + int cmf = zget8(a); + int cm = cmf & 15; + /* int cinfo = cmf >> 4; */ + int flg = zget8(a); + if ((cmf*256+flg) % 31 != 0) return e("bad zlib header","Corrupt PNG"); // zlib spec + if (flg & 32) return e("no preset dict","Corrupt PNG"); // preset dictionary not allowed in png + if (cm != 8) return e("bad compression","Corrupt PNG"); // DEFLATE required for png + // window = 1 << (8 + cinfo)... but who cares, we fully buffer output + return 1; +} + +// @TODO: should statically initialize these for optimal thread safety +static uint8 default_length[288], default_distance[32]; +static void init_defaults(void) +{ + int i; // use <= to match clearly with spec + for (i=0; i <= 143; ++i) default_length[i] = 8; + for ( ; i <= 255; ++i) default_length[i] = 9; + for ( ; i <= 279; ++i) default_length[i] = 7; + for ( ; i <= 287; ++i) default_length[i] = 8; + + for (i=0; i <= 31; ++i) default_distance[i] = 5; +} + +int stbi_png_partial; // a quick hack to only allow decoding some of a PNG... I should implement real streaming support instead +static int parse_zlib(zbuf *a, int parse_header) +{ + int final, type; + if (parse_header) + if (!parse_zlib_header(a)) return 0; + a->num_bits = 0; + a->code_buffer = 0; + do { + final = zreceive(a,1); + type = zreceive(a,2); + if (type == 0) { + if (!parse_uncompressed_block(a)) return 0; + } else if (type == 3) { + return 0; + } else { + if (type == 1) { + // use fixed code lengths + if (!default_distance[31]) init_defaults(); + if (!zbuild_huffman(&a->z_length , default_length , 288)) return 0; + if (!zbuild_huffman(&a->z_distance, default_distance, 32)) return 0; + } else { + if (!compute_huffman_codes(a)) return 0; + } + if (!parse_huffman_block(a)) return 0; + } + if (stbi_png_partial && a->zout - a->zout_start > 65536) + break; + } while (!final); + return 1; +} + +static int do_zlib(zbuf *a, char *obuf, int olen, int exp, int parse_header) +{ + a->zout_start = obuf; + a->zout = obuf; + a->zout_end = obuf + olen; + a->z_expandable = exp; + + return parse_zlib(a, parse_header); +} + +char *stbi_zlib_decode_malloc_guesssize(const char *buffer, int len, int initial_size, int *outlen) +{ + zbuf a; + char *p = (char *) malloc(initial_size); + if (p == NULL) return NULL; + a.zbuffer = (uint8 *) buffer; + a.zbuffer_end = (uint8 *) buffer + len; + if (do_zlib(&a, p, initial_size, 1, 1)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + free(a.zout_start); + return NULL; + } +} + +char *stbi_zlib_decode_malloc(char const *buffer, int len, int *outlen) +{ + return stbi_zlib_decode_malloc_guesssize(buffer, len, 16384, outlen); +} + +char *stbi_zlib_decode_malloc_guesssize_headerflag(const char *buffer, int len, int initial_size, int *outlen, int parse_header) +{ + zbuf a; + char *p = (char *) malloc(initial_size); + if (p == NULL) return NULL; + a.zbuffer = (uint8 *) buffer; + a.zbuffer_end = (uint8 *) buffer + len; + if (do_zlib(&a, p, initial_size, 1, parse_header)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + free(a.zout_start); + return NULL; + } +} + +int stbi_zlib_decode_buffer(char *obuffer, int olen, char const *ibuffer, int ilen) +{ + zbuf a; + a.zbuffer = (uint8 *) ibuffer; + a.zbuffer_end = (uint8 *) ibuffer + ilen; + if (do_zlib(&a, obuffer, olen, 0, 1)) + return (int) (a.zout - a.zout_start); + else + return -1; +} + +char *stbi_zlib_decode_noheader_malloc(char const *buffer, int len, int *outlen) +{ + zbuf a; + char *p = (char *) malloc(16384); + if (p == NULL) return NULL; + a.zbuffer = (uint8 *) buffer; + a.zbuffer_end = (uint8 *) buffer+len; + if (do_zlib(&a, p, 16384, 1, 0)) { + if (outlen) *outlen = (int) (a.zout - a.zout_start); + return a.zout_start; + } else { + free(a.zout_start); + return NULL; + } +} + +int stbi_zlib_decode_noheader_buffer(char *obuffer, int olen, const char *ibuffer, int ilen) +{ + zbuf a; + a.zbuffer = (uint8 *) ibuffer; + a.zbuffer_end = (uint8 *) ibuffer + ilen; + if (do_zlib(&a, obuffer, olen, 0, 0)) + return (int) (a.zout - a.zout_start); + else + return -1; +} + +// public domain "baseline" PNG decoder v0.10 Sean Barrett 2006-11-18 +// simple implementation +// - only 8-bit samples +// - no CRC checking +// - allocates lots of intermediate memory +// - avoids problem of streaming data between subsystems +// - avoids explicit window management +// performance +// - uses stb_zlib, a PD zlib implementation with fast huffman decoding + + +typedef struct +{ + uint32 length; + uint32 type; +} chunk; + +#define PNG_TYPE(a,b,c,d) (((a) << 24) + ((b) << 16) + ((c) << 8) + (d)) + +static chunk get_chunk_header(stbi *s) +{ + chunk c; + c.length = get32(s); + c.type = get32(s); + return c; +} + +static int check_png_header(stbi *s) +{ + static uint8 png_sig[8] = { 137,80,78,71,13,10,26,10 }; + int i; + for (i=0; i < 8; ++i) + if (get8(s) != png_sig[i]) return e("bad png sig","Not a PNG"); + return 1; +} + +typedef struct +{ + stbi s; + uint8 *idata, *expanded, *out; +} png; + + +enum { + F_none=0, F_sub=1, F_up=2, F_avg=3, F_paeth=4, + F_avg_first, F_paeth_first, +}; + +static uint8 first_row_filter[5] = +{ + F_none, F_sub, F_none, F_avg_first, F_paeth_first +}; + +static int paeth(int a, int b, int c) +{ + int p = a + b - c; + int pa = abs(p-a); + int pb = abs(p-b); + int pc = abs(p-c); + if (pa <= pb && pa <= pc) return a; + if (pb <= pc) return b; + return c; +} + +// create the png data from post-deflated data +static int create_png_image_raw(png *a, uint8 *raw, uint32 raw_len, int out_n, uint32 x, uint32 y) +{ + stbi *s = &a->s; + uint32 i,j,stride = x*out_n; + int k; + int img_n = s->img_n; // copy it into a local for later + assert(out_n == s->img_n || out_n == s->img_n+1); + if (stbi_png_partial) y = 1; + a->out = (uint8 *) malloc(x * y * out_n); + if (!a->out) return e("outofmem", "Out of memory"); + if (!stbi_png_partial) { + if (s->img_x == x && s->img_y == y) { + if (raw_len != (img_n * x + 1) * y) return e("not enough pixels","Corrupt PNG"); + } else { // interlaced: + if (raw_len < (img_n * x + 1) * y) return e("not enough pixels","Corrupt PNG"); + } + } + for (j=0; j < y; ++j) { + uint8 *cur = a->out + stride*j; + uint8 *prior = cur - stride; + int filter = *raw++; + if (filter > 4) return e("invalid filter","Corrupt PNG"); + // if first row, use special filter that doesn't sample previous row + if (j == 0) filter = first_row_filter[filter]; + // handle first pixel explicitly + for (k=0; k < img_n; ++k) { + switch (filter) { + case F_none : cur[k] = raw[k]; break; + case F_sub : cur[k] = raw[k]; break; + case F_up : cur[k] = raw[k] + prior[k]; break; + case F_avg : cur[k] = raw[k] + (prior[k]>>1); break; + case F_paeth : cur[k] = (uint8) (raw[k] + paeth(0,prior[k],0)); break; + case F_avg_first : cur[k] = raw[k]; break; + case F_paeth_first: cur[k] = raw[k]; break; + } + } + if (img_n != out_n) cur[img_n] = 255; + raw += img_n; + cur += out_n; + prior += out_n; + // this is a little gross, so that we don't switch per-pixel or per-component + if (img_n == out_n) { + #define CASE(f) \ + case f: \ + for (i=x-1; i >= 1; --i, raw+=img_n,cur+=img_n,prior+=img_n) \ + for (k=0; k < img_n; ++k) + switch (filter) { + CASE(F_none) cur[k] = raw[k]; break; + CASE(F_sub) cur[k] = raw[k] + cur[k-img_n]; break; + CASE(F_up) cur[k] = raw[k] + prior[k]; break; + CASE(F_avg) cur[k] = raw[k] + ((prior[k] + cur[k-img_n])>>1); break; + CASE(F_paeth) cur[k] = (uint8) (raw[k] + paeth(cur[k-img_n],prior[k],prior[k-img_n])); break; + CASE(F_avg_first) cur[k] = raw[k] + (cur[k-img_n] >> 1); break; + CASE(F_paeth_first) cur[k] = (uint8) (raw[k] + paeth(cur[k-img_n],0,0)); break; + } + #undef CASE + } else { + assert(img_n+1 == out_n); + #define CASE(f) \ + case f: \ + for (i=x-1; i >= 1; --i, cur[img_n]=255,raw+=img_n,cur+=out_n,prior+=out_n) \ + for (k=0; k < img_n; ++k) + switch (filter) { + CASE(F_none) cur[k] = raw[k]; break; + CASE(F_sub) cur[k] = raw[k] + cur[k-out_n]; break; + CASE(F_up) cur[k] = raw[k] + prior[k]; break; + CASE(F_avg) cur[k] = raw[k] + ((prior[k] + cur[k-out_n])>>1); break; + CASE(F_paeth) cur[k] = (uint8) (raw[k] + paeth(cur[k-out_n],prior[k],prior[k-out_n])); break; + CASE(F_avg_first) cur[k] = raw[k] + (cur[k-out_n] >> 1); break; + CASE(F_paeth_first) cur[k] = (uint8) (raw[k] + paeth(cur[k-out_n],0,0)); break; + } + #undef CASE + } + } + return 1; +} + +static int create_png_image(png *a, uint8 *raw, uint32 raw_len, int out_n, int interlaced) +{ + uint8 *final; + int p; + int save; + if (!interlaced) + return create_png_image_raw(a, raw, raw_len, out_n, a->s.img_x, a->s.img_y); + save = stbi_png_partial; + stbi_png_partial = 0; + + // de-interlacing + final = (uint8 *) malloc(a->s.img_x * a->s.img_y * out_n); + for (p=0; p < 7; ++p) { + int xorig[] = { 0,4,0,2,0,1,0 }; + int yorig[] = { 0,0,4,0,2,0,1 }; + int xspc[] = { 8,8,4,4,2,2,1 }; + int yspc[] = { 8,8,8,4,4,2,2 }; + int i,j,x,y; + // pass1_x[4] = 0, pass1_x[5] = 1, pass1_x[12] = 1 + x = (a->s.img_x - xorig[p] + xspc[p]-1) / xspc[p]; + y = (a->s.img_y - yorig[p] + yspc[p]-1) / yspc[p]; + if (x && y) { + if (!create_png_image_raw(a, raw, raw_len, out_n, x, y)) { + free(final); + return 0; + } + for (j=0; j < y; ++j) + for (i=0; i < x; ++i) + memcpy(final + (j*yspc[p]+yorig[p])*a->s.img_x*out_n + (i*xspc[p]+xorig[p])*out_n, + a->out + (j*x+i)*out_n, out_n); + free(a->out); + raw += (x*out_n+1)*y; + raw_len -= (x*out_n+1)*y; + } + } + a->out = final; + + stbi_png_partial = save; + return 1; +} + +static int compute_transparency(png *z, uint8 tc[3], int out_n) +{ + stbi *s = &z->s; + uint32 i, pixel_count = s->img_x * s->img_y; + uint8 *p = z->out; + + // compute color-based transparency, assuming we've + // already got 255 as the alpha value in the output + assert(out_n == 2 || out_n == 4); + + if (out_n == 2) { + for (i=0; i < pixel_count; ++i) { + p[1] = (p[0] == tc[0] ? 0 : 255); + p += 2; + } + } else { + for (i=0; i < pixel_count; ++i) { + if (p[0] == tc[0] && p[1] == tc[1] && p[2] == tc[2]) + p[3] = 0; + p += 4; + } + } + return 1; +} + +static int expand_palette(png *a, uint8 *palette, int len, int pal_img_n) +{ + uint32 i, pixel_count = a->s.img_x * a->s.img_y; + uint8 *p, *temp_out, *orig = a->out; + + p = (uint8 *) malloc(pixel_count * pal_img_n); + if (p == NULL) return e("outofmem", "Out of memory"); + + // between here and free(out) below, exitting would leak + temp_out = p; + + if (pal_img_n == 3) { + for (i=0; i < pixel_count; ++i) { + int n = orig[i]*4; + p[0] = palette[n ]; + p[1] = palette[n+1]; + p[2] = palette[n+2]; + p += 3; + } + } else { + for (i=0; i < pixel_count; ++i) { + int n = orig[i]*4; + p[0] = palette[n ]; + p[1] = palette[n+1]; + p[2] = palette[n+2]; + p[3] = palette[n+3]; + p += 4; + } + } + free(a->out); + a->out = temp_out; + + STBI_NOTUSED(len); + + return 1; +} + +static int stbi_unpremultiply_on_load = 0; +static int stbi_de_iphone_flag = 0; + +void stbi_set_unpremultiply_on_load(int flag_true_if_should_unpremultiply) +{ + stbi_unpremultiply_on_load = flag_true_if_should_unpremultiply; +} +void stbi_convert_iphone_png_to_rgb(int flag_true_if_should_convert) +{ + stbi_de_iphone_flag = flag_true_if_should_convert; +} + +static void stbi_de_iphone(png *z) +{ + stbi *s = &z->s; + uint32 i, pixel_count = s->img_x * s->img_y; + uint8 *p = z->out; + + if (s->img_out_n == 3) { // convert bgr to rgb + for (i=0; i < pixel_count; ++i) { + uint8 t = p[0]; + p[0] = p[2]; + p[2] = t; + p += 3; + } + } else { + assert(s->img_out_n == 4); + if (stbi_unpremultiply_on_load) { + // convert bgr to rgb and unpremultiply + for (i=0; i < pixel_count; ++i) { + uint8 a = p[3]; + uint8 t = p[0]; + if (a) { + p[0] = p[2] * 255 / a; + p[1] = p[1] * 255 / a; + p[2] = t * 255 / a; + } else { + p[0] = p[2]; + p[2] = t; + } + p += 4; + } + } else { + // convert bgr to rgb + for (i=0; i < pixel_count; ++i) { + uint8 t = p[0]; + p[0] = p[2]; + p[2] = t; + p += 4; + } + } + } +} + +static int parse_png_file(png *z, int scan, int req_comp) +{ + uint8 palette[1024], pal_img_n=0; + uint8 has_trans=0, tc[3]; + uint32 ioff=0, idata_limit=0, i, pal_len=0; + int first=1,k,interlace=0, iphone=0; + stbi *s = &z->s; + + if (!check_png_header(s)) return 0; + + if (scan == SCAN_type) return 1; + + for (;;) { + chunk c = get_chunk_header(s); + switch (c.type) { + case PNG_TYPE('C','g','B','I'): + iphone = stbi_de_iphone_flag; + skip(s, c.length); + break; + case PNG_TYPE('I','H','D','R'): { + int depth,color,comp,filter; + if (!first) return e("multiple IHDR","Corrupt PNG"); + first = 0; + if (c.length != 13) return e("bad IHDR len","Corrupt PNG"); + s->img_x = get32(s); if (s->img_x > (1 << 24)) return e("too large","Very large image (corrupt?)"); + s->img_y = get32(s); if (s->img_y > (1 << 24)) return e("too large","Very large image (corrupt?)"); + depth = get8(s); if (depth != 8) return e("8bit only","PNG not supported: 8-bit only"); + color = get8(s); if (color > 6) return e("bad ctype","Corrupt PNG"); + if (color == 3) pal_img_n = 3; else if (color & 1) return e("bad ctype","Corrupt PNG"); + comp = get8(s); if (comp) return e("bad comp method","Corrupt PNG"); + filter= get8(s); if (filter) return e("bad filter method","Corrupt PNG"); + interlace = get8(s); if (interlace>1) return e("bad interlace method","Corrupt PNG"); + if (!s->img_x || !s->img_y) return e("0-pixel image","Corrupt PNG"); + if (!pal_img_n) { + s->img_n = (color & 2 ? 3 : 1) + (color & 4 ? 1 : 0); + if ((1 << 30) / s->img_x / s->img_n < s->img_y) return e("too large", "Image too large to decode"); + if (scan == SCAN_header) return 1; + } else { + // if paletted, then pal_n is our final components, and + // img_n is # components to decompress/filter. + s->img_n = 1; + if ((1 << 30) / s->img_x / 4 < s->img_y) return e("too large","Corrupt PNG"); + // if SCAN_header, have to scan to see if we have a tRNS + } + break; + } + + case PNG_TYPE('P','L','T','E'): { + if (first) return e("first not IHDR", "Corrupt PNG"); + if (c.length > 256*3) return e("invalid PLTE","Corrupt PNG"); + pal_len = c.length / 3; + if (pal_len * 3 != c.length) return e("invalid PLTE","Corrupt PNG"); + for (i=0; i < pal_len; ++i) { + palette[i*4+0] = get8u(s); + palette[i*4+1] = get8u(s); + palette[i*4+2] = get8u(s); + palette[i*4+3] = 255; + } + break; + } + + case PNG_TYPE('t','R','N','S'): { + if (first) return e("first not IHDR", "Corrupt PNG"); + if (z->idata) return e("tRNS after IDAT","Corrupt PNG"); + if (pal_img_n) { + if (scan == SCAN_header) { s->img_n = 4; return 1; } + if (pal_len == 0) return e("tRNS before PLTE","Corrupt PNG"); + if (c.length > pal_len) return e("bad tRNS len","Corrupt PNG"); + pal_img_n = 4; + for (i=0; i < c.length; ++i) + palette[i*4+3] = get8u(s); + } else { + if (!(s->img_n & 1)) return e("tRNS with alpha","Corrupt PNG"); + if (c.length != (uint32) s->img_n*2) return e("bad tRNS len","Corrupt PNG"); + has_trans = 1; + for (k=0; k < s->img_n; ++k) + tc[k] = (uint8) get16(s); // non 8-bit images will be larger + } + break; + } + + case PNG_TYPE('I','D','A','T'): { + if (first) return e("first not IHDR", "Corrupt PNG"); + if (pal_img_n && !pal_len) return e("no PLTE","Corrupt PNG"); + if (scan == SCAN_header) { s->img_n = pal_img_n; return 1; } + if (ioff + c.length > idata_limit) { + uint8 *p; + if (idata_limit == 0) idata_limit = c.length > 4096 ? c.length : 4096; + while (ioff + c.length > idata_limit) + idata_limit *= 2; + p = (uint8 *) realloc(z->idata, idata_limit); if (p == NULL) return e("outofmem", "Out of memory"); + z->idata = p; + } + if (!getn(s, z->idata+ioff,c.length)) return e("outofdata","Corrupt PNG"); + ioff += c.length; + break; + } + + case PNG_TYPE('I','E','N','D'): { + uint32 raw_len; + if (first) return e("first not IHDR", "Corrupt PNG"); + if (scan != SCAN_load) return 1; + if (z->idata == NULL) return e("no IDAT","Corrupt PNG"); + z->expanded = (uint8 *) stbi_zlib_decode_malloc_guesssize_headerflag((char *) z->idata, ioff, 16384, (int *) &raw_len, !iphone); + if (z->expanded == NULL) return 0; // zlib should set error + free(z->idata); z->idata = NULL; + if ((req_comp == s->img_n+1 && req_comp != 3 && !pal_img_n) || has_trans) + s->img_out_n = s->img_n+1; + else + s->img_out_n = s->img_n; + if (!create_png_image(z, z->expanded, raw_len, s->img_out_n, interlace)) return 0; + if (has_trans) + if (!compute_transparency(z, tc, s->img_out_n)) return 0; + if (iphone && s->img_out_n > 2) + stbi_de_iphone(z); + if (pal_img_n) { + // pal_img_n == 3 or 4 + s->img_n = pal_img_n; // record the actual colors we had + s->img_out_n = pal_img_n; + if (req_comp >= 3) s->img_out_n = req_comp; + if (!expand_palette(z, palette, pal_len, s->img_out_n)) + return 0; + } + free(z->expanded); z->expanded = NULL; + return 1; + } + + default: + // if critical, fail + if (first) return e("first not IHDR", "Corrupt PNG"); + if ((c.type & (1 << 29)) == 0) { + #ifndef STBI_NO_FAILURE_STRINGS + // not threadsafe + static char invalid_chunk[] = "XXXX chunk not known"; + invalid_chunk[0] = (uint8) (c.type >> 24); + invalid_chunk[1] = (uint8) (c.type >> 16); + invalid_chunk[2] = (uint8) (c.type >> 8); + invalid_chunk[3] = (uint8) (c.type >> 0); + #endif + return e(invalid_chunk, "PNG not supported: unknown chunk type"); + } + skip(s, c.length); + break; + } + // end of chunk, read and skip CRC + get32(s); + } +} + +static unsigned char *do_png(png *p, int *x, int *y, int *n, int req_comp) +{ + unsigned char *result=NULL; + p->expanded = NULL; + p->idata = NULL; + p->out = NULL; + if (req_comp < 0 || req_comp > 4) return epuc("bad req_comp", "Internal error"); + if (parse_png_file(p, SCAN_load, req_comp)) { + result = p->out; + p->out = NULL; + if (req_comp && req_comp != p->s.img_out_n) { + result = convert_format(result, p->s.img_out_n, req_comp, p->s.img_x, p->s.img_y); + p->s.img_out_n = req_comp; + if (result == NULL) return result; + } + *x = p->s.img_x; + *y = p->s.img_y; + if (n) *n = p->s.img_n; + } + free(p->out); p->out = NULL; + free(p->expanded); p->expanded = NULL; + free(p->idata); p->idata = NULL; + + return result; +} + +#ifndef STBI_NO_STDIO +unsigned char *stbi_png_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + png p; + start_file(&p.s, f); + return do_png(&p, x,y,comp,req_comp); +} + +unsigned char *stbi_png_load(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + unsigned char *data; + FILE *f = fopen(filename, "rb"); + if (!f) return NULL; + data = stbi_png_load_from_file(f,x,y,comp,req_comp); + fclose(f); + return data; +} +#endif + +unsigned char *stbi_png_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + png p; + start_mem(&p.s, buffer,len); + return do_png(&p, x,y,comp,req_comp); +} + +#ifndef STBI_NO_STDIO +int stbi_png_test_file(FILE *f) +{ + png p; + int n,r; + n = ftell(f); + start_file(&p.s, f); + r = parse_png_file(&p, SCAN_type,STBI_default); + fseek(f,n,SEEK_SET); + return r; +} +#endif + +int stbi_png_test_memory(stbi_uc const *buffer, int len) +{ + png p; + start_mem(&p.s, buffer, len); + return parse_png_file(&p, SCAN_type,STBI_default); +} + +static int stbi_png_info_raw(png *p, int *x, int *y, int *comp) +{ + if (!parse_png_file(p, SCAN_header, 0)) + return 0; + if (x) *x = p->s.img_x; + if (y) *y = p->s.img_y; + if (comp) *comp = p->s.img_n; + return 1; +} + +#ifndef STBI_NO_STDIO +int stbi_png_info (char const *filename, int *x, int *y, int *comp) +{ + int res; + FILE *f = fopen(filename, "rb"); + if (!f) return 0; + res = stbi_png_info_from_file(f, x, y, comp); + fclose(f); + return res; +} + +int stbi_png_info_from_file(FILE *f, int *x, int *y, int *comp) +{ + png p; + int res; + long n = ftell(f); + start_file(&p.s, f); + res = stbi_png_info_raw(&p, x, y, comp); + fseek(f, n, SEEK_SET); + return res; +} +#endif // !STBI_NO_STDIO + +int stbi_png_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp) +{ + png p; + start_mem(&p.s, buffer, len); + return stbi_png_info_raw(&p, x, y, comp); +} + +// Microsoft/Windows BMP image + +static int bmp_test(stbi *s) +{ + int sz; + if (get8(s) != 'B') return 0; + if (get8(s) != 'M') return 0; + get32le(s); // discard filesize + get16le(s); // discard reserved + get16le(s); // discard reserved + get32le(s); // discard data offset + sz = get32le(s); + if (sz == 12 || sz == 40 || sz == 56 || sz == 108) return 1; + return 0; +} + +#ifndef STBI_NO_STDIO +int stbi_bmp_test_file (FILE *f) +{ + stbi s; + int r,n = ftell(f); + start_file(&s,f); + r = bmp_test(&s); + fseek(f,n,SEEK_SET); + return r; +} +#endif + +int stbi_bmp_test_memory (stbi_uc const *buffer, int len) +{ + stbi s; + start_mem(&s, buffer, len); + return bmp_test(&s); +} + +// returns 0..31 for the highest set bit +static int high_bit(unsigned int z) +{ + int n=0; + if (z == 0) return -1; + if (z >= 0x10000) n += 16, z >>= 16; + if (z >= 0x00100) n += 8, z >>= 8; + if (z >= 0x00010) n += 4, z >>= 4; + if (z >= 0x00004) n += 2, z >>= 2; + if (z >= 0x00002) n += 1, z >>= 1; + return n; +} + +static int bitcount(unsigned int a) +{ + a = (a & 0x55555555) + ((a >> 1) & 0x55555555); // max 2 + a = (a & 0x33333333) + ((a >> 2) & 0x33333333); // max 4 + a = (a + (a >> 4)) & 0x0f0f0f0f; // max 8 per 4, now 8 bits + a = (a + (a >> 8)); // max 16 per 8 bits + a = (a + (a >> 16)); // max 32 per 8 bits + return a & 0xff; +} + +static int shiftsigned(int v, int shift, int bits) +{ + int result; + int z=0; + + if (shift < 0) v <<= -shift; + else v >>= shift; + result = v; + + z = bits; + while (z < 8) { + result += v >> z; + z += bits; + } + return result; +} + +static stbi_uc *bmp_load(stbi *s, int *x, int *y, int *comp, int req_comp) +{ + uint8 *out; + unsigned int mr=0,mg=0,mb=0,ma=0, fake_a=0; + stbi_uc pal[256][4]; + int psize=0,i,j,compress=0,width; + int bpp, flip_vertically, pad, target, offset, hsz; + if (get8(s) != 'B' || get8(s) != 'M') return epuc("not BMP", "Corrupt BMP"); + get32le(s); // discard filesize + get16le(s); // discard reserved + get16le(s); // discard reserved + offset = get32le(s); + hsz = get32le(s); + if (hsz != 12 && hsz != 40 && hsz != 56 && hsz != 108) return epuc("unknown BMP", "BMP type not supported: unknown"); + if (hsz == 12) { + s->img_x = get16le(s); + s->img_y = get16le(s); + } else { + s->img_x = get32le(s); + s->img_y = get32le(s); + } + if (get16le(s) != 1) return epuc("bad BMP", "bad BMP"); + bpp = get16le(s); + if (bpp == 1) return epuc("monochrome", "BMP type not supported: 1-bit"); + flip_vertically = ((int) s->img_y) > 0; + s->img_y = abs((int) s->img_y); + if (hsz == 12) { + if (bpp < 24) + psize = (offset - 14 - 24) / 3; + } else { + compress = get32le(s); + if (compress == 1 || compress == 2) return epuc("BMP RLE", "BMP type not supported: RLE"); + get32le(s); // discard sizeof + get32le(s); // discard hres + get32le(s); // discard vres + get32le(s); // discard colorsused + get32le(s); // discard max important + if (hsz == 40 || hsz == 56) { + if (hsz == 56) { + get32le(s); + get32le(s); + get32le(s); + get32le(s); + } + if (bpp == 16 || bpp == 32) { + mr = mg = mb = 0; + if (compress == 0) { + if (bpp == 32) { + mr = 0xffu << 16; + mg = 0xffu << 8; + mb = 0xffu << 0; + ma = 0xffu << 24; + fake_a = 1; // @TODO: check for cases like alpha value is all 0 and switch it to 255 + } else { + mr = 31u << 10; + mg = 31u << 5; + mb = 31u << 0; + } + } else if (compress == 3) { + mr = get32le(s); + mg = get32le(s); + mb = get32le(s); + // not documented, but generated by photoshop and handled by mspaint + if (mr == mg && mg == mb) { + // ?!?!? + return epuc("bad BMP", "bad BMP"); + } + } else + return epuc("bad BMP", "bad BMP"); + } + } else { + assert(hsz == 108); + mr = get32le(s); + mg = get32le(s); + mb = get32le(s); + ma = get32le(s); + get32le(s); // discard color space + for (i=0; i < 12; ++i) + get32le(s); // discard color space parameters + } + if (bpp < 16) + psize = (offset - 14 - hsz) >> 2; + } + s->img_n = ma ? 4 : 3; + if (req_comp && req_comp >= 3) // we can directly decode 3 or 4 + target = req_comp; + else + target = s->img_n; // if they want monochrome, we'll post-convert + out = (stbi_uc *) malloc(target * s->img_x * s->img_y); + if (!out) return epuc("outofmem", "Out of memory"); + if (bpp < 16) { + int z=0; + if (psize == 0 || psize > 256) { free(out); return epuc("invalid", "Corrupt BMP"); } + for (i=0; i < psize; ++i) { + pal[i][2] = get8u(s); + pal[i][1] = get8u(s); + pal[i][0] = get8u(s); + if (hsz != 12) get8(s); + pal[i][3] = 255; + } + skip(s, offset - 14 - hsz - psize * (hsz == 12 ? 3 : 4)); + if (bpp == 4) width = (s->img_x + 1) >> 1; + else if (bpp == 8) width = s->img_x; + else { free(out); return epuc("bad bpp", "Corrupt BMP"); } + pad = (-width)&3; + for (j=0; j < (int) s->img_y; ++j) { + for (i=0; i < (int) s->img_x; i += 2) { + int v=get8(s),v2=0; + if (bpp == 4) { + v2 = v & 15; + v >>= 4; + } + out[z++] = pal[v][0]; + out[z++] = pal[v][1]; + out[z++] = pal[v][2]; + if (target == 4) out[z++] = 255; + if (i+1 == (int) s->img_x) break; + v = (bpp == 8) ? get8(s) : v2; + out[z++] = pal[v][0]; + out[z++] = pal[v][1]; + out[z++] = pal[v][2]; + if (target == 4) out[z++] = 255; + } + skip(s, pad); + } + } else { + int rshift=0,gshift=0,bshift=0,ashift=0,rcount=0,gcount=0,bcount=0,acount=0; + int z = 0; + int easy=0; + skip(s, offset - 14 - hsz); + if (bpp == 24) width = 3 * s->img_x; + else if (bpp == 16) width = 2*s->img_x; + else /* bpp = 32 and pad = 0 */ width=0; + pad = (-width) & 3; + if (bpp == 24) { + easy = 1; + } else if (bpp == 32) { + if (mb == 0xff && mg == 0xff00 && mr == 0xff000000 && ma == 0xff000000) + easy = 2; + } + if (!easy) { + if (!mr || !mg || !mb) return epuc("bad masks", "Corrupt BMP"); + // right shift amt to put high bit in position #7 + rshift = high_bit(mr)-7; rcount = bitcount(mr); + gshift = high_bit(mg)-7; gcount = bitcount(mr); + bshift = high_bit(mb)-7; bcount = bitcount(mr); + ashift = high_bit(ma)-7; acount = bitcount(mr); + } + for (j=0; j < (int) s->img_y; ++j) { + if (easy) { + for (i=0; i < (int) s->img_x; ++i) { + int a; + out[z+2] = get8u(s); + out[z+1] = get8u(s); + out[z+0] = get8u(s); + z += 3; + a = (easy == 2 ? get8(s) : 255); + if (target == 4) out[z++] = (uint8) a; + } + } else { + for (i=0; i < (int) s->img_x; ++i) { + uint32 v = (bpp == 16 ? get16le(s) : get32le(s)); + int a; + out[z++] = (uint8) shiftsigned(v & mr, rshift, rcount); + out[z++] = (uint8) shiftsigned(v & mg, gshift, gcount); + out[z++] = (uint8) shiftsigned(v & mb, bshift, bcount); + a = (ma ? shiftsigned(v & ma, ashift, acount) : 255); + if (target == 4) out[z++] = (uint8) a; + } + } + skip(s, pad); + } + } + if (flip_vertically) { + stbi_uc t; + for (j=0; j < (int) s->img_y>>1; ++j) { + stbi_uc *p1 = out + j *s->img_x*target; + stbi_uc *p2 = out + (s->img_y-1-j)*s->img_x*target; + for (i=0; i < (int) s->img_x*target; ++i) { + t = p1[i], p1[i] = p2[i], p2[i] = t; + } + } + } + + if (req_comp && req_comp != target) { + out = convert_format(out, target, req_comp, s->img_x, s->img_y); + if (out == NULL) return out; // convert_format frees input on failure + } + + *x = s->img_x; + *y = s->img_y; + if (comp) *comp = target; + return out; +} + +#ifndef STBI_NO_STDIO +stbi_uc *stbi_bmp_load (char const *filename, int *x, int *y, int *comp, int req_comp) +{ + stbi_uc *data; + FILE *f = fopen(filename, "rb"); + if (!f) return NULL; + data = stbi_bmp_load_from_file(f, x,y,comp,req_comp); + fclose(f); + return data; +} + +stbi_uc *stbi_bmp_load_from_file (FILE *f, int *x, int *y, int *comp, int req_comp) +{ + stbi s; + start_file(&s, f); + return bmp_load(&s, x,y,comp,req_comp); +} +#endif + +stbi_uc *stbi_bmp_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + stbi s; + start_mem(&s, buffer, len); + return bmp_load(&s, x,y,comp,req_comp); +} + +// Targa Truevision - TGA +// by Jonathan Dummer + +static int tga_info(stbi *s, int *x, int *y, int *comp) +{ + int tga_w, tga_h, tga_comp; + int sz; + get8u(s); // discard Offset + sz = get8u(s); // color type + if( sz > 1 ) return 0; // only RGB or indexed allowed + sz = get8u(s); // image type + // only RGB or grey allowed, +/- RLE + if ((sz != 1) && (sz != 2) && (sz != 3) && (sz != 9) && (sz != 10) && (sz != 11)) return 0; + get16le(s); // discard palette start + get16le(s); // discard palette length + get8(s); // discard bits per palette color entry + get16le(s); // discard x origin + get16le(s); // discard y origin + tga_w = get16le(s); + if( tga_w < 1 ) return 0; // test width + tga_h = get16le(s); + if( tga_h < 1 ) return 0; // test height + sz = get8(s); // bits per pixel + // only RGB or RGBA or grey allowed + if ((sz != 8) && (sz != 16) && (sz != 24) && (sz != 32)) return 0; + tga_comp = sz; + if (x) *x = tga_w; + if (y) *y = tga_h; + if (comp) *comp = tga_comp / 8; + return 1; // seems to have passed everything +} + +int stbi_tga_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp) +{ + stbi s; + start_mem(&s, buffer, len); + return tga_info(&s, x, y, comp); +} + +static int tga_test(stbi *s) +{ + int sz; + get8u(s); // discard Offset + sz = get8u(s); // color type + if ( sz > 1 ) return 0; // only RGB or indexed allowed + sz = get8u(s); // image type + if ( (sz != 1) && (sz != 2) && (sz != 3) && (sz != 9) && (sz != 10) && (sz != 11) ) return 0; // only RGB or grey allowed, +/- RLE + get16(s); // discard palette start + get16(s); // discard palette length + get8(s); // discard bits per palette color entry + get16(s); // discard x origin + get16(s); // discard y origin + if ( get16(s) < 1 ) return 0; // test width + if ( get16(s) < 1 ) return 0; // test height + sz = get8(s); // bits per pixel + if ( (sz != 8) && (sz != 16) && (sz != 24) && (sz != 32) ) return 0; // only RGB or RGBA or grey allowed + return 1; // seems to have passed everything +} + +#ifndef STBI_NO_STDIO +int stbi_tga_info_from_file(FILE *f, int *x, int *y, int *comp) +{ + stbi s; + int r; + long n = ftell(f); + start_file(&s, f); + r = tga_info(&s, x, y, comp); + fseek(f, n, SEEK_SET); + return r; +} + +int stbi_tga_test_file (FILE *f) +{ + stbi s; + int r,n = ftell(f); + start_file(&s, f); + r = tga_test(&s); + fseek(f,n,SEEK_SET); + return r; +} +#endif + +int stbi_tga_test_memory (stbi_uc const *buffer, int len) +{ + stbi s; + start_mem(&s, buffer, len); + return tga_test(&s); +} + +static stbi_uc *tga_load(stbi *s, int *x, int *y, int *comp, int req_comp) +{ + // read in the TGA header stuff + int tga_offset = get8u(s); + int tga_indexed = get8u(s); + int tga_image_type = get8u(s); + int tga_is_RLE = 0; + int tga_palette_start = get16le(s); + int tga_palette_len = get16le(s); + int tga_palette_bits = get8u(s); + int tga_x_origin = get16le(s); + int tga_y_origin = get16le(s); + int tga_width = get16le(s); + int tga_height = get16le(s); + int tga_bits_per_pixel = get8u(s); + int tga_inverted = get8u(s); + // image data + unsigned char *tga_data; + unsigned char *tga_palette = NULL; + int i, j; + unsigned char raw_data[4]; + unsigned char trans_data[4]; + int RLE_count = 0; + int RLE_repeating = 0; + int read_next_pixel = 1; + + // do a tiny bit of precessing + if ( tga_image_type >= 8 ) + { + tga_image_type -= 8; + tga_is_RLE = 1; + } + /* int tga_alpha_bits = tga_inverted & 15; */ + tga_inverted = 1 - ((tga_inverted >> 5) & 1); + + // error check + if ( //(tga_indexed) || + (tga_width < 1) || (tga_height < 1) || + (tga_image_type < 1) || (tga_image_type > 3) || + ((tga_bits_per_pixel != 8) && (tga_bits_per_pixel != 16) && + (tga_bits_per_pixel != 24) && (tga_bits_per_pixel != 32)) + ) + { + return NULL; + } + + // If I'm paletted, then I'll use the number of bits from the palette + if ( tga_indexed ) + { + tga_bits_per_pixel = tga_palette_bits; + } + + // tga info + *x = tga_width; + *y = tga_height; + if ( (req_comp < 1) || (req_comp > 4) ) + { + // just use whatever the file was + req_comp = tga_bits_per_pixel / 8; + *comp = req_comp; + } else + { + // force a new number of components + *comp = tga_bits_per_pixel/8; + } + tga_data = (unsigned char*)malloc( tga_width * tga_height * req_comp ); + + // skip to the data's starting position (offset usually = 0) + skip(s, tga_offset ); + // do I need to load a palette? + if ( tga_indexed ) + { + // any data to skip? (offset usually = 0) + skip(s, tga_palette_start ); + // load the palette + tga_palette = (unsigned char*)malloc( tga_palette_len * tga_palette_bits / 8 ); + if (!getn(s, tga_palette, tga_palette_len * tga_palette_bits / 8 )) + return NULL; + } + // load the data + trans_data[0] = trans_data[1] = trans_data[2] = trans_data[3] = 0; + for (i=0; i < tga_width * tga_height; ++i) + { + // if I'm in RLE mode, do I need to get a RLE chunk? + if ( tga_is_RLE ) + { + if ( RLE_count == 0 ) + { + // yep, get the next byte as a RLE command + int RLE_cmd = get8u(s); + RLE_count = 1 + (RLE_cmd & 127); + RLE_repeating = RLE_cmd >> 7; + read_next_pixel = 1; + } else if ( !RLE_repeating ) + { + read_next_pixel = 1; + } + } else + { + read_next_pixel = 1; + } + // OK, if I need to read a pixel, do it now + if ( read_next_pixel ) + { + // load however much data we did have + if ( tga_indexed ) + { + // read in 1 byte, then perform the lookup + int pal_idx = get8u(s); + if ( pal_idx >= tga_palette_len ) + { + // invalid index + pal_idx = 0; + } + pal_idx *= tga_bits_per_pixel / 8; + for (j = 0; j*8 < tga_bits_per_pixel; ++j) + { + raw_data[j] = tga_palette[pal_idx+j]; + } + } else + { + // read in the data raw + for (j = 0; j*8 < tga_bits_per_pixel; ++j) + { + raw_data[j] = get8u(s); + } + } + // convert raw to the intermediate format + switch (tga_bits_per_pixel) + { + case 8: + // Luminous => RGBA + trans_data[0] = raw_data[0]; + trans_data[1] = raw_data[0]; + trans_data[2] = raw_data[0]; + trans_data[3] = 255; + break; + case 16: + // Luminous,Alpha => RGBA + trans_data[0] = raw_data[0]; + trans_data[1] = raw_data[0]; + trans_data[2] = raw_data[0]; + trans_data[3] = raw_data[1]; + break; + case 24: + // BGR => RGBA + trans_data[0] = raw_data[2]; + trans_data[1] = raw_data[1]; + trans_data[2] = raw_data[0]; + trans_data[3] = 255; + break; + case 32: + // BGRA => RGBA + trans_data[0] = raw_data[2]; + trans_data[1] = raw_data[1]; + trans_data[2] = raw_data[0]; + trans_data[3] = raw_data[3]; + break; + } + // clear the reading flag for the next pixel + read_next_pixel = 0; + } // end of reading a pixel + // convert to final format + switch (req_comp) + { + case 1: + // RGBA => Luminance + tga_data[i*req_comp+0] = compute_y(trans_data[0],trans_data[1],trans_data[2]); + break; + case 2: + // RGBA => Luminance,Alpha + tga_data[i*req_comp+0] = compute_y(trans_data[0],trans_data[1],trans_data[2]); + tga_data[i*req_comp+1] = trans_data[3]; + break; + case 3: + // RGBA => RGB + tga_data[i*req_comp+0] = trans_data[0]; + tga_data[i*req_comp+1] = trans_data[1]; + tga_data[i*req_comp+2] = trans_data[2]; + break; + case 4: + // RGBA => RGBA + tga_data[i*req_comp+0] = trans_data[0]; + tga_data[i*req_comp+1] = trans_data[1]; + tga_data[i*req_comp+2] = trans_data[2]; + tga_data[i*req_comp+3] = trans_data[3]; + break; + } + // in case we're in RLE mode, keep counting down + --RLE_count; + } + // do I need to invert the image? + if ( tga_inverted ) + { + for (j = 0; j*2 < tga_height; ++j) + { + int index1 = j * tga_width * req_comp; + int index2 = (tga_height - 1 - j) * tga_width * req_comp; + for (i = tga_width * req_comp; i > 0; --i) + { + unsigned char temp = tga_data[index1]; + tga_data[index1] = tga_data[index2]; + tga_data[index2] = temp; + ++index1; + ++index2; + } + } + } + // clear my palette, if I had one + if ( tga_palette != NULL ) + { + free( tga_palette ); + } + // the things I do to get rid of an error message, and yet keep + // Microsoft's C compilers happy... [8^( + tga_palette_start = tga_palette_len = tga_palette_bits = + tga_x_origin = tga_y_origin = 0; + // OK, done + return tga_data; +} + +#ifndef STBI_NO_STDIO +stbi_uc *stbi_tga_load (char const *filename, int *x, int *y, int *comp, int req_comp) +{ + stbi_uc *data; + FILE *f = fopen(filename, "rb"); + if (!f) return NULL; + data = stbi_tga_load_from_file(f, x,y,comp,req_comp); + fclose(f); + return data; +} + +stbi_uc *stbi_tga_load_from_file (FILE *f, int *x, int *y, int *comp, int req_comp) +{ + stbi s; + start_file(&s, f); + return tga_load(&s, x,y,comp,req_comp); +} +#endif + +stbi_uc *stbi_tga_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + stbi s; + start_mem(&s, buffer, len); + return tga_load(&s, x,y,comp,req_comp); +} + + +// ************************************************************************************************* +// Photoshop PSD loader -- PD by Thatcher Ulrich, integration by Nicolas Schulz, tweaked by STB + +static int psd_test(stbi *s) +{ + if (get32(s) != 0x38425053) return 0; // "8BPS" + else return 1; +} + +#ifndef STBI_NO_STDIO +int stbi_psd_test_file(FILE *f) +{ + stbi s; + int r,n = ftell(f); + start_file(&s, f); + r = psd_test(&s); + fseek(f,n,SEEK_SET); + return r; +} +#endif + +int stbi_psd_test_memory(stbi_uc const *buffer, int len) +{ + stbi s; + start_mem(&s, buffer, len); + return psd_test(&s); +} + +static stbi_uc *psd_load(stbi *s, int *x, int *y, int *comp, int req_comp) +{ + int pixelCount; + int channelCount, compression; + int channel, i, count, len; + int w,h; + uint8 *out; + + // Check identifier + if (get32(s) != 0x38425053) // "8BPS" + return epuc("not PSD", "Corrupt PSD image"); + + // Check file type version. + if (get16(s) != 1) + return epuc("wrong version", "Unsupported version of PSD image"); + + // Skip 6 reserved bytes. + skip(s, 6 ); + + // Read the number of channels (R, G, B, A, etc). + channelCount = get16(s); + if (channelCount < 0 || channelCount > 16) + return epuc("wrong channel count", "Unsupported number of channels in PSD image"); + + // Read the rows and columns of the image. + h = get32(s); + w = get32(s); + + // Make sure the depth is 8 bits. + if (get16(s) != 8) + return epuc("unsupported bit depth", "PSD bit depth is not 8 bit"); + + // Make sure the color mode is RGB. + // Valid options are: + // 0: Bitmap + // 1: Grayscale + // 2: Indexed color + // 3: RGB color + // 4: CMYK color + // 7: Multichannel + // 8: Duotone + // 9: Lab color + if (get16(s) != 3) + return epuc("wrong color format", "PSD is not in RGB color format"); + + // Skip the Mode Data. (It's the palette for indexed color; other info for other modes.) + skip(s,get32(s) ); + + // Skip the image resources. (resolution, pen tool paths, etc) + skip(s, get32(s) ); + + // Skip the reserved data. + skip(s, get32(s) ); + + // Find out if the data is compressed. + // Known values: + // 0: no compression + // 1: RLE compressed + compression = get16(s); + if (compression > 1) + return epuc("bad compression", "PSD has an unknown compression format"); + + // Create the destination image. + out = (stbi_uc *) malloc(4 * w*h); + if (!out) return epuc("outofmem", "Out of memory"); + pixelCount = w*h; + + // Initialize the data to zero. + //memset( out, 0, pixelCount * 4 ); + + // Finally, the image data. + if (compression) { + // RLE as used by .PSD and .TIFF + // Loop until you get the number of unpacked bytes you are expecting: + // Read the next source byte into n. + // If n is between 0 and 127 inclusive, copy the next n+1 bytes literally. + // Else if n is between -127 and -1 inclusive, copy the next byte -n+1 times. + // Else if n is 128, noop. + // Endloop + + // The RLE-compressed data is preceeded by a 2-byte data count for each row in the data, + // which we're going to just skip. + skip(s, h * channelCount * 2 ); + + // Read the RLE data by channel. + for (channel = 0; channel < 4; channel++) { + uint8 *p; + + p = out+channel; + if (channel >= channelCount) { + // Fill this channel with default data. + for (i = 0; i < pixelCount; i++) *p = (channel == 3 ? 255 : 0), p += 4; + } else { + // Read the RLE data. + count = 0; + while (count < pixelCount) { + len = get8(s); + if (len == 128) { + // No-op. + } else if (len < 128) { + // Copy next len+1 bytes literally. + len++; + count += len; + while (len) { + *p = get8u(s); + p += 4; + len--; + } + } else if (len > 128) { + uint8 val; + // Next -len+1 bytes in the dest are replicated from next source byte. + // (Interpret len as a negative 8-bit int.) + len ^= 0x0FF; + len += 2; + val = get8u(s); + count += len; + while (len) { + *p = val; + p += 4; + len--; + } + } + } + } + } + + } else { + // We're at the raw image data. It's each channel in order (Red, Green, Blue, Alpha, ...) + // where each channel consists of an 8-bit value for each pixel in the image. + + // Read the data by channel. + for (channel = 0; channel < 4; channel++) { + uint8 *p; + + p = out + channel; + if (channel > channelCount) { + // Fill this channel with default data. + for (i = 0; i < pixelCount; i++) *p = channel == 3 ? 255 : 0, p += 4; + } else { + // Read the data. + for (i = 0; i < pixelCount; i++) + *p = get8u(s), p += 4; + } + } + } + + if (req_comp && req_comp != 4) { + out = convert_format(out, 4, req_comp, w, h); + if (out == NULL) return out; // convert_format frees input on failure + } + + if (comp) *comp = channelCount; + *y = h; + *x = w; + + return out; +} + +#ifndef STBI_NO_STDIO +stbi_uc *stbi_psd_load(char const *filename, int *x, int *y, int *comp, int req_comp) +{ + stbi_uc *data; + FILE *f = fopen(filename, "rb"); + if (!f) return NULL; + data = stbi_psd_load_from_file(f, x,y,comp,req_comp); + fclose(f); + return data; +} + +stbi_uc *stbi_psd_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + stbi s; + start_file(&s, f); + return psd_load(&s, x,y,comp,req_comp); +} +#endif + +stbi_uc *stbi_psd_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + stbi s; + start_mem(&s, buffer, len); + return psd_load(&s, x,y,comp,req_comp); +} + +// ************************************************************************************************* +// Softimage PIC loader +// by Tom Seddon +// +// See http://softimage.wiki.softimage.com/index.php/INFO:_PIC_file_format +// See http://ozviz.wasp.uwa.edu.au/~pbourke/dataformats/softimagepic/ + +static int pic_is4(stbi *s,const char *str) +{ + int i; + for (i=0; i<4; ++i) + if (get8(s) != (stbi_uc)str[i]) + return 0; + + return 1; +} + +static int pic_test(stbi *s) +{ + int i; + + if (!pic_is4(s,"\x53\x80\xF6\x34")) + return 0; + + for(i=0;i<84;++i) + get8(s); + + if (!pic_is4(s,"PICT")) + return 0; + + return 1; +} + +typedef struct +{ + stbi_uc size,type,channel; +} pic_packet_t; + +static stbi_uc *pic_readval(stbi *s, int channel, stbi_uc *dest) +{ + int mask=0x80, i; + + for (i=0; i<4; ++i, mask>>=1) { + if (channel & mask) { + if (at_eof(s)) return epuc("bad file","PIC file too short"); + dest[i]=get8u(s); + } + } + + return dest; +} + +static void pic_copyval(int channel,stbi_uc *dest,const stbi_uc *src) +{ + int mask=0x80,i; + + for (i=0;i<4; ++i, mask>>=1) + if (channel&mask) + dest[i]=src[i]; +} + +static stbi_uc *pic_load2(stbi *s,int width,int height,int *comp, stbi_uc *result) +{ + int act_comp=0,num_packets=0,y,chained; + pic_packet_t packets[10]; + + // this will (should...) cater for even some bizarre stuff like having data + // for the same channel in multiple packets. + do { + pic_packet_t *packet; + + if (num_packets==sizeof(packets)/sizeof(packets[0])) + return epuc("bad format","too many packets"); + + packet = &packets[num_packets++]; + + chained = get8(s); + packet->size = get8u(s); + packet->type = get8u(s); + packet->channel = get8u(s); + + act_comp |= packet->channel; + + if (at_eof(s)) return epuc("bad file","file too short (reading packets)"); + if (packet->size != 8) return epuc("bad format","packet isn't 8bpp"); + } while (chained); + + *comp = (act_comp & 0x10 ? 4 : 3); // has alpha channel? + + for(y=0; ytype) { + default: + return epuc("bad format","packet has bad compression type"); + + case 0: {//uncompressed + int x; + + for(x=0;xchannel,dest)) + return 0; + break; + } + + case 1://Pure RLE + { + int left=width, i; + + while (left>0) { + stbi_uc count,value[4]; + + count=get8u(s); + if (at_eof(s)) return epuc("bad file","file too short (pure read count)"); + + if (count > left) + count = (uint8) left; + + if (!pic_readval(s,packet->channel,value)) return 0; + + for(i=0; ichannel,dest,value); + left -= count; + } + } + break; + + case 2: {//Mixed RLE + int left=width; + while (left>0) { + int count = get8(s), i; + if (at_eof(s)) return epuc("bad file","file too short (mixed read count)"); + + if (count >= 128) { // Repeated + stbi_uc value[4]; + int i; + + if (count==128) + count = get16(s); + else + count -= 127; + if (count > left) + return epuc("bad file","scanline overrun"); + + if (!pic_readval(s,packet->channel,value)) + return 0; + + for(i=0;ichannel,dest,value); + } else { // Raw + ++count; + if (count>left) return epuc("bad file","scanline overrun"); + + for(i=0;ichannel,dest)) + return 0; + } + left-=count; + } + break; + } + } + } + } + + return result; +} + +static stbi_uc *pic_load(stbi *s,int *px,int *py,int *comp,int req_comp) +{ + stbi_uc *result; + int i, x,y; + + for (i=0; i<92; ++i) + get8(s); + + x = get16(s); + y = get16(s); + if (at_eof(s)) return epuc("bad file","file too short (pic header)"); + if ((1 << 28) / x < y) return epuc("too large", "Image too large to decode"); + + get32(s); //skip `ratio' + get16(s); //skip `fields' + get16(s); //skip `pad' + + // intermediate buffer is RGBA + result = (stbi_uc *) malloc(x*y*4); + memset(result, 0xff, x*y*4); + + if (!pic_load2(s,x,y,comp, result)) { + free(result); + result=0; + } + *px = x; + *py = y; + if (req_comp == 0) req_comp = *comp; + result=convert_format(result,4,req_comp,x,y); + + return result; +} + +int stbi_pic_test_memory(stbi_uc const *buffer, int len) +{ + stbi s; + start_mem(&s,buffer,len); + return pic_test(&s); +} + +stbi_uc *stbi_pic_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + stbi s; + start_mem(&s,buffer,len); + return pic_load(&s,x,y,comp,req_comp); +} + +#ifndef STBI_NO_STDIO +int stbi_pic_test_file(FILE *f) +{ + int result; + long l = ftell(f); + stbi s; + start_file(&s,f); + result = pic_test(&s); + fseek(f,l,SEEK_SET); + return result; +} + +stbi_uc *stbi_pic_load(char const *filename,int *x, int *y, int *comp, int req_comp) +{ + stbi_uc *result; + FILE *f=fopen(filename,"rb"); + if (!f) return 0; + result = stbi_pic_load_from_file(f,x,y,comp,req_comp); + fclose(f); + return result; +} + +stbi_uc *stbi_pic_load_from_file(FILE *f,int *x, int *y, int *comp, int req_comp) +{ + stbi s; + start_file(&s,f); + return pic_load(&s,x,y,comp,req_comp); +} +#endif + +// ************************************************************************************************* +// GIF loader -- public domain by Jean-Marc Lienher -- simplified/shrunk by stb +typedef struct stbi_gif_lzw_struct { + int16 prefix; + uint8 first; + uint8 suffix; +} stbi_gif_lzw; + +typedef struct stbi_gif_struct +{ + int w,h; + stbi_uc *out; // output buffer (always 4 components) + int flags, bgindex, ratio, transparent, eflags; + uint8 pal[256][4]; + uint8 lpal[256][4]; + stbi_gif_lzw codes[4096]; + uint8 *color_table; + int parse, step; + int lflags; + int start_x, start_y; + int max_x, max_y; + int cur_x, cur_y; + int line_size; +} stbi_gif; + +static int gif_test(stbi *s) +{ + int sz; + if (get8(s) != 'G' || get8(s) != 'I' || get8(s) != 'F' || get8(s) != '8') return 0; + sz = get8(s); + if (sz != '9' && sz != '7') return 0; + if (get8(s) != 'a') return 0; + return 1; +} + +#ifndef STBI_NO_STDIO +int stbi_gif_test_file (FILE *f) +{ + stbi s; + int r,n = ftell(f); + start_file(&s,f); + r = gif_test(&s); + fseek(f,n,SEEK_SET); + return r; +} +#endif + +int stbi_gif_test_memory (stbi_uc const *buffer, int len) +{ + stbi s; + start_mem(&s, buffer, len); + return gif_test(&s); +} + +static void stbi_gif_parse_colortable(stbi *s, uint8 pal[256][4], int num_entries, int transp) +{ + int i; + for (i=0; i < num_entries; ++i) { + pal[i][2] = get8u(s); + pal[i][1] = get8u(s); + pal[i][0] = get8u(s); + pal[i][3] = transp ? 0 : 255; + } +} + +static int stbi_gif_header(stbi *s, stbi_gif *g, int *comp, int is_info) +{ + uint8 version; + if (get8(s) != 'G' || get8(s) != 'I' || get8(s) != 'F' || get8(s) != '8') + return e("not GIF", "Corrupt GIF"); + + version = get8u(s); + if (version != '7' && version != '9') return e("not GIF", "Corrupt GIF"); + if (get8(s) != 'a') return e("not GIF", "Corrupt GIF"); + + failure_reason = ""; + g->w = get16le(s); + g->h = get16le(s); + g->flags = get8(s); + g->bgindex = get8(s); + g->ratio = get8(s); + g->transparent = -1; + + if (comp != 0) *comp = 4; // can't actually tell whether it's 3 or 4 until we parse the comments + + if (is_info) return 1; + + if (g->flags & 0x80) + stbi_gif_parse_colortable(s,g->pal, 2 << (g->flags & 7), -1); + + return 1; +} + +static int stbi_gif_info_raw(stbi *s, int *x, int *y, int *comp) +{ + stbi_gif g; + if (!stbi_gif_header(s, &g, comp, 1)) return 0; + if (x) *x = g.w; + if (y) *y = g.h; + return 1; +} + +static void stbi_out_gif_code(stbi_gif *g, uint16 code) +{ + uint8 *p, *c; + + // recurse to decode the prefixes, since the linked-list is backwards, + // and working backwards through an interleaved image would be nasty + if (g->codes[code].prefix >= 0) + stbi_out_gif_code(g, g->codes[code].prefix); + + if (g->cur_y >= g->max_y) return; + + p = &g->out[g->cur_x + g->cur_y]; + c = &g->color_table[g->codes[code].suffix * 4]; + + if (c[3] >= 128) { + p[0] = c[2]; + p[1] = c[1]; + p[2] = c[0]; + p[3] = c[3]; + } + g->cur_x += 4; + + if (g->cur_x >= g->max_x) { + g->cur_x = g->start_x; + g->cur_y += g->step; + + while (g->cur_y >= g->max_y && g->parse > 0) { + g->step = (1 << g->parse) * g->line_size; + g->cur_y = g->start_y + (g->step >> 1); + --g->parse; + } + } +} + +static uint8 *stbi_process_gif_raster(stbi *s, stbi_gif *g) +{ + uint8 lzw_cs; + int32 len, code; + uint32 first; + int32 codesize, codemask, avail, oldcode, bits, valid_bits, clear; + stbi_gif_lzw *p; + + lzw_cs = get8u(s); + clear = 1 << lzw_cs; + first = 1; + codesize = lzw_cs + 1; + codemask = (1 << codesize) - 1; + bits = 0; + valid_bits = 0; + for (code = 0; code < clear; code++) { + g->codes[code].prefix = -1; + g->codes[code].first = (uint8) code; + g->codes[code].suffix = (uint8) code; + } + + // support no starting clear code + avail = clear+2; + oldcode = -1; + + len = 0; + for(;;) { + if (valid_bits < codesize) { + if (len == 0) { + len = get8(s); // start new block + if (len == 0) + return g->out; + } + --len; + bits |= (int32) get8(s) << valid_bits; + valid_bits += 8; + } else { + int32 code = bits & codemask; + bits >>= codesize; + valid_bits -= codesize; + // @OPTIMIZE: is there some way we can accelerate the non-clear path? + if (code == clear) { // clear code + codesize = lzw_cs + 1; + codemask = (1 << codesize) - 1; + avail = clear + 2; + oldcode = -1; + first = 0; + } else if (code == clear + 1) { // end of stream code + skip(s, len); + while ((len = get8(s)) > 0) + skip(s,len); + return g->out; + } else if (code <= avail) { + if (first) return epuc("no clear code", "Corrupt GIF"); + + if (oldcode >= 0) { + p = &g->codes[avail++]; + if (avail > 4096) return epuc("too many codes", "Corrupt GIF"); + p->prefix = (int16) oldcode; + p->first = g->codes[oldcode].first; + p->suffix = (code == avail) ? p->first : g->codes[code].first; + } else if (code == avail) + return epuc("illegal code in raster", "Corrupt GIF"); + + stbi_out_gif_code(g, (uint16) code); + + if ((avail & codemask) == 0 && avail <= 0x0FFF) { + codesize++; + codemask = (1 << codesize) - 1; + } + + oldcode = code; + } else { + return epuc("illegal code in raster", "Corrupt GIF"); + } + } + } +} + +static void stbi_fill_gif_background(stbi_gif *g) +{ + int i; + uint8 *c = g->pal[g->bgindex]; + // @OPTIMIZE: write a dword at a time + for (i = 0; i < g->w * g->h * 4; i += 4) { + uint8 *p = &g->out[i]; + p[0] = c[2]; + p[1] = c[1]; + p[2] = c[0]; + p[3] = c[3]; + } +} + +// this function is designed to support animated gifs, although stb_image doesn't support it +static uint8 *stbi_gif_load_next(stbi *s, stbi_gif *g, int *comp, int req_comp) +{ + int i; + uint8 *old_out = 0; + + if (g->out == 0) { + if (!stbi_gif_header(s, g, comp,0)) return 0; // failure_reason set by stbi_gif_header + g->out = (uint8 *) malloc(4 * g->w * g->h); + if (g->out == 0) return epuc("outofmem", "Out of memory"); + stbi_fill_gif_background(g); + } else { + // animated-gif-only path + if (((g->eflags & 0x1C) >> 2) == 3) { + old_out = g->out; + g->out = (uint8 *) malloc(4 * g->w * g->h); + if (g->out == 0) return epuc("outofmem", "Out of memory"); + memcpy(g->out, old_out, g->w*g->h*4); + } + } + + for (;;) { + switch (get8(s)) { + case 0x2C: /* Image Descriptor */ + { + int32 x, y, w, h; + uint8 *o; + + x = get16le(s); + y = get16le(s); + w = get16le(s); + h = get16le(s); + if (((x + w) > (g->w)) || ((y + h) > (g->h))) + return epuc("bad Image Descriptor", "Corrupt GIF"); + + g->line_size = g->w * 4; + g->start_x = x * 4; + g->start_y = y * g->line_size; + g->max_x = g->start_x + w * 4; + g->max_y = g->start_y + h * g->line_size; + g->cur_x = g->start_x; + g->cur_y = g->start_y; + + g->lflags = get8(s); + + if (g->lflags & 0x40) { + g->step = 8 * g->line_size; // first interlaced spacing + g->parse = 3; + } else { + g->step = g->line_size; + g->parse = 0; + } + + if (g->lflags & 0x80) { + stbi_gif_parse_colortable(s,g->lpal, 2 << (g->lflags & 7), g->eflags & 0x01 ? g->transparent : -1); + g->color_table = (uint8 *) g->lpal; + } else if (g->flags & 0x80) { + for (i=0; i < 256; ++i) // @OPTIMIZE: reset only the previous transparent + g->pal[i][3] = 255; + if (g->transparent >= 0 && (g->eflags & 0x01)) + g->pal[g->transparent][3] = 0; + g->color_table = (uint8 *) g->pal; + } else + return epuc("missing color table", "Corrupt GIF"); + + o = stbi_process_gif_raster(s, g); + if (o == NULL) return NULL; + + if (req_comp && req_comp != 4) + o = convert_format(o, 4, req_comp, g->w, g->h); + return o; + } + + case 0x21: // Comment Extension. + { + int len; + if (get8(s) == 0xF9) { // Graphic Control Extension. + len = get8(s); + if (len == 4) { + g->eflags = get8(s); + get16le(s); // delay + g->transparent = get8(s); + } else { + skip(s, len); + break; + } + } + while ((len = get8(s)) != 0) + skip(s, len); + break; + } + + case 0x3B: // gif stream termination code + return (uint8 *) 1; + + default: + return epuc("unknown code", "Corrupt GIF"); + } + } +} + +#ifndef STBI_NO_STDIO +stbi_uc *stbi_gif_load (char const *filename, int *x, int *y, int *comp, int req_comp) +{ + uint8 *data; + FILE *f = fopen(filename, "rb"); + if (!f) return NULL; + data = stbi_gif_load_from_file(f, x,y,comp,req_comp); + fclose(f); + return data; +} + +stbi_uc *stbi_gif_load_from_file (FILE *f, int *x, int *y, int *comp, int req_comp) +{ + uint8 *u = 0; + stbi s; + stbi_gif g={0}; + start_file(&s, f); + + u = stbi_gif_load_next(&s, &g, comp, req_comp); + if (u == (void *) 1) u = 0; // end of animated gif marker + if (u) { + *x = g.w; + *y = g.h; + } + + return u; +} +#endif + +stbi_uc *stbi_gif_load_from_memory (stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + uint8 *u = 0; + stbi s; + stbi_gif g={0}; + start_mem(&s, buffer, len); + u = stbi_gif_load_next(&s, &g, comp, req_comp); + if (u == (void *) 1) u = 0; // end of animated gif marker + if (u) { + *x = g.w; + *y = g.h; + } + return u; +} + +#ifndef STBI_NO_STDIO +int stbi_gif_info (char const *filename, int *x, int *y, int *comp) +{ + int res; + FILE *f = fopen(filename, "rb"); + if (!f) return 0; + res = stbi_gif_info_from_file(f, x, y, comp); + fclose(f); + return res; +} + +int stbi_gif_info_from_file(FILE *f, int *x, int *y, int *comp) +{ + stbi s; + int res; + long n = ftell(f); + start_file(&s, f); + res = stbi_gif_info_raw(&s, x, y, comp); + fseek(f, n, SEEK_SET); + return res; +} +#endif // !STBI_NO_STDIO + +int stbi_gif_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp) +{ + stbi s; + start_mem(&s, buffer, len); + return stbi_gif_info_raw(&s, x, y, comp); +} + + + + +// ************************************************************************************************* +// Radiance RGBE HDR loader +// originally by Nicolas Schulz +#ifndef STBI_NO_HDR +static int hdr_test(stbi *s) +{ + const char *signature = "#?RADIANCE\n"; + int i; + for (i=0; signature[i]; ++i) + if (get8(s) != signature[i]) + return 0; + return 1; +} + +int stbi_hdr_test_memory(stbi_uc const *buffer, int len) +{ + stbi s; + start_mem(&s, buffer, len); + return hdr_test(&s); +} + +#ifndef STBI_NO_STDIO +int stbi_hdr_test_file(FILE *f) +{ + stbi s; + int r,n = ftell(f); + start_file(&s, f); + r = hdr_test(&s); + fseek(f,n,SEEK_SET); + return r; +} +#endif + +#define HDR_BUFLEN 1024 +static char *hdr_gettoken(stbi *z, char *buffer) +{ + int len=0; + char c = '\0'; + + c = (char) get8(z); + + while (!at_eof(z) && c != '\n') { + buffer[len++] = c; + if (len == HDR_BUFLEN-1) { + // flush to end of line + while (!at_eof(z) && get8(z) != '\n') + ; + break; + } + c = (char) get8(z); + } + + buffer[len] = 0; + return buffer; +} + +static void hdr_convert(float *output, stbi_uc *input, int req_comp) +{ + if ( input[3] != 0 ) { + float f1; + // Exponent + f1 = (float) ldexp(1.0f, input[3] - (int)(128 + 8)); + if (req_comp <= 2) + output[0] = (input[0] + input[1] + input[2]) * f1 / 3; + else { + output[0] = input[0] * f1; + output[1] = input[1] * f1; + output[2] = input[2] * f1; + } + if (req_comp == 2) output[1] = 1; + if (req_comp == 4) output[3] = 1; + } else { + switch (req_comp) { + case 4: output[3] = 1; /* fallthrough */ + case 3: output[0] = output[1] = output[2] = 0; + break; + case 2: output[1] = 1; /* fallthrough */ + case 1: output[0] = 0; + break; + } + } +} + + +static float *hdr_load(stbi *s, int *x, int *y, int *comp, int req_comp) +{ + char buffer[HDR_BUFLEN]; + char *token; + int valid = 0; + int width, height; + stbi_uc *scanline; + float *hdr_data; + int len; + unsigned char count, value; + int i, j, k, c1,c2, z; + + + // Check identifier + if (strcmp(hdr_gettoken(s,buffer), "#?RADIANCE") != 0) + return epf("not HDR", "Corrupt HDR image"); + + // Parse header + for(;;) { + token = hdr_gettoken(s,buffer); + if (token[0] == 0) break; + if (strcmp(token, "FORMAT=32-bit_rle_rgbe") == 0) valid = 1; + } + + if (!valid) return epf("unsupported format", "Unsupported HDR format"); + + // Parse width and height + // can't use sscanf() if we're not using stdio! + token = hdr_gettoken(s,buffer); + if (strncmp(token, "-Y ", 3)) return epf("unsupported data layout", "Unsupported HDR format"); + token += 3; + height = strtol(token, &token, 10); + while (*token == ' ') ++token; + if (strncmp(token, "+X ", 3)) return epf("unsupported data layout", "Unsupported HDR format"); + token += 3; + width = strtol(token, NULL, 10); + + *x = width; + *y = height; + + *comp = 3; + if (req_comp == 0) req_comp = 3; + + // Read data + hdr_data = (float *) malloc(height * width * req_comp * sizeof(float)); + + // Load image data + // image data is stored as some number of sca + if ( width < 8 || width >= 32768) { + // Read flat data + for (j=0; j < height; ++j) { + for (i=0; i < width; ++i) { + stbi_uc rgbe[4]; + main_decode_loop: + getn(s, rgbe, 4); + hdr_convert(hdr_data + j * width * req_comp + i * req_comp, rgbe, req_comp); + } + } + } else { + // Read RLE-encoded data + scanline = NULL; + + for (j = 0; j < height; ++j) { + c1 = get8(s); + c2 = get8(s); + len = get8(s); + if (c1 != 2 || c2 != 2 || (len & 0x80)) { + // not run-length encoded, so we have to actually use THIS data as a decoded + // pixel (note this can't be a valid pixel--one of RGB must be >= 128) + uint8 rgbe[4]; + rgbe[0] = (uint8) c1; + rgbe[1] = (uint8) c2; + rgbe[2] = (uint8) len; + rgbe[3] = (uint8) get8u(s); + hdr_convert(hdr_data, rgbe, req_comp); + i = 1; + j = 0; + free(scanline); + goto main_decode_loop; // yes, this makes no sense + } + len <<= 8; + len |= get8(s); + if (len != width) { free(hdr_data); free(scanline); return epf("invalid decoded scanline length", "corrupt HDR"); } + if (scanline == NULL) scanline = (stbi_uc *) malloc(width * 4); + + for (k = 0; k < 4; ++k) { + i = 0; + while (i < width) { + count = get8u(s); + if (count > 128) { + // Run + value = get8u(s); + count -= 128; + for (z = 0; z < count; ++z) + scanline[i++ * 4 + k] = value; + } else { + // Dump + for (z = 0; z < count; ++z) + scanline[i++ * 4 + k] = get8u(s); + } + } + } + for (i=0; i < width; ++i) + hdr_convert(hdr_data+(j*width + i)*req_comp, scanline + i*4, req_comp); + } + free(scanline); + } + + return hdr_data; +} + +#ifndef STBI_NO_STDIO +float *stbi_hdr_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp) +{ + stbi s; + start_file(&s,f); + return hdr_load(&s,x,y,comp,req_comp); +} +#endif + +float *stbi_hdr_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp) +{ + stbi s; + start_mem(&s,buffer, len); + return hdr_load(&s,x,y,comp,req_comp); +} + +#endif // STBI_NO_HDR + + +#ifndef STBI_NO_STDIO +int stbi_info(char const *filename, int *x, int *y, int *comp) +{ + FILE *f = fopen(filename, "rb"); + int result; + if (!f) return e("can't fopen", "Unable to open file"); + result = stbi_info_from_file(f, x, y, comp); + fclose(f); + return result; +} + +int stbi_info_from_file(FILE *f, int *x, int *y, int *comp) +{ + if (stbi_jpeg_info_from_file(f, x, y, comp)) + return 1; + if (stbi_png_info_from_file(f, x, y, comp)) + return 1; + if (stbi_gif_info_from_file(f, x, y, comp)) + return 1; + // @TODO: stbi_bmp_info_from_file + // @TODO: stbi_psd_info_from_file + #ifndef STBI_NO_HDR + // @TODO: stbi_hdr_info_from_file + #endif + // test tga last because it's a crappy test! + if (stbi_tga_info_from_file(f, x, y, comp)) + return 1; + return e("unknown image type", "Image not of any known type, or corrupt"); +} +#endif // !STBI_NO_STDIO + +int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp) +{ + if (stbi_jpeg_info_from_memory(buffer, len, x, y, comp)) + return 1; + if (stbi_png_info_from_memory(buffer, len, x, y, comp)) + return 1; + if (stbi_gif_info_from_memory(buffer, len, x, y, comp)) + return 1; + // @TODO: stbi_bmp_info_from_memory + // @TODO: stbi_psd_info_from_memory + #ifndef STBI_NO_HDR + // @TODO: stbi_hdr_info_from_memory + #endif + // test tga last because it's a crappy test! + if (stbi_tga_info_from_memory(buffer, len, x, y, comp)) + return 1; + return e("unknown image type", "Image not of any known type, or corrupt"); +} + +#endif // STBI_HEADER_FILE_ONLY + +/* + revision history: + 1.28 (2010-08-01) fix bug in GIF palette transparency (SpartanJ) + 1.27 (2010-08-01) + cast-to-uint8 to fix warnings + 1.26 (2010-07-24) + fix bug in file buffering for PNG reported by SpartanJ + 1.25 (2010-07-17) + refix trans_data warning (Won Chun) + 1.24 (2010-07-12) + perf improvements reading from files on platforms with lock-heavy fgetc() + minor perf improvements for jpeg + deprecated type-specific functions so we'll get feedback if they're needed + attempt to fix trans_data warning (Won Chun) + 1.23 fixed bug in iPhone support + 1.22 (2010-07-10) + removed image *writing* support + removed image *writing* support + stbi_info support from Jetro Lauha + GIF support from Jean-Marc Lienher + iPhone PNG-extensions from James Brown + warning-fixes from Nicolas Schulz and Janez Zemva (i.e. Janez (U+017D)emva) + 1.21 fix use of 'uint8' in header (reported by jon blow) + 1.20 added support for Softimage PIC, by Tom Seddon + 1.19 bug in interlaced PNG corruption check (found by ryg) + 1.18 2008-08-02 + fix a threading bug (local mutable static) + 1.17 support interlaced PNG + 1.16 major bugfix - convert_format converted one too many pixels + 1.15 initialize some fields for thread safety + 1.14 fix threadsafe conversion bug + header-file-only version (#define STBI_HEADER_FILE_ONLY before including) + 1.13 threadsafe + 1.12 const qualifiers in the API + 1.11 Support installable IDCT, colorspace conversion routines + 1.10 Fixes for 64-bit (don't use "unsigned long") + optimized upsampling by Fabian "ryg" Giesen + 1.09 Fix format-conversion for PSD code (bad global variables!) + 1.08 Thatcher Ulrich's PSD code integrated by Nicolas Schulz + 1.07 attempt to fix C++ warning/errors again + 1.06 attempt to fix C++ warning/errors again + 1.05 fix TGA loading to return correct *comp and use good luminance calc + 1.04 default float alpha is 1, not 255; use 'void *' for stbi_image_free + 1.03 bugfixes to STBI_NO_STDIO, STBI_NO_HDR + 1.02 support for (subset of) HDR files, float interface for preferred access to them + 1.01 fix bug: possible bug in handling right-side up bmps... not sure + fix bug: the stbi_bmp_load() and stbi_tga_load() functions didn't work at all + 1.00 interface to zlib that skips zlib header + 0.99 correct handling of alpha in palette + 0.98 TGA loader by lonesock; dynamically add loaders (untested) + 0.97 jpeg errors on too large a file; also catch another malloc failure + 0.96 fix detection of invalid v value - particleman@mollyrocket forum + 0.95 during header scan, seek to markers in case of padding + 0.94 STBI_NO_STDIO to disable stdio usage; rename all #defines the same + 0.93 handle jpegtran output; verbose errors + 0.92 read 4,8,16,24,32-bit BMP files of several formats + 0.91 output 24-bit Windows 3.0 BMP files + 0.90 fix a few more warnings; bump version number to approach 1.0 + 0.61 bugfixes due to Marc LeBlanc, Christopher Lloyd + 0.60 fix compiling as c++ + 0.59 fix warnings: merge Dave Moore's -Wall fixes + 0.58 fix bug: zlib uncompressed mode len/nlen was wrong endian + 0.57 fix bug: jpg last huffman symbol before marker was >9 bits but less + than 16 available + 0.56 fix bug: zlib uncompressed mode len vs. nlen + 0.55 fix bug: restart_interval not initialized to 0 + 0.54 allow NULL for 'int *comp' + 0.53 fix bug in png 3->4; speedup png decoding + 0.52 png handles req_comp=3,4 directly; minor cleanup; jpeg comments + 0.51 obey req_comp requests, 1-component jpegs return as 1-component, + on 'test' only check type, not whether we support this variant +*/ diff --git a/stb_truetype.h b/stb_truetype.h new file mode 100644 index 0000000..1428744 --- /dev/null +++ b/stb_truetype.h @@ -0,0 +1,1807 @@ +// stb_truetype.h - v0.3 - public domain - 2009 Sean Barrett / RAD Game Tools +// +// This library processes TrueType files: +// parse files +// extract glyph metrics +// extract glyph shapes +// render glyphs to one-channel bitmaps with antialiasing (box filter) +// +// Todo: +// non-MS cmaps +// crashproof on bad data +// hinting +// subpixel positioning when rendering bitmap +// cleartype-style AA +// +// ADDITIONAL CONTRIBUTORS +// +// Mikko Mononen: compound shape support, more cmap formats +// +// VERSIONS +// +// 0.3 (2009-06-24) cmap fmt=12, compound shapes (MM) +// userdata, malloc-from-userdata, non-zero fill (STB) +// 0.2 (2009-03-11) Fix unsigned/signed char warnings +// 0.1 (2009-03-09) First public release +// +// USAGE +// +// Include this file in whatever places neeed to refer to it. In ONE C/C++ +// file, write: +// #define STB_TRUETYPE_IMPLEMENTATION +// before the #include of this file. This expands out the actual +// implementation into that C/C++ file. +// +// Look at the header-file sections below for the API, but here's a quick skim: +// +// Simple 3D API (don't ship this, but it's fine for tools and quick start, +// and you can cut and paste from it to move to more advanced) +// stbtt_BakeFontBitmap() -- bake a font to a bitmap for use as texture +// stbtt_GetBakedQuad() -- compute quad to draw for a given char +// +// "Load" a font file from a memory buffer (you have to keep the buffer loaded) +// stbtt_InitFont() +// stbtt_GetFontOffsetForIndex() -- use for TTC font collections +// +// Render a unicode codepoint to a bitmap +// stbtt_GetCodepointBitmap() -- allocates and returns a bitmap +// stbtt_MakeCodepointBitmap() -- renders into bitmap you provide +// stbtt_GetCodepointBitmapBox() -- how big the bitmap must be +// +// Character advance/positioning +// stbtt_GetCodepointHMetrics() +// stbtt_GetFontVMetrics() +// +// NOTES +// +// The system uses the raw data found in the .ttf file without changing it +// and without building auxiliary data structures. This is a bit inefficient +// on little-endian systems (the data is big-endian), but assuming you're +// caching the bitmaps or glyph shapes this shouldn't be a big deal. +// +// It appears to be very hard to programmatically determine what font a +// given file is in a general way. I provide an API for this, but I don't +// recommend it. +// +// +// SOURCE STATISTICS (based on v0.3, 1800 LOC) +// +// Documentation & header file 350 LOC \___ 500 LOC documentation +// Sample code 140 LOC / +// Truetype parsing 580 LOC ---- 600 LOC TrueType +// Software rasterization 240 LOC \ . +// Curve tesselation 120 LOC \__ 500 LOC Bitmap creation +// Bitmap management 70 LOC / +// Baked bitmap interface 70 LOC / +// Font name matching & access 150 LOC ---- 150 +// C runtime library abstraction 60 LOC ---- 60 + + +////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////// +//// +//// SAMPLE PROGRAMS +//// +// +// Incomplete text-in-3d-api example, which draws quads properly aligned to be lossless +// +#if 0 +#define STB_TRUETYPE_IMPLEMENTATION // force following include to generate implementation +#include "stb_truetype.h" + +char ttf_buffer[1<<20]; +unsigned char temp_bitmap[512*512]; + +stbtt_chardata cdata[96]; // ASCII 32..126 is 95 glyphs +GLstbtt_uint ftex; + +void my_stbtt_initfont(void) +{ + fread(ttf_buffer, 1, 1<<20, fopen("c:/windows/fonts/times.ttf", "rb")); + stbtt_BakeFontBitmap(data,0, 32.0, temp_bitmap,512,512, 32,96, cdata); // no guarantee this fits! + // can free ttf_buffer at this point + glGenTextures(1, &ftex); + glBindTexture(GL_TEXTURE_2D, ftex); + glTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, 512,512, 0, GL_ALPHA, GL_UNSIGNED_BYTE, temp_bitmap); + // can free temp_bitmap at this point + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); +} + +void my_stbtt_print(float x, float y, char *text) +{ + // assume orthographic projection with units = screen pixels, origin at top left + glBindTexture(GL_TEXTURE_2D, ftex); + glBegin(GL_QUADS); + while (*text) { + if (*text >= 32 && *text < 128) { + stbtt_aligned_quad q; + stbtt_GetBakedQuad(cdata, 512,512, *text-32, &x,&y,&q,1);//1=opengl,0=old d3d + glTexCoord2f(q.s0,q.t1); glVertex2f(q.x0,q.y0); + glTexCoord2f(q.s1,q.t1); glVertex2f(q.x1,q.y0); + glTexCoord2f(q.s1,q.t0); glVertex2f(q.x1,q.y1); + glTexCoord2f(q.s0,q.t0); glVertex2f(q.x0,q.y1); + } + ++text; + } + glEnd(); +} +#endif +// +// +////////////////////////////////////////////////////////////////////////////// +// +// Complete program (this compiles): get a single bitmap, print as ASCII art +// +#if 0 +#include +#define STB_TRUETYPE_IMPLEMENTATION // force following include to generate implementation +#include "stb_truetype.h" + +char ttf_buffer[1<<25]; + +int main(int argc, char **argv) +{ + stbtt_fontinfo font; + unsigned char *bitmap; + int w,h,i,j,c = (argc > 1 ? atoi(argv[1]) : 'a'), s = (argc > 2 ? atoi(argv[2]) : 20); + + fread(ttf_buffer, 1, 1<<25, fopen(argc > 3 ? argv[3] : "c:/windows/fonts/arialbd.ttf", "rb")); + + stbtt_InitFont(&font, ttf_buffer, stbtt_GetFontOffsetForIndex(ttf_buffer,0)); + bitmap = stbtt_GetCodepointBitmap(&font, 0,stbtt_ScaleForPixelHeight(&font, s), c, &w, &h, 0,0); + + for (j=0; j < h; ++j) { + for (i=0; i < w; ++i) + putchar(" .:ioVM@"[bitmap[j*w+i]>>5]); + putchar('\n'); + } + return 0; +} +#endif +// +// Output: +// +// .ii. +// @@@@@@. +// V@Mio@@o +// :i. V@V +// :oM@@M +// :@@@MM@M +// @@o o@M +// :@@. M@M +// @@@o@@@@ +// :M@@V:@@. +// +////////////////////////////////////////////////////////////////////////////// +// +// Complete program: print "Hello World!" banner, with bugs +// +#if 0 +int main(int arg, char **argv) +{ + unsigned char screen[20][79]; + int i,j, pos=0; + float scale; + char *text = "Heljo World!"; + + fread(buffer, 1, 1000000, fopen("c:/windows/fonts/arialbd.ttf", "rb")); + stbtt_InitFont(&font, buffer, 0); + + scale = stbtt_ScaleForPixelHeight(&font, 16); + memset(screen, 0, sizeof(screen)); + + while (*text) { + int advance,lsb,x0,y0,x1,y1, newpos, baseline=13; + stbtt_GetCodepointHMetrics(&font, *text, &advance, &lsb); + stbtt_GetCodepointBitmapBox(&font, *text, scale,scale, &x0,&y0,&x1,&y1); + newpos = pos + (int) (lsb * scale) + x0; + stbtt_MakeCodepointBitmap(&font, &screen[baseline + y0][newpos], x1-x0,y1-y0, 79, scale,scale, *text); + // note that this stomps the old data, so where character boxes overlap (e.g. 'lj') it's wrong + // because this API is really for baking character bitmaps into textures + pos += (int) (advance * scale); + ++text; + } + + for (j=0; j < 20; ++j) { + for (i=0; i < 79; ++i) + putchar(" .:ioVM@"[screen[j][i]>>5]); + putchar('\n'); + } + + return 0; +} +#endif + + +////////////////////////////////////////////////////////////////////////////// +////////////////////////////////////////////////////////////////////////////// +//// +//// INTEGRATION WITH RUNTIME LIBRARIES +//// + +#ifdef STB_TRUETYPE_IMPLEMENTATION + // #define your own (u)stbtt_int8/16/32 before including to override this + #ifndef stbtt_uint8 + typedef unsigned char stbtt_uint8; + typedef signed char stbtt_int8; + typedef unsigned short stbtt_uint16; + typedef signed short stbtt_int16; + typedef unsigned int stbtt_uint32; + typedef signed int stbtt_int32; + #endif + + typedef char stbtt__check_size32[sizeof(stbtt_int32)==4 ? 1 : -1]; + typedef char stbtt__check_size16[sizeof(stbtt_int16)==2 ? 1 : -1]; + + // #define your own STBTT_sort() to override this to avoid qsort + #ifndef STBTT_sort + #include + #define STBTT_sort(data,num_items,item_size,compare_func) qsort(data,num_items,item_size,compare_func) + #endif + + // #define your own STBTT_ifloor/STBTT_iceil() to avoid math.h + #ifndef STBTT_ifloor + #include + #define STBTT_ifloor(x) ((int) floor(x)) + #define STBTT_iceil(x) ((int) ceil(x)) + #endif + + // #define your own functions "STBTT_malloc" / "STBTT_free" to avoid malloc.h + #ifndef STBTT_malloc + #include + #define STBTT_malloc(x,u) malloc(x) + #define STBTT_free(x,u) free(x) + #endif + + #ifndef STBTT_assert + #include + #define STBTT_assert(x) assert(x) + #endif + + #ifndef STBTT_strlen + #include + #define STBTT_strlen(x) strlen(x) + #endif + + //#ifndef STBTT_memcpy + //#include + #define STBTT_memcpy memcpy + #define STBTT_memset memset + //#endif +#endif + +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// +//// +//// INTERFACE +//// +//// + +#ifndef __STB_INCLUDE_STB_TRUETYPE_H__ +#define __STB_INCLUDE_STB_TRUETYPE_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +////////////////////////////////////////////////////////////////////////////// +// +// TEXTURE BAKING API +// +// If you use this API, you only have to call two functions ever. +// + +typedef struct +{ + unsigned short x0,y0,x1,y1; // coordinates of bbox in bitmap + float xoff,yoff,xadvance; +} stbtt_bakedchar; + +extern int stbtt_BakeFontBitmap(const unsigned char *data, int offset, // font location (use offset=0 for plain .ttf) + float pixel_height, // height of font in pixels + unsigned char *pixels, int pw, int ph, // bitmap to be filled in + int first_char, int num_chars, // characters to bake + stbtt_bakedchar *chardata); // you allocate this, it's num_chars long +// if return is positive, the first unused row of the bitmap +// if return is negative, returns the negative of the number of characters that fit +// if return is 0, no characters fit and no rows were used +// This uses a very crappy packing. + +typedef struct +{ + float x0,y0,s0,t0; // top-left + float x1,y1,s1,t1; // bottom-right +} stbtt_aligned_quad; + +extern void stbtt_GetBakedQuad(stbtt_bakedchar *chardata, int pw, int ph, // same data as above + int char_index, // character to display + float *xpos, float *ypos, // pointers to current position in screen pixel space + stbtt_aligned_quad *q, // output: quad to draw + int opengl_fillrule); // true if opengl fill rule; false if DX9 or earlier +// Call GetBakedQuad with char_index = 'character - first_char', and it +// creates the quad you need to draw and advances the current position. +// It's inefficient; you might want to c&p it and optimize it. + + +////////////////////////////////////////////////////////////////////////////// +// +// FONT LOADING +// +// + +extern int stbtt_GetFontOffsetForIndex(const unsigned char *data, int index); +// Each .ttf file may have more than one font. Each has a sequential index +// number starting from 0. Call this function to get the font offset for a +// given index; it returns -1 if the index is out of range. A regular .ttf +// file will only define one font and it always be at offset 0, so it will +// return '0' for index 0, and -1 for all other indices. You can just skip +// this step if you know it's that kind of font. + + +// The following structure is defined publically so you can declare one on +// the stack or as a global or etc. +typedef struct +{ + void *userdata; + unsigned char *data; // pointer to .ttf file + int fontstart; // offset of start of font + + int numGlyphs; // number of glyphs, needed for range checking + + int loca,head,glyf,hhea,hmtx; // table locations as offset from start of .ttf + int index_map; // a cmap mapping for our chosen character encoding + int indexToLocFormat; // format needed to map from glyph index to glyph +} stbtt_fontinfo; + +extern int stbtt_InitFont(stbtt_fontinfo *info, const unsigned char *data, int offset); +// Given an offset into the file that defines a font, this function builds +// the necessary cached info for the rest of the system. You must allocate +// the stbtt_fontinfo yourself, and stbtt_InitFont will fill it out. You don't +// need to do anything special to free it, because the contents are a pure +// cache with no additional data structures. Returns 0 on failure. + + +////////////////////////////////////////////////////////////////////////////// +// +// CHARACTER TO GLYPH-INDEX CONVERSIOn + +int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unicode_codepoint); +// If you're going to perform multiple operations on the same character +// and you want a speed-up, call this function with the character you're +// going to process, then use glyph-based functions instead of the +// codepoint-based functions. + + +////////////////////////////////////////////////////////////////////////////// +// +// CHARACTER PROPERTIES +// + +extern float stbtt_ScaleForPixelHeight(const stbtt_fontinfo *info, float pixels); +// computes a scale factor to produce a font whose "height" is 'pixels' tall. +// Height is measured as the distance from the highest ascender to the lowest +// descender; in other words, it's equivalent to calling stbtt_GetFontVMetrics +// and computing: +// scale = pixels / (ascent - descent) +// so if you prefer to measure height by the ascent only, use a similar calculation. + +extern void stbtt_GetFontVMetrics(const stbtt_fontinfo *info, int *ascent, int *descent, int *lineGap); +// ascent is the coordinate above the baseline the font extends; descent +// is the coordinate below the baseline the font extends (i.e. it is typically negative) +// lineGap is the spacing between one row's descent and the next row's ascent... +// so you should advance the vertical position by "*ascent - *descent + *lineGap" +// these are expressed in unscaled coordinates + +extern void stbtt_GetCodepointHMetrics(const stbtt_fontinfo *info, int codepoint, int *advanceWidth, int *leftSideBearing); +// leftSideBearing is the offset from the current horizontal position to the left edge of the character +// advanceWidth is the offset from the current horizontal position to the next horizontal position +// these are expressed in unscaled coordinates + +extern int stbtt_GetCodepointKernAdvance(const stbtt_fontinfo *info, int ch1, int ch2); +// an additional amount to add to the 'advance' value between ch1 and ch2 +// @TODO; for now always returns 0! + +extern int stbtt_GetCodepointBox(const stbtt_fontinfo *info, int codepoint, int *x0, int *y0, int *x1, int *y1); +// Gets the bounding box of the visible part of the glyph, in unscaled coordinates + +extern void stbtt_GetGlyphHMetrics(const stbtt_fontinfo *info, int glyph_index, int *advanceWidth, int *leftSideBearing); +extern int stbtt_GetGlyphKernAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2); +extern int stbtt_GetGlyphBox(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1); +// as above, but takes one or more glyph indices for greater efficiency + + +////////////////////////////////////////////////////////////////////////////// +// +// GLYPH SHAPES (you probably don't need these, but they have to go before +// the bitmaps for C declaration-order reasons) +// + +#ifndef STBTT_vmove // you can predefine these to use different values (but why?) + enum { + STBTT_vmove=1, + STBTT_vline, + STBTT_vcurve + }; +#endif + +#ifndef stbtt_vertex // you can predefine this to use different values + // (we share this with other code at RAD) + #define stbtt_vertex_type short // can't use stbtt_int16 because that's not visible in the header file + typedef struct + { + stbtt_vertex_type x,y,cx,cy; + unsigned char type,padding; + } stbtt_vertex; +#endif + +extern int stbtt_GetCodepointShape(const stbtt_fontinfo *info, int unicode_codepoint, stbtt_vertex **vertices); +extern int stbtt_GetGlyphShape(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **vertices); +// returns # of vertices and fills *vertices with the pointer to them +// these are expressed in "unscaled" coordinates + +extern void stbtt_FreeShape(const stbtt_fontinfo *info, stbtt_vertex *vertices); +// frees the data allocated above + +////////////////////////////////////////////////////////////////////////////// +// +// BITMAP RENDERING +// + +extern void stbtt_FreeBitmap(unsigned char *bitmap, void *userdata); +// frees the bitmap allocated below + +extern unsigned char *stbtt_GetCodepointBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int codepoint, int *width, int *height, int *xoff, int *yoff); +// allocates a large-enough single-channel 8bpp bitmap and renders the +// specified character/glyph at the specified scale into it, with +// antialiasing. 0 is no coverage (transparent), 255 is fully covered (opaque). +// *width & *height are filled out with the width & height of the bitmap, +// which is stored left-to-right, top-to-bottom. +// +// xoff/yoff are the offset it pixel space from the glyph origin to the top-left of the bitmap + +extern void stbtt_MakeCodepointBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int codepoint); +// the same as above, but you pass in storage for the bitmap in the form +// of 'output', with row spacing of 'out_stride' bytes. the bitmap is +// clipped to out_w/out_h bytes. call the next function to get the +// height and width and positioning info + +extern void stbtt_GetCodepointBitmapBox(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1); +// get the bbox of the bitmap centered around the glyph origin; so the +// bitmap width is ix1-ix0, height is iy1-iy0, and location to place +// the bitmap top left is (leftSideBearing*scale,iy0). +// (Note that the bitmap uses y-increases-down, but the shape uses +// y-increases-up, so CodepointBitmapBox and CodepointBox are inverted.) + +extern unsigned char *stbtt_GetGlyphBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int glyph, int *width, int *height, int *xoff, int *yoff); +extern void stbtt_GetGlyphBitmapBox(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1); +extern void stbtt_MakeGlyphBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int glyph); + +//extern void stbtt_get_true_bbox(stbtt_vertex *vertices, int num_verts, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1); + +// @TODO: don't expose this structure +typedef struct +{ + int w,h,stride; + unsigned char *pixels; +} stbtt__bitmap; + +extern void stbtt_Rasterize(stbtt__bitmap *result, float flatness_in_pixels, stbtt_vertex *vertices, int num_verts, float scale_x, float scale_y, int x_off, int y_off, int invert, void *userdata); + +////////////////////////////////////////////////////////////////////////////// +// +// Finding the right font... +// +// You should really just solve this offline, keep your own tables +// of what font is what, and don't try to get it out of the .ttf file. +// That's because getting it out of the .ttf file is really hard, because +// the names in the file can appear in many possible encodings, in many +// possible languages, and e.g. if you need a case-insensitive comparison, +// the details of that depend on the encoding & language in a complex way +// (actually underspecified in truetype, but also gigantic). +// +// But you can use the provided functions in two possible ways: +// stbtt_FindMatchingFont() will use *case-sensitive* comparisons on +// unicode-encoded names to try to find the font you want; +// you can run this before calling stbtt_InitFont() +// +// stbtt_GetFontNameString() lets you get any of the various strings +// from the file yourself and do your own comparisons on them. +// You have to have called stbtt_InitFont() first. + + +extern int stbtt_FindMatchingFont(const unsigned char *fontdata, const char *name, int flags); +// returns the offset (not index) of the font that matches, or -1 if none +// if you use STBTT_MACSTYLE_DONTCARE, use a font name like "Arial Bold". +// if you use any other flag, use a font name like "Arial"; this checks +// the 'macStyle' header field; i don't know if fonts set this consistently +#define STBTT_MACSTYLE_DONTCARE 0 +#define STBTT_MACSTYLE_BOLD 1 +#define STBTT_MACSTYLE_ITALIC 2 +#define STBTT_MACSTYLE_UNDERSCORE 4 +#define STBTT_MACSTYLE_NONE 8 // <= not same as 0, this makes us check the bitfield is 0 + +extern int stbtt_CompareUTF8toUTF16_bigendian(const char *s1, int len1, const char *s2, int len2); +// returns 1/0 whether the first string interpreted as utf8 is identical to +// the second string interpreted as big-endian utf16... useful for strings from next func + +extern char *stbtt_GetFontNameString(const stbtt_fontinfo *font, int *length, int platformID, int encodingID, int languageID, int nameID); +// returns the string (which may be big-endian double byte, e.g. for unicode) +// and puts the length in bytes in *length. +// +// some of the values for the IDs are below; for more see the truetype spec: +// http://developer.apple.com/textfonts/TTRefMan/RM06/Chap6name.html +// http://www.microsoft.com/typography/otspec/name.htm + +enum { // platformID + STBTT_PLATFORM_ID_UNICODE =0, + STBTT_PLATFORM_ID_MAC =1, + STBTT_PLATFORM_ID_ISO =2, + STBTT_PLATFORM_ID_MICROSOFT =3 +}; + +enum { // encodingID for STBTT_PLATFORM_ID_UNICODE + STBTT_UNICODE_EID_UNICODE_1_0 =0, + STBTT_UNICODE_EID_UNICODE_1_1 =1, + STBTT_UNICODE_EID_ISO_10646 =2, + STBTT_UNICODE_EID_UNICODE_2_0_BMP=3, + STBTT_UNICODE_EID_UNICODE_2_0_FULL=4, +}; + +enum { // encodingID for STBTT_PLATFORM_ID_MICROSOFT + STBTT_MS_EID_SYMBOL =0, + STBTT_MS_EID_UNICODE_BMP =1, + STBTT_MS_EID_SHIFTJIS =2, + STBTT_MS_EID_UNICODE_FULL =10, +}; + +enum { // encodingID for STBTT_PLATFORM_ID_MAC; same as Script Manager codes + STBTT_MAC_EID_ROMAN =0, STBTT_MAC_EID_ARABIC =4, + STBTT_MAC_EID_JAPANESE =1, STBTT_MAC_EID_HEBREW =5, + STBTT_MAC_EID_CHINESE_TRAD =2, STBTT_MAC_EID_GREEK =6, + STBTT_MAC_EID_KOREAN =3, STBTT_MAC_EID_RUSSIAN =7, +}; + +enum { // languageID for STBTT_PLATFORM_ID_MICROSOFT; same as LCID... + // problematic because there are e.g. 16 english LCIDs and 16 arabic LCIDs + STBTT_MS_LANG_ENGLISH =0x0409, STBTT_MS_LANG_ITALIAN =0x0410, + STBTT_MS_LANG_CHINESE =0x0804, STBTT_MS_LANG_JAPANESE =0x0411, + STBTT_MS_LANG_DUTCH =0x0413, STBTT_MS_LANG_KOREAN =0x0412, + STBTT_MS_LANG_FRENCH =0x040c, STBTT_MS_LANG_RUSSIAN =0x0419, + STBTT_MS_LANG_GERMAN =0x0407, STBTT_MS_LANG_SPANISH =0x0409, + STBTT_MS_LANG_HEBREW =0x040d, STBTT_MS_LANG_SWEDISH =0x041D, +}; + +enum { // languageID for STBTT_PLATFORM_ID_MAC + STBTT_MAC_LANG_ENGLISH =0 , STBTT_MAC_LANG_JAPANESE =11, + STBTT_MAC_LANG_ARABIC =12, STBTT_MAC_LANG_KOREAN =23, + STBTT_MAC_LANG_DUTCH =4 , STBTT_MAC_LANG_RUSSIAN =32, + STBTT_MAC_LANG_FRENCH =1 , STBTT_MAC_LANG_SPANISH =6 , + STBTT_MAC_LANG_GERMAN =2 , STBTT_MAC_LANG_SWEDISH =5 , + STBTT_MAC_LANG_HEBREW =10, STBTT_MAC_LANG_CHINESE_SIMPLIFIED =33, + STBTT_MAC_LANG_ITALIAN =3 , STBTT_MAC_LANG_CHINESE_TRAD =19, +}; + +#ifdef __cplusplus +} +#endif + +#endif // __STB_INCLUDE_STB_TRUETYPE_H__ + +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// +//// +//// IMPLEMENTATION +//// +//// + +#ifdef STB_TRUETYPE_IMPLEMENTATION + +////////////////////////////////////////////////////////////////////////// +// +// accessors to parse data from file +// + +// on platforms that don't allow misaligned reads, if we want to allow +// truetype fonts that aren't padded to alignment, define ALLOW_UNALIGNED_TRUETYPE + +#define ttBYTE(p) (* (stbtt_uint8 *) (p)) +#define ttCHAR(p) (* (stbtt_int8 *) (p)) +#define ttFixed(p) ttLONG(p) + +#if defined(STB_TRUETYPE_BIGENDIAN) && !defined(ALLOW_UNALIGNED_TRUETYPE) + + #define ttUSHORT(p) (* (stbtt_uint16 *) (p)) + #define ttSHORT(p) (* (stbtt_int16 *) (p)) + #define ttULONG(p) (* (stbtt_uint32 *) (p)) + #define ttLONG(p) (* (stbtt_int32 *) (p)) + +#else + + stbtt_uint16 ttUSHORT(const stbtt_uint8 *p) { return p[0]*256 + p[1]; } + stbtt_int16 ttSHORT(const stbtt_uint8 *p) { return p[0]*256 + p[1]; } + stbtt_uint32 ttULONG(const stbtt_uint8 *p) { return (p[0]<<24) + (p[1]<<16) + (p[2]<<8) + p[3]; } + stbtt_int32 ttLONG(const stbtt_uint8 *p) { return (p[0]<<24) + (p[1]<<16) + (p[2]<<8) + p[3]; } + +#endif + +#define stbtt_tag4(p,c0,c1,c2,c3) ((p)[0] == (c0) && (p)[1] == (c1) && (p)[2] == (c2) && (p)[3] == (c3)) +#define stbtt_tag(p,str) stbtt_tag4(p,str[0],str[1],str[2],str[3]) + +static int stbtt__isfont(const stbtt_uint8 *font) +{ + // check the version number + if (stbtt_tag(font, "1")) return 1; // TrueType 1 + if (stbtt_tag(font, "typ1")) return 1; // TrueType with type 1 font -- we don't support this! + if (stbtt_tag(font, "OTTO")) return 1; // OpenType with CFF + if (stbtt_tag4(font, 0,1,0,0)) return 1; // OpenType 1.0 + return 0; +} + +// @OPTIMIZE: binary search +static stbtt_uint32 stbtt__find_table(stbtt_uint8 *data, stbtt_uint32 fontstart, char *tag) +{ + stbtt_int32 num_tables = ttUSHORT(data+fontstart+4); + stbtt_uint32 tabledir = fontstart + 12; + stbtt_int32 i; + for (i=0; i < num_tables; ++i) { + stbtt_uint32 loc = tabledir + 16*i; + if (stbtt_tag(data+loc+0, tag)) + return ttULONG(data+loc+8); + } + return 0; +} + +int stbtt_GetFontOffsetForIndex(const unsigned char *font_collection, int index) +{ + // if it's just a font, there's only one valid index + if (stbtt__isfont(font_collection)) + return index == 0 ? 0 : -1; + + // check if it's a TTC + if (stbtt_tag(font_collection, "ttcf")) { + // version 1? + if (ttULONG(font_collection+4) == 0x00010000 || ttULONG(font_collection+4) == 0x00020000) { + stbtt_int32 n = ttLONG(font_collection+8); + if (index >= n) + return -1; + return ttULONG(font_collection+12+index*14); + } + } + return -1; +} + +int stbtt_InitFont(stbtt_fontinfo *info, const unsigned char *data2, int fontstart) +{ + stbtt_uint8 *data = (stbtt_uint8 *) data2; + stbtt_uint32 cmap, t; + stbtt_int32 i,numTables; + + info->data = data; + info->fontstart = fontstart; + + cmap = stbtt__find_table(data, fontstart, "cmap"); + info->loca = stbtt__find_table(data, fontstart, "loca"); + info->head = stbtt__find_table(data, fontstart, "head"); + info->glyf = stbtt__find_table(data, fontstart, "glyf"); + info->hhea = stbtt__find_table(data, fontstart, "hhea"); + info->hmtx = stbtt__find_table(data, fontstart, "hmtx"); + if (!cmap || !info->loca || !info->head || !info->glyf || !info->hhea || !info->hmtx) + return 0; + + t = stbtt__find_table(data, fontstart, "maxp"); + if (t) + info->numGlyphs = ttUSHORT(data+t+4); + else + info->numGlyphs = 0xffff; + + // find a cmap encoding table we understand *now* to avoid searching + // later. (todo: could make this installable) + // the same regardless of glyph. + numTables = ttUSHORT(data + cmap + 2); + info->index_map = 0; + for (i=0; i < numTables; ++i) { + stbtt_uint32 encoding_record = cmap + 4 + 8 * i; + // find an encoding we understand: + switch(ttUSHORT(data+encoding_record)) { + case STBTT_PLATFORM_ID_MICROSOFT: + switch (ttUSHORT(data+encoding_record+2)) { + case STBTT_MS_EID_UNICODE_BMP: + case STBTT_MS_EID_UNICODE_FULL: + // MS/Unicode + info->index_map = cmap + ttULONG(data+encoding_record+4); + break; + } + break; + } + } + if (info->index_map == 0) + return 0; + + info->indexToLocFormat = ttUSHORT(data+info->head + 50); + return 1; +} + +int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unicode_codepoint) +{ + stbtt_uint8 *data = info->data; + stbtt_uint32 index_map = info->index_map; + + stbtt_uint16 format = ttUSHORT(data + index_map + 0); + if (format == 0) { // apple byte encoding + stbtt_int32 bytes = ttUSHORT(data + index_map + 2); + if (unicode_codepoint < bytes-6) + return ttBYTE(data + index_map + 6 + unicode_codepoint); + return 0; + } else if (format == 6) { + stbtt_uint32 first = ttUSHORT(data + index_map + 6); + stbtt_uint32 count = ttUSHORT(data + index_map + 8); + if ((stbtt_uint32) unicode_codepoint >= first && (stbtt_uint32) unicode_codepoint < first+count) + return ttUSHORT(data + index_map + 10 + (unicode_codepoint - first)*2); + return 0; + } else if (format == 2) { + STBTT_assert(0); // @TODO: high-byte mapping for japanese/chinese/korean + return 0; + } else if (format == 4) { // standard mapping for windows fonts: binary search collection of ranges + stbtt_uint16 segcount = ttUSHORT(data+index_map+6) >> 1; + stbtt_uint16 searchRange = ttUSHORT(data+index_map+8) >> 1; + stbtt_uint16 entrySelector = ttUSHORT(data+index_map+10); + stbtt_uint16 rangeShift = ttUSHORT(data+index_map+12) >> 1; + stbtt_uint16 item, offset, start, end; + + // do a binary search of the segments + stbtt_uint32 endCount = index_map + 14; + stbtt_uint32 search = endCount; + + if (unicode_codepoint > 0xffff) + return 0; + + // they lie from endCount .. endCount + segCount + // but searchRange is the nearest power of two, so... + if (unicode_codepoint >= ttUSHORT(data + search + rangeShift*2)) + search += rangeShift*2; + + // now decrement to bias correctly to find smallest + search -= 2; + while (entrySelector) { + stbtt_uint16 start, end; + searchRange >>= 1; + start = ttUSHORT(data + search + 2 + segcount*2 + 2); + end = ttUSHORT(data + search + 2); + start = ttUSHORT(data + search + searchRange*2 + segcount*2 + 2); + end = ttUSHORT(data + search + searchRange*2); + if (unicode_codepoint > end) + search += searchRange*2; + --entrySelector; + } + search += 2; + + item = (stbtt_uint16) ((search - endCount) >> 1); + + STBTT_assert(unicode_codepoint <= ttUSHORT(data + endCount + 2*item)); + start = ttUSHORT(data + index_map + 14 + segcount*2 + 2 + 2*item); + end = ttUSHORT(data + index_map + 14 + 2 + 2*item); + if (unicode_codepoint < start) + return 0; + + offset = ttUSHORT(data + index_map + 14 + segcount*6 + 2 + 2*item); + if (offset == 0) + return unicode_codepoint + ttSHORT(data + index_map + 14 + segcount*4 + 2 + 2*item); + + return ttUSHORT(data + offset + (unicode_codepoint-start)*2 + index_map + 14 + segcount*6 + 2 + 2*item); + } else if (format == 12) { + stbtt_uint16 ngroups = ttUSHORT(data+index_map+6); + stbtt_int32 low,high; + stbtt_uint16 g = 0; + low = 0; high = (stbtt_int32)ngroups; + // Binary search the right group. + while (low <= high) { + stbtt_int32 mid = low + ((high-low) >> 1); // rounds down, so low <= mid < high + stbtt_uint32 start_char = ttULONG(data+index_map+16+mid*12); + stbtt_uint32 end_char = ttULONG(data+index_map+16+mid*12+4); + if ((stbtt_uint32) unicode_codepoint < start_char) + high = mid-1; + else if ((stbtt_uint32) unicode_codepoint > end_char) + low = mid+1; + else { + stbtt_uint32 start_glyph = ttULONG(data+index_map+16+mid*12+8); + return start_glyph + unicode_codepoint-start_char; + } + } + return 0; // not found + } + // @TODO + STBTT_assert(0); + return 0; +} + +int stbtt_GetCodepointShape(const stbtt_fontinfo *info, int unicode_codepoint, stbtt_vertex **vertices) +{ + return stbtt_GetGlyphShape(info, stbtt_FindGlyphIndex(info, unicode_codepoint), vertices); +} + +static void stbtt_setvertex(stbtt_vertex *v, stbtt_uint8 type, stbtt_int16 x, stbtt_int16 y, stbtt_int16 cx, stbtt_int16 cy) +{ + v->type = type; + v->x = x; + v->y = y; + v->cx = cx; + v->cy = cy; +} + +static int stbtt__GetGlyfOffset(const stbtt_fontinfo *info, int glyph_index) +{ + int g1,g2; + + if (glyph_index >= info->numGlyphs) return -1; // glyph index out of range + if (info->indexToLocFormat >= 2) return -1; // unknown index->glyph map format + + if (info->indexToLocFormat == 0) { + g1 = info->glyf + ttUSHORT(info->data + info->loca + glyph_index * 2) * 2; + g2 = info->glyf + ttUSHORT(info->data + info->loca + glyph_index * 2 + 2) * 2; + } else { + g1 = info->glyf + ttULONG (info->data + info->loca + glyph_index * 4); + g2 = info->glyf + ttULONG (info->data + info->loca + glyph_index * 4 + 4); + } + + return g1==g2 ? -1 : g1; // if length is 0, return -1 +} + +int stbtt_GetGlyphBox(const stbtt_fontinfo *info, int glyph_index, int *x0, int *y0, int *x1, int *y1) +{ + int g = stbtt__GetGlyfOffset(info, glyph_index); + if (g < 0) return 0; + + if (x0) *x0 = ttSHORT(info->data + g + 2); + if (y0) *y0 = ttSHORT(info->data + g + 4); + if (x1) *x1 = ttSHORT(info->data + g + 6); + if (y1) *y1 = ttSHORT(info->data + g + 8); + return 1; +} + +int stbtt_GetCodepointBox(const stbtt_fontinfo *info, int codepoint, int *x0, int *y0, int *x1, int *y1) +{ + return stbtt_GetGlyphBox(info, stbtt_FindGlyphIndex(info,codepoint), x0,y0,x1,y1); +} + +int stbtt_GetGlyphShape(const stbtt_fontinfo *info, int glyph_index, stbtt_vertex **pvertices) +{ + stbtt_int16 numberOfContours; + stbtt_uint8 *endPtsOfContours; + stbtt_uint8 *data = info->data; + stbtt_vertex *vertices=0; + int num_vertices=0; + int g = stbtt__GetGlyfOffset(info, glyph_index); + + *pvertices = NULL; + + if (g < 0) return 0; + + numberOfContours = ttSHORT(data + g); + + if (numberOfContours > 0) { + stbtt_uint8 flags=0,flagcount; + stbtt_int32 ins, i,j=0,m,n, next_move, was_off=0, off; + stbtt_int16 x,y,cx,cy,sx,sy; + stbtt_uint8 *points; + endPtsOfContours = (data + g + 10); + ins = ttUSHORT(data + g + 10 + numberOfContours * 2); + points = data + g + 10 + numberOfContours * 2 + 2 + ins; + + n = 1+ttUSHORT(endPtsOfContours + numberOfContours*2-2); + + m = n + numberOfContours; // a loose bound on how many vertices we might need + vertices = (stbtt_vertex *) STBTT_malloc(m * sizeof(vertices[0]), info->userdata); + if (vertices == 0) + return 0; + + next_move = 0; + flagcount=0; + + // in first pass, we load uninterpreted data into the allocated array + // above, shifted to the end of the array so we won't overwrite it when + // we create our final data starting from the front + + off = m - n; // starting offset for uninterpreted data, regardless of how m ends up being calculated + + // first load flags + + for (i=0; i < n; ++i) { + if (flagcount == 0) { + flags = *points++; + if (flags & 8) + flagcount = *points++; + } else + --flagcount; + vertices[off+i].type = flags; + } + + // now load x coordinates + x=0; + for (i=0; i < n; ++i) { + flags = vertices[off+i].type; + if (flags & 2) { + stbtt_int16 dx = *points++; + x += (flags & 16) ? dx : -dx; // ??? + } else { + if (!(flags & 16)) { + x = x + (stbtt_int16) (points[0]*256 + points[1]); + points += 2; + } + } + vertices[off+i].x = x; + } + + // now load y coordinates + y=0; + for (i=0; i < n; ++i) { + flags = vertices[off+i].type; + if (flags & 4) { + stbtt_int16 dy = *points++; + y += (flags & 32) ? dy : -dy; // ??? + } else { + if (!(flags & 32)) { + y = y + (stbtt_int16) (points[0]*256 + points[1]); + points += 2; + } + } + vertices[off+i].y = y; + } + + // now convert them to our format + num_vertices=0; + sx = sy = cx = cy = 0; + for (i=0; i < n; ++i) { + flags = vertices[off+i].type; + x = (stbtt_int16) vertices[off+i].x; + y = (stbtt_int16) vertices[off+i].y; + if (next_move == i) { + // when we get to the end, we have to close the shape explicitly + if (i != 0) { + if (was_off) + stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve,sx,sy,cx,cy); + else + stbtt_setvertex(&vertices[num_vertices++], STBTT_vline,sx,sy,0,0); + } + + // now start the new one + stbtt_setvertex(&vertices[num_vertices++], STBTT_vmove,x,y,0,0); + next_move = 1 + ttUSHORT(endPtsOfContours+j*2); + ++j; + was_off = 0; + sx = x; + sy = y; + } else { + if (!(flags & 1)) { // if it's a curve + if (was_off) // two off-curve control points in a row means interpolate an on-curve midpoint + stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, (cx+x)>>1, (cy+y)>>1, cx, cy); + cx = x; + cy = y; + was_off = 1; + } else { + if (was_off) + stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, x,y, cx, cy); + else + stbtt_setvertex(&vertices[num_vertices++], STBTT_vline, x,y,0,0); + was_off = 0; + } + } + } + if (i != 0) { + if (was_off) + stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve,sx,sy,cx,cy); + else + stbtt_setvertex(&vertices[num_vertices++], STBTT_vline,sx,sy,0,0); + } + } else if (numberOfContours == -1) { + // Compound shapes. + int more = 1; + stbtt_uint8 *comp = data + g + 10; + num_vertices = 0; + vertices = 0; + while (more) { + stbtt_uint16 flags, gidx; + int comp_num_verts = 0, i; + stbtt_vertex *comp_verts = 0, *tmp = 0; + float mtx[6] = {1,0,0,1,0,0}, m, n; + + flags = ttSHORT(comp); comp+=2; + gidx = ttSHORT(comp); comp+=2; + + if (flags & 2) { // XY values + if (flags & 1) { // shorts + mtx[4] = ttSHORT(comp); comp+=2; + mtx[5] = ttSHORT(comp); comp+=2; + } else { + mtx[4] = ttCHAR(comp); comp+=1; + mtx[5] = ttCHAR(comp); comp+=1; + } + } + else { + // @TODO handle matching point + STBTT_assert(0); + } + if (flags & (1<<3)) { // WE_HAVE_A_SCALE + mtx[0] = mtx[3] = ttSHORT(comp)/16384.0f; comp+=2; + mtx[1] = mtx[2] = 0; + } else if (flags & (1<<6)) { // WE_HAVE_AN_X_AND_YSCALE + mtx[0] = ttSHORT(comp)/16384.0f; comp+=2; + mtx[1] = mtx[2] = 0; + mtx[3] = ttSHORT(comp)/16384.0f; comp+=2; + } else if (flags & (1<<7)) { // WE_HAVE_A_TWO_BY_TWO + mtx[0] = ttSHORT(comp)/16384.0f; comp+=2; + mtx[1] = ttSHORT(comp)/16384.0f; comp+=2; + mtx[2] = ttSHORT(comp)/16384.0f; comp+=2; + mtx[3] = ttSHORT(comp)/16384.0f; comp+=2; + } + + // Find transformation scales. + m = (float) sqrt(mtx[0]*mtx[0] + mtx[1]*mtx[1]); + n = (float) sqrt(mtx[2]*mtx[2] + mtx[3]*mtx[3]); + + // Get indexed glyph. + comp_num_verts = stbtt_GetGlyphShape(info, gidx, &comp_verts); + if (comp_num_verts > 0) { + // Transform vertices. + for (i = 0; i < comp_num_verts; ++i) { + stbtt_vertex* v = &comp_verts[i]; + stbtt_vertex_type x,y; + x=v->x; y=v->y; + v->x = (stbtt_vertex_type)(m * (mtx[0]*x + mtx[2]*y + mtx[4])); + v->y = (stbtt_vertex_type)(n * (mtx[1]*x + mtx[3]*y + mtx[5])); + x=v->cx; y=v->cy; + v->cx = (stbtt_vertex_type)(m * (mtx[0]*x + mtx[2]*y + mtx[4])); + v->cy = (stbtt_vertex_type)(n * (mtx[1]*x + mtx[3]*y + mtx[5])); + } + // Append vertices. + tmp = (stbtt_vertex*)STBTT_malloc((num_vertices+comp_num_verts)*sizeof(stbtt_vertex), info->userdata); + if (!tmp) { + if (vertices) STBTT_free(vertices, info->userdata); + if (comp_verts) STBTT_free(comp_verts, info->userdata); + return 0; + } + if (num_vertices > 0) memcpy(tmp, vertices, num_vertices*sizeof(stbtt_vertex)); + memcpy(tmp+num_vertices, comp_verts, comp_num_verts*sizeof(stbtt_vertex)); + if (vertices) STBTT_free(vertices, info->userdata); + vertices = tmp; + STBTT_free(comp_verts, info->userdata); + num_vertices += comp_num_verts; + } + // More components ? + more = flags & (1<<5); + } + } else if (numberOfContours < 0) { + // @TODO other compound variations? + STBTT_assert(0); + } else { + // numberOfCounters == 0, do nothing + } + + *pvertices = vertices; + return num_vertices; +} + +void stbtt_GetGlyphHMetrics(const stbtt_fontinfo *info, int glyph_index, int *advanceWidth, int *leftSideBearing) +{ + stbtt_uint16 numOfLongHorMetrics = ttUSHORT(info->data+info->hhea + 34); + if (glyph_index < numOfLongHorMetrics) { + if (advanceWidth) *advanceWidth = ttSHORT(info->data + info->hmtx + 4*glyph_index); + if (leftSideBearing) *leftSideBearing = ttSHORT(info->data + info->hmtx + 4*glyph_index + 2); + } else { + if (advanceWidth) *advanceWidth = ttSHORT(info->data + info->hmtx + 4*(numOfLongHorMetrics-1)); + if (leftSideBearing) *leftSideBearing = ttSHORT(info->data + info->hmtx + 4*numOfLongHorMetrics + 2*(glyph_index - numOfLongHorMetrics)); + } +} + +int stbtt_GetGlyphKernAdvance(const stbtt_fontinfo *info, int glyph1, int glyph2) +{ + return 0; +} + +int stbtt_GetCodepointKernAdvance(const stbtt_fontinfo *info, int ch1, int ch2) +{ + return 0; +} + +void stbtt_GetCodepointHMetrics(const stbtt_fontinfo *info, int codepoint, int *advanceWidth, int *leftSideBearing) +{ + stbtt_GetGlyphHMetrics(info, stbtt_FindGlyphIndex(info,codepoint), advanceWidth, leftSideBearing); +} + +void stbtt_GetFontVMetrics(const stbtt_fontinfo *info, int *ascent, int *descent, int *lineGap) +{ + if (ascent ) *ascent = ttSHORT(info->data+info->hhea + 4); + if (descent) *descent = ttSHORT(info->data+info->hhea + 6); + if (lineGap) *lineGap = ttSHORT(info->data+info->hhea + 8); +} + +float stbtt_ScaleForPixelHeight(const stbtt_fontinfo *info, float height) +{ + int fheight = ttSHORT(info->data + info->hhea + 4) - ttSHORT(info->data + info->hhea + 6); + return (float) height / fheight; +} + +void stbtt_FreeShape(const stbtt_fontinfo *info, stbtt_vertex *v) +{ + STBTT_free(v, info->userdata); +} + +////////////////////////////////////////////////////////////////////////////// +// +// antialiasing software rasterizer +// + +void stbtt_GetGlyphBitmapBox(const stbtt_fontinfo *font, int glyph, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1) +{ + int x0,y0,x1,y1; + if (!stbtt_GetGlyphBox(font, glyph, &x0,&y0,&x1,&y1)) + x0=y0=x1=y1=0; // e.g. space character + // now move to integral bboxes (treating pixels as little squares, what pixels get touched)? + if (ix0) *ix0 = STBTT_ifloor(x0 * scale_x); + if (iy0) *iy0 = -STBTT_iceil (y1 * scale_y); + if (ix1) *ix1 = STBTT_iceil (x1 * scale_x); + if (iy1) *iy1 = -STBTT_ifloor(y0 * scale_y); +} + +void stbtt_GetCodepointBitmapBox(const stbtt_fontinfo *font, int codepoint, float scale_x, float scale_y, int *ix0, int *iy0, int *ix1, int *iy1) +{ + stbtt_GetGlyphBitmapBox(font, stbtt_FindGlyphIndex(font,codepoint), scale_x, scale_y, ix0,iy0,ix1,iy1); +} + +typedef struct stbtt__edge { + float x0,y0, x1,y1; + int invert; +} stbtt__edge; + +typedef struct stbtt__active_edge +{ + int x,dx; + float ey; + struct stbtt__active_edge *next; + int valid; +} stbtt__active_edge; + +#define FIXSHIFT 10 +#define FIX (1 << FIXSHIFT) +#define FIXMASK (FIX-1) + +static stbtt__active_edge *new_active(stbtt__edge *e, int off_x, float start_point, void *userdata) +{ + stbtt__active_edge *z = (stbtt__active_edge *) STBTT_malloc(sizeof(*z), userdata); // @TODO: make a pool of these!!! + float dxdy = (e->x1 - e->x0) / (e->y1 - e->y0); + STBTT_assert(e->y0 <= start_point); + if (!z) return z; + // round dx down to avoid going too far + if (dxdy < 0) + z->dx = -STBTT_ifloor(FIX * -dxdy); + else + z->dx = STBTT_ifloor(FIX * dxdy); + z->x = STBTT_ifloor(FIX * (e->x0 + dxdy * (start_point - e->y0))); + z->x -= off_x * FIX; + z->ey = e->y1; + z->next = 0; + z->valid = e->invert ? 1 : -1; + return z; +} + +// note: this routine clips fills that extend off the edges... ideally this +// wouldn't happen, but it could happen if the truetype glyph bounding boxes +// are wrong, or if the user supplies a too-small bitmap +static void stbtt__fill_active_edges(unsigned char *scanline, int len, stbtt__active_edge *e, int max_weight) +{ + // non-zero winding fill + int x0=0, w=0; + + while (e) { + if (w == 0) { + // if we're currently at zero, we need to record the edge start point + x0 = e->x; w += e->valid; + } else { + int x1 = e->x; w += e->valid; + // if we went to zero, we need to draw + if (w == 0) { + int i = x0 >> FIXSHIFT; + int j = x1 >> FIXSHIFT; + + if (i < len && j >= 0) { + if (i == j) { + // x0,x1 are the same pixel, so compute combined coverage + scanline[i] = scanline[i] + (stbtt_uint8) ((x1 - x0) * max_weight >> FIXSHIFT); + } else { + if (i >= 0) // add antialiasing for x0 + scanline[i] = scanline[i] + (stbtt_uint8) (((FIX - (x0 & FIXMASK)) * max_weight) >> FIXSHIFT); + else + i = -1; // clip + + if (j < len) // add antialiasing for x1 + scanline[j] = scanline[j] + (stbtt_uint8) (((x1 & FIXMASK) * max_weight) >> FIXSHIFT); + else + j = len; // clip + + for (++i; i < j; ++i) // fill pixels between x0 and x1 + scanline[i] = scanline[i] + (stbtt_uint8) max_weight; + } + } + } + } + + e = e->next; + } +} + +static void stbtt__rasterize_sorted_edges(stbtt__bitmap *result, stbtt__edge *e, int n, int vsubsample, int off_x, int off_y, void *userdata) +{ + stbtt__active_edge *active = NULL; + int y,j=0; + int max_weight = (255 / vsubsample); // weight per vertical scanline + int s; // vertical subsample index + unsigned char scanline_data[512], *scanline; + + if (result->w > 512) + scanline = (unsigned char *) STBTT_malloc(result->w, userdata); + else + scanline = scanline_data; + + y = off_y * vsubsample; + e[n].y0 = (off_y + result->h) * (float) vsubsample + 1; + + while (j < result->h) { + STBTT_memset(scanline, 0, result->w); + for (s=0; s < vsubsample; ++s) { + // find center of pixel for this scanline + float scan_y = y + 0.5f; + stbtt__active_edge **step = &active; + + // update all active edges; + // remove all active edges that terminate before the center of this scanline + while (*step) { + stbtt__active_edge * z = *step; + if (z->ey <= scan_y) { + *step = z->next; // delete from list + STBTT_assert(z->valid); + z->valid = 0; + STBTT_free(z, userdata); + } else { + z->x += z->dx; // advance to position for current scanline + step = &((*step)->next); // advance through list + } + } + + // resort the list if needed + for(;;) { + int changed=0; + step = &active; + while (*step && (*step)->next) { + if ((*step)->x > (*step)->next->x) { + stbtt__active_edge *t = *step; + stbtt__active_edge *q = t->next; + + t->next = q->next; + q->next = t; + *step = q; + changed = 1; + } + step = &(*step)->next; + } + if (!changed) break; + } + + // insert all edges that start before the center of this scanline -- omit ones that also end on this scanline + while (e->y0 <= scan_y) { + if (e->y1 > scan_y) { + stbtt__active_edge *z = new_active(e, off_x, scan_y, userdata); + // find insertion point + if (active == NULL) + active = z; + else if (z->x < active->x) { + // insert at front + z->next = active; + active = z; + } else { + // find thing to insert AFTER + stbtt__active_edge *p = active; + while (p->next && p->next->x < z->x) + p = p->next; + // at this point, p->next->x is NOT < z->x + z->next = p->next; + p->next = z; + } + } + ++e; + } + + // now process all active edges in XOR fashion + if (active) + stbtt__fill_active_edges(scanline, result->w, active, max_weight); + + ++y; + } + STBTT_memcpy(result->pixels + j * result->stride, scanline, result->w); + ++j; + } + + while (active) { + stbtt__active_edge *z = active; + active = active->next; + STBTT_free(z, userdata); + } + + if (scanline != scanline_data) + STBTT_free(scanline, userdata); +} + +static int stbtt__edge_compare(const void *p, const void *q) +{ + stbtt__edge *a = (stbtt__edge *) p; + stbtt__edge *b = (stbtt__edge *) q; + + if (a->y0 < b->y0) return -1; + if (a->y0 > b->y0) return 1; + return 0; +} + +typedef struct +{ + float x,y; +} stbtt__point; + +static void stbtt__rasterize(stbtt__bitmap *result, stbtt__point *pts, int *wcount, int windings, float scale_x, float scale_y, int off_x, int off_y, int invert, void *userdata) +{ + float y_scale_inv = invert ? -scale_y : scale_y; + stbtt__edge *e; + int n,i,j,k,m; + int vsubsample = result->h < 8 ? 15 : 5; + // vsubsample should divide 255 evenly; otherwise we won't reach full opacity + + // now we have to blow out the windings into explicit edge lists + n = 0; + for (i=0; i < windings; ++i) + n += wcount[i]; + + e = (stbtt__edge *) STBTT_malloc(sizeof(*e) * (n+1), userdata); // add an extra one as a sentinel + if (e == 0) return; + n = 0; + + m=0; + for (i=0; i < windings; ++i) { + stbtt__point *p = pts + m; + m += wcount[i]; + j = wcount[i]-1; + for (k=0; k < wcount[i]; j=k++) { + int a=k,b=j; + // skip the edge if horizontal + if (p[j].y == p[k].y) + continue; + // add edge from j to k to the list + e[n].invert = 0; + if (invert ? p[j].y > p[k].y : p[j].y < p[k].y) { + e[n].invert = 1; + a=j,b=k; + } + e[n].x0 = p[a].x * scale_x; + e[n].y0 = p[a].y * y_scale_inv * vsubsample; + e[n].x1 = p[b].x * scale_x; + e[n].y1 = p[b].y * y_scale_inv * vsubsample; + ++n; + } + } + + // now sort the edges by their highest point (should snap to integer, and then by x) + STBTT_sort(e, n, sizeof(e[0]), stbtt__edge_compare); + + // now, traverse the scanlines and find the intersections on each scanline, use xor winding rule + stbtt__rasterize_sorted_edges(result, e, n, vsubsample, off_x, off_y, userdata); + + STBTT_free(e, userdata); +} + +static void stbtt__add_point(stbtt__point *points, int n, float x, float y) +{ + if (!points) return; // during first pass, it's unallocated + points[n].x = x; + points[n].y = y; +} + +// tesselate until threshhold p is happy... @TODO warped to compensate for non-linear stretching +static int stbtt__tesselate_curve(stbtt__point *points, int *num_points, float x0, float y0, float x1, float y1, float x2, float y2, float objspace_flatness_squared, int n) +{ + // midpoint + float mx = (x0 + 2*x1 + x2)/4; + float my = (y0 + 2*y1 + y2)/4; + // versus directly drawn line + float dx = (x0+x2)/2 - mx; + float dy = (y0+y2)/2 - my; + if (n > 16) // 65536 segments on one curve better be enough! + return 1; + if (dx*dx+dy*dy > objspace_flatness_squared) { // half-pixel error allowed... need to be smaller if AA + stbtt__tesselate_curve(points, num_points, x0,y0, (x0+x1)/2.0f,(y0+y1)/2.0f, mx,my, objspace_flatness_squared,n+1); + stbtt__tesselate_curve(points, num_points, mx,my, (x1+x2)/2.0f,(y1+y2)/2.0f, x2,y2, objspace_flatness_squared,n+1); + } else { + stbtt__add_point(points, *num_points,x2,y2); + *num_points = *num_points+1; + } + return 1; +} + +// returns number of contours +stbtt__point *stbtt_FlattenCurves(stbtt_vertex *vertices, int num_verts, float objspace_flatness, int **contour_lengths, int *num_contours, void *userdata) +{ + stbtt__point *points=0; + int num_points=0; + + float objspace_flatness_squared = objspace_flatness * objspace_flatness; + int i,n=0,start=0, pass; + + // count how many "moves" there are to get the contour count + for (i=0; i < num_verts; ++i) + if (vertices[i].type == STBTT_vmove) + ++n; + + *num_contours = n; + if (n == 0) return 0; + + *contour_lengths = (int *) STBTT_malloc(sizeof(**contour_lengths) * n, userdata); + + if (*contour_lengths == 0) { + *num_contours = 0; + return 0; + } + + // make two passes through the points so we don't need to realloc + for (pass=0; pass < 2; ++pass) { + float x=0,y=0; + if (pass == 1) { + points = (stbtt__point *) STBTT_malloc(num_points * sizeof(points[0]), userdata); + if (points == NULL) goto error; + } + num_points = 0; + n= -1; + for (i=0; i < num_verts; ++i) { + switch (vertices[i].type) { + case STBTT_vmove: + // start the next contour + if (n >= 0) + (*contour_lengths)[n] = num_points - start; + ++n; + start = num_points; + + x = vertices[i].x, y = vertices[i].y; + stbtt__add_point(points, num_points++, x,y); + break; + case STBTT_vline: + x = vertices[i].x, y = vertices[i].y; + stbtt__add_point(points, num_points++, x, y); + break; + case STBTT_vcurve: + stbtt__tesselate_curve(points, &num_points, x,y, + vertices[i].cx, vertices[i].cy, + vertices[i].x, vertices[i].y, + objspace_flatness_squared, 0); + x = vertices[i].x, y = vertices[i].y; + break; + } + } + (*contour_lengths)[n] = num_points - start; + } + + return points; +error: + STBTT_free(points, userdata); + STBTT_free(*contour_lengths, userdata); + *contour_lengths = 0; + *num_contours = 0; + return NULL; +} + +void stbtt_Rasterize(stbtt__bitmap *result, float flatness_in_pixels, stbtt_vertex *vertices, int num_verts, float scale_x, float scale_y, int x_off, int y_off, int invert, void *userdata) +{ + float scale = scale_x > scale_y ? scale_y : scale_x; + int winding_count, *winding_lengths; + stbtt__point *windings = stbtt_FlattenCurves(vertices, num_verts, flatness_in_pixels / scale, &winding_lengths, &winding_count, userdata); + if (windings) { + stbtt__rasterize(result, windings, winding_lengths, winding_count, scale_x, scale_y, x_off, y_off, invert, userdata); + STBTT_free(winding_lengths, userdata); + STBTT_free(windings, userdata); + } +} + +void stbtt_FreeBitmap(unsigned char *bitmap, void *userdata) +{ + STBTT_free(bitmap, userdata); +} + +unsigned char *stbtt_GetGlyphBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int glyph, int *width, int *height, int *xoff, int *yoff) +{ + int ix0,iy0,ix1,iy1; + stbtt__bitmap gbm; + stbtt_vertex *vertices; + int num_verts = stbtt_GetGlyphShape(info, glyph, &vertices); + + if (scale_x == 0) scale_x = scale_y; + if (scale_y == 0) { + if (scale_x == 0) return NULL; + scale_y = scale_x; + } + + stbtt_GetGlyphBitmapBox(info, glyph, scale_x, scale_y, &ix0,&iy0,&ix1,&iy1); + + // now we get the size + gbm.w = (ix1 - ix0); + gbm.h = (iy1 - iy0); + gbm.pixels = NULL; // in case we error + + if (width ) *width = gbm.w; + if (height) *height = gbm.h; + if (xoff ) *xoff = ix0; + if (yoff ) *yoff = iy0; + + if (gbm.w && gbm.h) { + gbm.pixels = (unsigned char *) STBTT_malloc(gbm.w * gbm.h, info->userdata); + if (gbm.pixels) { + gbm.stride = gbm.w; + + stbtt_Rasterize(&gbm, 0.35f, vertices, num_verts, scale_x, scale_y, ix0, iy0, 1, info->userdata); + } + } + STBTT_free(vertices, info->userdata); + return gbm.pixels; +} + +void stbtt_MakeGlyphBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int glyph) +{ + int ix0,iy0; + stbtt_vertex *vertices; + int num_verts = stbtt_GetGlyphShape(info, glyph, &vertices); + stbtt__bitmap gbm; + + stbtt_GetGlyphBitmapBox(info, glyph, scale_x, scale_y, &ix0,&iy0,0,0); + gbm.pixels = output; + gbm.w = out_w; + gbm.h = out_h; + gbm.stride = out_stride; + + if (gbm.w && gbm.h) + stbtt_Rasterize(&gbm, 0.35f, vertices, num_verts, scale_x, scale_y, ix0,iy0, 1, info->userdata); + + STBTT_free(vertices, info->userdata); +} + +unsigned char *stbtt_GetCodepointBitmap(const stbtt_fontinfo *info, float scale_x, float scale_y, int codepoint, int *width, int *height, int *xoff, int *yoff) +{ + return stbtt_GetGlyphBitmap(info, scale_x, scale_y, stbtt_FindGlyphIndex(info,codepoint), width,height,xoff,yoff); +} + +void stbtt_MakeCodepointBitmap(const stbtt_fontinfo *info, unsigned char *output, int out_w, int out_h, int out_stride, float scale_x, float scale_y, int codepoint) +{ + stbtt_MakeGlyphBitmap(info, output, out_w, out_h, out_stride, scale_x, scale_y, stbtt_FindGlyphIndex(info,codepoint)); +} + +////////////////////////////////////////////////////////////////////////////// +// +// bitmap baking +// +// This is SUPER-SHITTY packing to keep source code small + +extern int stbtt_BakeFontBitmap(const unsigned char *data, int offset, // font location (use offset=0 for plain .ttf) + float pixel_height, // height of font in pixels + unsigned char *pixels, int pw, int ph, // bitmap to be filled in + int first_char, int num_chars, // characters to bake + stbtt_bakedchar *chardata) +{ + float scale; + int x,y,bottom_y, i; + stbtt_fontinfo f; + stbtt_InitFont(&f, data, offset); + STBTT_memset(pixels, 0, pw*ph); // background of 0 around pixels + x=y=1; + bottom_y = 1; + + scale = stbtt_ScaleForPixelHeight(&f, pixel_height); + + for (i=0; i < num_chars; ++i) { + int advance, lsb, x0,y0,x1,y1,gw,gh; + int g = stbtt_FindGlyphIndex(&f, first_char + i); + stbtt_GetGlyphHMetrics(&f, g, &advance, &lsb); + stbtt_GetGlyphBitmapBox(&f, g, scale,scale, &x0,&y0,&x1,&y1); + gw = x1-x0; + gh = y1-y0; + if (x + gw + 1 >= pw) + y = bottom_y, x = 1; // advance to next row + if (y + gh + 1 >= ph) // check if it fits vertically AFTER potentially moving to next row + return -i; + STBTT_assert(x+gw < pw); + STBTT_assert(y+gh < ph); + stbtt_MakeGlyphBitmap(&f, pixels+x+y*pw, gw,gh,pw, scale,scale, g); + chardata[i].x0 = (stbtt_int16) x; + chardata[i].y0 = (stbtt_int16) y; + chardata[i].x1 = (stbtt_int16) (x + gw); + chardata[i].y1 = (stbtt_int16) (y + gh); + chardata[i].xadvance = scale * advance; + chardata[i].xoff = (float) x0; + chardata[i].yoff = (float) y0; + x = x + gw + 2; + if (y+gh+2 > bottom_y) + bottom_y = y+gh+2; + } + return bottom_y; +} + +void stbtt_GetBakedQuad(stbtt_bakedchar *chardata, int pw, int ph, int char_index, float *xpos, float *ypos, stbtt_aligned_quad *q, int opengl_fillrule) +{ + float d3d_bias = opengl_fillrule ? 0 : -0.5f; + float ipw = 1.0f / pw, iph = 1.0f / ph; + stbtt_bakedchar *b = chardata + char_index; + int round_x = STBTT_ifloor((*xpos + b->xoff) + 0.5); + int round_y = STBTT_ifloor((*ypos + b->yoff) + 0.5); + + q->x0 = round_x + d3d_bias; + q->y0 = round_y + d3d_bias; + q->x1 = round_x + b->x1 - b->x0 + d3d_bias; + q->y1 = round_y + b->y1 - b->y0 + d3d_bias; + + q->s0 = b->x0 * ipw; + q->t0 = b->y0 * ipw; + q->s1 = b->x1 * iph; + q->t1 = b->y1 * iph; + + *xpos += b->xadvance; +} + +////////////////////////////////////////////////////////////////////////////// +// +// font name matching -- recommended not to use this +// + +// check if a utf8 string contains a prefix which is the utf16 string; if so return length of matching utf8 string +static stbtt_int32 stbtt__CompareUTF8toUTF16_bigendian_prefix(stbtt_uint8 *s1, stbtt_int32 len1, stbtt_uint8 *s2, stbtt_int32 len2) +{ + stbtt_int32 i=0; + + // convert utf16 to utf8 and compare the results while converting + while (len2) { + stbtt_uint16 ch = s2[0]*256 + s2[1]; + if (ch < 0x80) { + if (i >= len1) return -1; + if (s1[i++] != ch) return -1; + } else if (ch < 0x800) { + if (i+1 >= len1) return -1; + if (s1[i++] != 0xc0 + (ch >> 6)) return -1; + if (s1[i++] != 0x80 + (ch & 0x3f)) return -1; + } else if (ch >= 0xd800 && ch < 0xdc00) { + stbtt_uint32 c; + stbtt_uint16 ch2 = s2[2]*256 + s2[3]; + if (i+3 >= len1) return -1; + c = ((ch - 0xd800) << 10) + (ch2 - 0xdc00) + 0x10000; + if (s1[i++] != 0xf0 + (c >> 18)) return -1; + if (s1[i++] != 0x80 + ((c >> 12) & 0x3f)) return -1; + if (s1[i++] != 0x80 + ((c >> 6) & 0x3f)) return -1; + if (s1[i++] != 0x80 + ((c ) & 0x3f)) return -1; + s2 += 2; // plus another 2 below + len2 -= 2; + } else if (ch >= 0xdc00 && ch < 0xe000) { + return -1; + } else { + if (i+2 >= len1) return -1; + if (s1[i++] != 0xe0 + (ch >> 12)) return -1; + if (s1[i++] != 0x80 + ((ch >> 6) & 0x3f)) return -1; + if (s1[i++] != 0x80 + ((ch ) & 0x3f)) return -1; + } + s2 += 2; + len2 -= 2; + } + return i; +} + +int stbtt_CompareUTF8toUTF16_bigendian(const char *s1, int len1, const char *s2, int len2) +{ + return len1 == stbtt__CompareUTF8toUTF16_bigendian_prefix((stbtt_uint8*) s1, len1, (stbtt_uint8*) s2, len2); +} + +// returns results in whatever encoding you request... but note that 2-byte encodings +// will be BIG-ENDIAN... use stbtt_CompareUTF8toUTF16_bigendian() to compare +char *stbtt_GetFontNameString(const stbtt_fontinfo *font, int *length, int platformID, int encodingID, int languageID, int nameID) +{ + stbtt_int32 i,count,stringOffset; + stbtt_uint8 *fc = font->data; + stbtt_uint32 offset = font->fontstart; + stbtt_uint32 nm = stbtt__find_table(fc, offset, "name"); + if (!nm) return NULL; + + count = ttUSHORT(fc+nm+2); + stringOffset = nm + ttUSHORT(fc+nm+4); + for (i=0; i < count; ++i) { + stbtt_uint32 loc = nm + 6 + 12 * i; + if (platformID == ttUSHORT(fc+loc+0) && encodingID == ttUSHORT(fc+loc+2) + && languageID == ttUSHORT(fc+loc+4) && nameID == ttUSHORT(fc+loc+6)) { + *length = ttUSHORT(fc+loc+8); + return (char *) (fc+stringOffset+ttUSHORT(fc+loc+10)); + } + } + return NULL; +} + +static int stbtt__matchpair(stbtt_uint8 *fc, stbtt_uint32 nm, stbtt_uint8 *name, stbtt_int32 nlen, stbtt_int32 target_id, stbtt_int32 next_id) +{ + stbtt_int32 i; + stbtt_int32 count = ttUSHORT(fc+nm+2); + stbtt_int32 stringOffset = nm + ttUSHORT(fc+nm+4); + + for (i=0; i < count; ++i) { + stbtt_uint32 loc = nm + 6 + 12 * i; + stbtt_int32 id = ttUSHORT(fc+loc+6); + if (id == target_id) { + // find the encoding + stbtt_int32 platform = ttUSHORT(fc+loc+0), encoding = ttUSHORT(fc+loc+2), language = ttUSHORT(fc+loc+4); + + // is this a Unicode encoding? + if (platform == 0 || (platform == 3 && encoding == 1) || (platform == 3 && encoding == 10)) { + stbtt_int32 slen = ttUSHORT(fc+loc+8), off = ttUSHORT(fc+loc+10); + + // check if there's a prefix match + stbtt_int32 matchlen = stbtt__CompareUTF8toUTF16_bigendian_prefix(name, nlen, fc+stringOffset+off,slen); + if (matchlen >= 0) { + // check for target_id+1 immediately following, with same encoding & language + if (i+1 < count && ttUSHORT(fc+loc+12+6) == next_id && ttUSHORT(fc+loc+12) == platform && ttUSHORT(fc+loc+12+2) == encoding && ttUSHORT(fc+loc+12+4) == language) { + stbtt_int32 slen = ttUSHORT(fc+loc+12+8), off = ttUSHORT(fc+loc+12+10); + if (slen == 0) { + if (matchlen == nlen) + return 1; + } else if (matchlen < nlen && name[matchlen] == ' ') { + ++matchlen; + if (stbtt_CompareUTF8toUTF16_bigendian((char*) (name+matchlen), nlen-matchlen, (char*)(fc+stringOffset+off),slen)) + return 1; + } + } else { + // if nothing immediately following + if (matchlen == nlen) + return 1; + } + } + } + + // @TODO handle other encodings + } + } + return 0; +} + +static int stbtt__matches(stbtt_uint8 *fc, stbtt_uint32 offset, stbtt_uint8 *name, stbtt_int32 flags) +{ + stbtt_int32 nlen = STBTT_strlen((char *) name); + stbtt_uint32 nm,hd; + if (!stbtt__isfont(fc+offset)) return 0; + + // check italics/bold/underline flags in macStyle... + if (flags) { + hd = stbtt__find_table(fc, offset, "head"); + if ((ttUSHORT(fc+hd+44) & 7) != (flags & 7)) return 0; + } + + nm = stbtt__find_table(fc, offset, "name"); + if (!nm) return 0; + + if (flags) { + // if we checked the macStyle flags, then just check the family and ignore the subfamily + if (stbtt__matchpair(fc, nm, name, nlen, 16, -1)) return 1; + if (stbtt__matchpair(fc, nm, name, nlen, 1, -1)) return 1; + if (stbtt__matchpair(fc, nm, name, nlen, 3, -1)) return 1; + } else { + if (stbtt__matchpair(fc, nm, name, nlen, 16, 17)) return 1; + if (stbtt__matchpair(fc, nm, name, nlen, 1, 2)) return 1; + if (stbtt__matchpair(fc, nm, name, nlen, 3, -1)) return 1; + } + + return 0; +} + +int stbtt_FindMatchingFont(const unsigned char *font_collection, const char *name_utf8, stbtt_int32 flags) +{ + stbtt_int32 i; + for (i=0;;++i) { + stbtt_int32 off = stbtt_GetFontOffsetForIndex(font_collection, i); + if (off < 0) return off; + if (stbtt__matches((stbtt_uint8 *) font_collection, off, (stbtt_uint8*) name_utf8, flags)) + return off; + } +} + +#endif // STB_TRUETYPE_IMPLEMENTATION diff --git a/strlib.c b/strlib.c new file mode 100644 index 0000000..91fdfc8 --- /dev/null +++ b/strlib.c @@ -0,0 +1,43 @@ +#include "strlib.h" + +char *strcpytrim(char *d, // destination + char *s, // source + int mode, + char *delim + ) { + char *o = d; // save orig + char *e = 0; // end space ptr. + char dtab[256] = {0}; + if (!s || !d) return 0; + + if (!delim) delim = " \t\n\f"; + while (*delim) + dtab[*delim++] = 1; + + while ( (*d = *s++) != 0 ) { + if (!dtab[*d]) { // Not a match char + e = 0; // Reset end pointer + } else { + if (!e) e = d; // Found first match. + + if ( mode == STRLIB_MODE_ALL || ((mode != STRLIB_MODE_RIGHT) && (d == o)) ) + continue; + } + d++; + } + if (mode != STRLIB_MODE_LEFT && e) { // for everything but trim_left, delete trailing matches. + *e = 0; + } + return o; +} + +// perhaps these could be inlined in strlib.h +char *strtriml(char *d, char *s) { return strcpytrim(d, s, STRLIB_MODE_LEFT, 0); } +char *strtrimr(char *d, char *s) { return strcpytrim(d, s, STRLIB_MODE_RIGHT, 0); } +char *strtrim(char *d, char *s) { return strcpytrim(d, s, STRLIB_MODE_BOTH, 0); } +char *strstrlibkill(char *d, char *s) { return strcpytrim(d, s, STRLIB_MODE_ALL, 0); } + +char *triml(char *s) { return strcpytrim(s, s, STRLIB_MODE_LEFT, 0); } +char *trimr(char *s) { return strcpytrim(s, s, STRLIB_MODE_RIGHT, 0); } +char *trim(char *s) { return strcpytrim(s, s, STRLIB_MODE_BOTH, 0); } +char *strlibkill(char *s) { return strcpytrim(s, s, STRLIB_MODE_ALL, 0); } \ No newline at end of file diff --git a/strlib.h b/strlib.h new file mode 100644 index 0000000..e3ed963 --- /dev/null +++ b/strlib.h @@ -0,0 +1,24 @@ +#ifndef STRLIB_H_ +enum strtrim_mode_t { + STRLIB_MODE_ALL = 0, + STRLIB_MODE_RIGHT = 0x01, + STRLIB_MODE_LEFT = 0x02, + STRLIB_MODE_BOTH = 0x03 +}; + +char *strcpytrim(char *d, // destination + char *s, // source + int mode, + char *delim + ); + +char *strtriml(char *d, char *s); +char *strtrimr(char *d, char *s); +char *strtrim(char *d, char *s); +char *strstrlibkill(char *d, char *s); + +char *triml(char *s); +char *trimr(char *s); +char *trim(char *s); +char *strlibkill(char *s); +#endif diff --git a/sys.c b/sys.c new file mode 100644 index 0000000..d1c68d0 --- /dev/null +++ b/sys.c @@ -0,0 +1,359 @@ +#include +#include +#include +#include "sys.h" +#include "types.h" +#include "everdrive.h" +#include "errors.h" +#include "usb.h" + + +u32 asm_date; + +Options_st options; + +u32 native_tv_mode; + +#define CIC_6101 1 +#define CIC_6102 2 +#define CIC_6103 3 +#define CIC_6104 4 +#define CIC_6105 5 +#define CIC_6106 6 + +u16 strcon(u8 *str1, u8 *str2, u8 *dst, u16 max_len) { + + u16 len = 0; + max_len -= 1; + + while (*str1 != 0 && len < max_len) { + *dst++ = *str1++; + len++; + } + + while (*str2 != 0 && len < max_len) { + *dst++ = *str2++; + len++; + } + *dst++ = 0; + return len; + +} + + +void dma_read_s(void * ram_address, unsigned long pi_address, unsigned long len) { + + u32 buff[256]; + + u32 *bptr; + + u32 *rptr = (u32 *) ram_address; + + // if(len==32768) + // rptr = (u32 *) 0x803F7988; + + u16 i; + + //u16 blen = 512; + //if (len < 512)blen = len; + //*(volatile u32*) 0x1FC007FC = 0x08; + + IO_WRITE(PI_STATUS_REG, 3); + while (len) { + dma_read(buff, pi_address, 512); + while ((IO_READ(PI_STATUS_REG) & 3) != 0); + //while ((*((volatile u32*) PI_STATUS_REG) & 0x02) != 1); + data_cache_hit_invalidate(buff, 512); + bptr = buff; + for (i = 0; i < 512 && i < len; i += 4)*rptr++ = *bptr++; + len = len < 512 ? 0 : len - 512; + pi_address += 512; + } +} + +void dma_write_s(void * ram_address, unsigned long pi_address, unsigned long len) { + + + //if(len==32768) + //ram_address = (u32 *) 0x803F7988; + + + data_cache_hit_writeback(ram_address, len); + dma_write(ram_address, pi_address, len); + + + +} + + +/* +void showError(char *str, u32 code) { + + + console_printf("%s%u\n", str, code); + joyWait(); + + +} + */ +void sleep(u32 ms) { + + u32 current_ms = get_ticks_ms(); + + while (get_ticks_ms() - current_ms < ms); + +} + +void dma_read_sram(void *dest, u32 offset, u32 size) { + /* + PI_DMAWait(); + + IO_WRITE(PI_STATUS_REG, 0x03); + IO_WRITE(PI_DRAM_ADDR_REG, K1_TO_PHYS(dest)); + IO_WRITE(PI_CART_ADDR_REG, (0xA8000000 + offset)); + // data_cache_invalidate_all(); + IO_WRITE(PI_WR_LEN_REG, (size - 1)); + */ + /* 0xA8000000 + * 0xb0000000 + * 0x4000000 + * */ + dma_read_s(dest, 0xA8000000 + offset, size); + //data_cache_invalidate(dest,size); + +} + +void dma_write_sram(void* src, u32 offset, u32 size) { + /* + PI_DMAWait(); + + IO_WRITE(PI_STATUS_REG, 0x02); + IO_WRITE(PI_DRAM_ADDR_REG, K1_TO_PHYS(src)); + IO_WRITE(PI_CART_ADDR_REG, (0xA8000000 + offset)); + // data_cache_invalidate_all(); + IO_WRITE(PI_RD_LEN_REG, (size - 1)); + */ + dma_write_s(src, 0xA8000000 + offset, size); + +} + +#define DO1(buf) crc = crc_table[((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8); +#define DO2(buf) DO1(buf); DO1(buf); +#define DO4(buf) DO2(buf); DO2(buf); +#define DO8(buf) DO4(buf); DO4(buf); + +unsigned int CRC_Calculate(unsigned int crc, unsigned char* buf, unsigned int len) { + static unsigned int crc_table[256]; + static int make_crc_table = 1; + + if (make_crc_table) { + unsigned int c, n; + int k; + unsigned int poly; + const unsigned char p[] = {0, 1, 2, 4, 5, 7, 8, 10, 11, 12, 16, 22, 23, 26}; + + /* make exclusive-or pattern from polynomial (0xedb88320L) */ + poly = 0L; + for (n = 0; n < sizeof (p) / sizeof (unsigned char); n++) + poly |= 1L << (31 - p[n]); + + for (n = 0; n < 256; n++) { + c = n; + for (k = 0; k < 8; k++) + c = c & 1 ? poly ^ (c >> 1) : c >> 1; + crc_table[n] = c; + } + make_crc_table = 0; + } + + if (buf == (void*) 0) return 0L; + + crc = crc ^ 0xffffffffL; + while (len >= 8) { + DO8(buf); + len -= 8; + } + if (len) + do { + DO1(buf); + } while (--len); + + return crc ^ 0xffffffffL; +} + + + +u32 ii; +volatile u32 *pt; +void clean(); + +#define MEM32(addr) *((volatile u32 *)addr) + + +u8 str_buff[128]; + +u8 STR_intToDecString(u32 val, u8 *str) { + + int len; + + if (val < 10)len = 1; + else + if (val < 100)len = 2; + else + if (val < 1000)len = 3; + else + if (val < 10000)len = 4; + else + if (val < 100000)len = 5; + else + if (val < 1000000)len = 6; + else + if (val < 10000000)len = 7; + else + if (val < 100000000)len = 8; + else + if (val < 1000000000)len = 9; + else len = 10; + + str += len; + str[0] = 0; + if (val == 0)*--str = '0'; + while (val) { + + *--str = '0' + val % 10; + val /= 10; + } + + + return len; +} + +void STR_intToDecStringMin(u32 val, u8 *str, u8 min_size) { + + int len; + u8 i; + + if (val < 10)len = 1; + else + if (val < 100)len = 2; + else + if (val < 1000)len = 3; + else + if (val < 10000)len = 4; + else + if (val < 100000)len = 5; + else + if (val < 1000000)len = 6; + else + if (val < 10000000)len = 7; + else + if (val < 100000000)len = 8; + else + if (val < 1000000000)len = 9; + else len = 10; + + if (len < min_size) { + + i = min_size - len; + while (i--)str[i] = '0'; + len = min_size; + } + str += len; + str[0] = 0; + if (val == 0)*--str = '0'; + while (val) { + + *--str = '0' + val % 10; + val /= 10; + } +} + + +u8 streq(u8 *str1, u8 *str2) { + + u8 s1; + u8 s2; + + for (;;) { + s1 = *str1++; + s2 = *str2++; + if (s1 >= 'a' && s1 <= 'z')s1 -= 0x20; + if (s2 >= 'a' && s2 <= 'z')s2 -= 0x20; + + if (s1 != s2) return 0; + + if (*str1 == 0 && *str2 == 0)return 1; + } +} + +u8 streql(u8 *str1, u8 *str2, u8 len) { + + u8 s1; + u8 s2; + while (len--) { + + s1 = *str1++; + s2 = *str2++; + if (s1 >= 'a' && s1 <= 'z')s1 -= 0x20; + if (s2 >= 'a' && s2 <= 'z')s2 -= 0x20; + + if (s1 != s2) return 0; + } + + return 1; +} + +u16 strContain(u8 *target, u8 *str) { + + u16 targ_len = slen(target); + u16 eq_len; + + + for (eq_len = 0; eq_len < targ_len;) { + + if (*str == 0)return 0; + if (*str++ == target[eq_len]) { + eq_len++; + } else { + eq_len = 0; + } + } + + if (eq_len != targ_len)return 0; + return 1; + +} + +u8 slen(u8 *str) { + + u8 len = 0; + while (*str++)len++; + return len; +} + +u8 scopy(u8 *src, u8 *dst) { + + u8 len = 0; + while (*src != 0) { + *dst++ = *src++; + len++; + } + *dst = 0; + return len; +} + +void strhicase(u8 *str, u8 len) { + + if (len) { + while (len--) { + if (*str >= 'a' && *str <= 'z')*str -= 0x20; + str++; + } + } else { + while (*str != 0) { + if (*str >= 'a' && *str <= 'z')*str -= 0x20; + str++; + } + } + +} diff --git a/sys.h b/sys.h new file mode 100644 index 0000000..892313c --- /dev/null +++ b/sys.h @@ -0,0 +1,61 @@ +/* + * File: tools.h + * Author: KRIK + * + * Created on 16 Àïðåëü 2011 ã., 2:30 + */ + +#ifndef _SYS_H +#define _SYS_H +#include "types.h" +#include "utils.h" +#include + + +void dma_read_s(void * ram_address, unsigned long pi_address, unsigned long len); +void dma_write_s(void * ram_address, unsigned long pi_address, unsigned long len); + + +void sleep(u32 ms); +void dma_write_sram(void* src, u32 offset, u32 size); +void dma_read_sram(void *dest, u32 offset, u32 size); +u8 getSaveType(); +u8 getCicType(u8 bios_cic); + +u16 strcon(u8 *str1, u8 *str2, u8 *dst, u16 max_len); +u8 slen(u8 *str); +u8 scopy(u8 *src, u8 *dst); + +u16 strContain(u8 *target, u8 *str); + +typedef struct SP_regs_s { + u32 mem_addr; + u32 dram_addr; + u32 rd_len; + u32 wr_len; + u32 status; +} _SP_regs_s; + +#define SP_PC *((volatile u32 *)0xA4080000) +#define SP_IBIST_REG *((volatile u32 *)0xA4080004) + +static volatile struct AI_regs_s * const AI_regs = (struct AI_regs_s *) 0xa4500000; +static volatile struct MI_regs_s * const MI_regs = (struct MI_regs_s *) 0xa4300000; +static volatile struct VI_regs_s * const VI_regs = (struct VI_regs_s *) 0xa4400000; +static volatile struct PI_regs_s * const PI_regs = (struct PI_regs_s *) 0xa4600000; +static volatile struct SP_regs_s * const SP_regs = (struct SP_regs_s *) 0xA4040000; + +extern u32 native_tv_mode; + +typedef struct { + u16 sd_speed; + u16 font_size; + u16 tv_mode; + u8 wall[256]; +} Options_st; + + +extern Options_st options; +extern u32 asm_date; +#endif /* _TOOLS_H */ + diff --git a/types.h b/types.h new file mode 100644 index 0000000..625c877 --- /dev/null +++ b/types.h @@ -0,0 +1,36 @@ +/* + * File: types.h + * Author: KRIK + * + * Created on 16 Àïðåëü 2011 ã., 2:24 + */ + +#include + +#ifndef _TYPES_H +#define _TYPES_H + +#define u8 unsigned char +#define u16 unsigned short +#define u32 unsigned long +#define u64 unsigned long long + +#define vu8 volatile unsigned char +#define vu16 volatile unsigned short +#define vu32 volatile unsigned long +#define vu64 volatile unsigned long long + +#define s8 signed char +#define s16 short +#define s32 long +#define s64 long long + + +typedef volatile uint64_t sim_vu64; +typedef volatile uint64_t sim_vu64; +typedef unsigned int sim_u32; +typedef uint64_t sim_u64; + + +#endif /* _TYPES_H */ + diff --git a/upload.sh b/upload.sh new file mode 100755 index 0000000..d4fba53 --- /dev/null +++ b/upload.sh @@ -0,0 +1,15 @@ +#! /bin/bash +sudo mount /dev/sdb1 /mnt +file=/mnt/ED64/OS64.v64 +if [ -e $file ] +then + echo -e "File $file exists - mount ok" + echo -e "copy..." + sudo cp OS64.v64 /mnt/ED64/ + sudo cp ALT64.INI /mnt/ED64/ + echo -e "umounting..." + sudo umount /mnt + echo -e "done..." +else + echo -e "File $file doesnt exists - sdcard problem?" +fi diff --git a/usb.c b/usb.c new file mode 100644 index 0000000..da43d86 --- /dev/null +++ b/usb.c @@ -0,0 +1,180 @@ + + +#include "everdrive.h" +#include "sys.h" +#include "types.h" +#include +#include "rom.h" + +u8 cmdTest(); +u8 cmdFill(); +u8 cmdReadRom(); +u8 cmdWriteRom(); + +u64 usb_buff[128]; +u8 *usb_buff8; // = (u8 *) usb_buff; + + +#define PI_BSD_DOM1_LAT_REG (PI_BASE_REG+0x14) + +/* PI dom1 pulse width (R/W): [7:0] domain 1 device R/W strobe pulse width */ +#define PI_BSD_DOM1_PWD_REG (PI_BASE_REG+0x18) + +/* PI dom1 page size (R/W): [3:0] domain 1 device page size */ +#define PI_BSD_DOM1_PGS_REG (PI_BASE_REG+0x1C) /* page size */ + +/* PI dom1 release (R/W): [1:0] domain 1 device R/W release duration */ +#define PI_BSD_DOM1_RLS_REG (PI_BASE_REG+0x20) +/* PI dom2 latency (R/W): [7:0] domain 2 device latency */ +#define PI_BSD_DOM2_LAT_REG (PI_BASE_REG+0x24) /* Domain 2 latency */ + +/* PI dom2 pulse width (R/W): [7:0] domain 2 device R/W strobe pulse width */ +#define PI_BSD_DOM2_PWD_REG (PI_BASE_REG+0x28) /* pulse width */ + +/* PI dom2 page size (R/W): [3:0] domain 2 device page size */ +#define PI_BSD_DOM2_PGS_REG (PI_BASE_REG+0x2C) /* page size */ + +/* PI dom2 release (R/W): [1:0] domain 2 device R/W release duration */ +#define PI_BSD_DOM2_RLS_REG (PI_BASE_REG+0x30) /* release duration */ + +#define PHYS_TO_K1(x) ((u32)(x)|0xA0000000) /* physical to kseg1 */ +#define IO_WRITE(addr,data) (*(volatile u32*)PHYS_TO_K1(addr)=(u32)(data)) +#define PI_BASE_REG 0x04600000 + +extern u8 system_cic; + +u8 usbListener() { + + volatile u16 resp; + volatile u8 cmd; + usb_buff8 = (u8 *) usb_buff; + + + if (evd_fifoRxf())return 0; + + resp = evd_fifoRd(usb_buff, 1); + + if (resp != 0) return 1; + + if (usb_buff8[0] != 'C' || usb_buff8[1] != 'M' || usb_buff8[2] != 'D')return 2; + + cmd = usb_buff8[3]; + + + switch (cmd) { + + case 'R': + resp = cmdReadRom(); + if (resp)return 10; + break; + case 'W': + resp = cmdWriteRom(); + if (resp)return 11; + break; + case 'T': + resp = cmdTest(); + if (resp)return 12; + break; + case 'F': + resp = cmdFill(); + if (resp)return 13; + break; + case 'S': + //IO_WRITE(PI_BSD_DOM1_PGS_REG, 0x0c); + //IO_WRITE(PI_BSD_DOM1_PGS_REG, 0x80); + //evdSetESaveType(SAVE_TYPE_EEP16k); + system_cic = CIC_6102; + evd_lockRegs(); + IO_WRITE(PI_STATUS_REG, 3); + sleep(2); + pif_boot(); + break; + + } + + + return 0; +} + +u8 cmdTest() { + + u16 resp; + usb_buff8[3] = 'k'; + resp = evd_fifoWr(usb_buff, 1); + if (resp)return 1; + + return 0; + +} + +u8 cmdFill() { + + u16 resp; + u32 i; + //console_printf("fill...\n"); + + for (i = 0; i < 512; i++) { + usb_buff8[i] = 0; + } + //console_printf("buff prepared\n"); + romFill(0, 0x200000, 0); + //console_printf("fill done\n"); + + usb_buff8[3] = 'k'; + resp = evd_fifoWr(usb_buff, 1); + + if (resp)return 1; + //console_printf("resp sent ok\n"); + + return 0; +} + +u8 cmdReadRom() { + + u16 resp; + u16 ptr; + u16 len; + u32 addr; + ptr = 4; + + + addr = usb_buff8[ptr++]; + addr <<= 8; + addr |= usb_buff8[ptr++]; + addr *= 2048; + + len = usb_buff8[ptr++]; + len <<= 8; + len |= usb_buff8[ptr++]; + + + resp = evd_fifoWrFromCart(addr, len); + if (resp)return 1; + + + return 0; +} + +u8 cmdWriteRom() { + + u16 resp; + u16 ptr; + u16 len; + u32 addr; + ptr = 4; + + addr = usb_buff8[ptr++]; + addr <<= 8; + addr |= usb_buff8[ptr++]; + addr *= 2048; + + len = usb_buff8[ptr++]; + len <<= 8; + len |= usb_buff8[ptr++]; + + resp = evd_fifoRdToCart(addr, len); + if (resp)return 1; + + return 0; + +} diff --git a/usb.h b/usb.h new file mode 100644 index 0000000..3683941 --- /dev/null +++ b/usb.h @@ -0,0 +1,16 @@ +/* + * File: fifo.h + * Author: KRIK + * + * Created on 22 Àïðåëü 2011 ã., 20:46 + */ + +#ifndef _FIFO_H +#define _FIFO_H + +#include "types.h" +u8 usbListener(); + + +#endif /* _FIFO_H */ + diff --git a/utils.c b/utils.c new file mode 100644 index 0000000..a5e7ec8 --- /dev/null +++ b/utils.c @@ -0,0 +1,1640 @@ +#include +#include +#include +#include +#include +#include +#include +#include "everdrive.h" +#include "sys.h" + +#include "types.h" +#include "utils.h" +#include "sram.h" + + + + +#define STBI_HEADER_FILE_ONLY +#include "stb_image.c" + +extern short int gCheats; /* 0 = off, 1 = select, 2 = all */ +extern short int force_tv; +extern short int boot_country; + +struct gscEntry { + char *description; + char *gscodes; + u16 count; + u16 state; + u16 mask; + u16 value; +}; +typedef struct gscEntry gscEntry_t; + +extern gscEntry_t gGSCodes[]; + + + +static u8 __attribute__((aligned(16))) dmaBuf[128*1024]; +static volatile struct _PI_regs_s * const _PI_regs = (struct _PI_regs_s *)0xa4600000; + +int is_valid_rom(unsigned char *buffer) +{ + /* Test if rom is a native .z64 image with header 0x80371240. [ABCD] */ + if((buffer[0]==0x80)&&(buffer[1]==0x37)&&(buffer[2]==0x12)&&(buffer[3]==0x40)) + return 0; + /* Test if rom is a byteswapped .v64 image with header 0x37804012. [BADC] */ + else if((buffer[0]==0x37)&&(buffer[1]==0x80)&&(buffer[2]==0x40)&&(buffer[3]==0x12)) + return 1; + /* Test if rom is a wordswapped .n64 image with header 0x40123780. [DCBA] */ + else if((buffer[0]==0x40)&&(buffer[1]==0x12)&&(buffer[2]==0x37)&&(buffer[3]==0x80)) + return 2; + else + return 0; +} + +void swap_header(unsigned char* header, int loadlength) +{ + unsigned char temp; + int i; + + /* Btyeswap if .v64 image. */ + if( header[0]==0x37) + { + // *imagetype = V64IMAGE; + for (i = 0; i < loadlength; i+=2) + { + temp= header[i]; + header[i]= header[i+1]; + header[i+1]=temp; + } + } + /* Wordswap if .n64 image. */ + else if( header[0]==0x40) + { + // *imagetype = N64IMAGE; + for (i = 0; i < loadlength; i+=4) + { + temp= header[i]; + header[i]= header[i+3]; + header[i+3]=temp; + temp= header[i+1]; + header[i+1]= header[i+2]; + header[i+2]=temp; + } + } + // else + // *imagetype = Z64IMAGE; +} + + + + +u8 getCicType(u8 bios_cic) { + + u8 cic_buff[2048]; + volatile u8 cic_chip; + volatile u32 val; // = *(u32 *) 0xB0000170; + if (bios_cic) { + evd_setCfgBit(ED_CFG_SDRAM_ON, 0); + sleep(10); + val = *(u32 *) 0xB0000170; + dma_read_s(cic_buff, 0xB0000040, 1024); + cic_chip = get_cic(cic_buff); + evd_setCfgBit(ED_CFG_SDRAM_ON, 1); + sleep(10); + + } else { + val = *(u32 *) 0xB0000170; + dma_read_s(cic_buff, 0xB0000040, 1024); + cic_chip = get_cic(cic_buff); + + } + return cic_chip; +} + + + +int get_cic(unsigned char *buffer) +{ + unsigned int crc; + // figure out the CIC + crc = CRC_Calculate(0, buffer, 1000); + switch(crc) + { + case 0x303faac9: + case 0xf0da3d50: + return 1; + case 0xf3106101: + return 2; + case 0xe7cd9d51: + return 3; + case 0x7ae65c9: + return 5; + case 0x86015f8f: + return 6; + } + return 2; +} + +int get_cic_save(char *cartid, int *cic, int *save) +{ + // variables + int NUM_CARTS = 137; + int i; + + //data arrays + //char *names[] = {"gnuboy64lite", "FRAMTestRom", "SRAMTestRom", "Worms Armageddon", "Super Smash Bros.", "Banjo-Tooie", "Blast Corps", "Bomberman Hero", "Body Harvest", "Banjo-Kazooie", "Bomberman 64", "Bomberman 64: Second Attack", "Command & Conquer", "Chopper Attack", "NBA Courtside 2 featuring Kobe Bryant", "Penny Racers", "Chameleon Twist", "Cruis'n USA", "Cruis'n World", "Legend of Zelda: Majora's Mask, The", "Donkey Kong 64", "Donkey Kong 64", "Donald Duck: Goin' Quackers", "Loony Toons: Duck Dodgers", "Diddy Kong Racing", "PGA European Tour", "Star Wars Episode 1 Racer", "AeroFighters Assault", "Bass Hunter 64", "Conker's Bad Fur Day", "F-1 World Grand Prix", "Star Fox 64", "F-Zero X", "GT64 Championship Edition", "GoldenEye 007", "Glover", "Bomberman 64", "Indy Racing 2000", "Indiana Jones and the Infernal Machine", "Jet Force Gemini", "Jet Force Gemini", "Earthworm Jim 3D", "Snowboard Kids 2", "Kirby 64: The Crystal Shards", "Fighters Destiny", "Major League Baseball featuring Ken Griffey Jr.", "Killer Instinct Gold", "Ken Griffey Jr's Slugfest", "Mario Kart 64", "Mario Party", "Lode Runner 3D", "Megaman 64", "Mario Tennis", "Mario Golf", "Mission: Impossible", "Mickey's Speedway USA", "Monopoly", "Paper Mario", "Multi-Racing Championship", "Big Mountain 2000", "Mario Party 3", "Mario Party 2", "Excitebike 64", "Dr. Mario 64", "Star Wars Episode 1: Battle for Naboo", "Kobe Bryant in NBA Courtside", "Excitebike 64", "Ogre Battle 64: Person of Lordly Caliber", "Pokémon Stadium 2", "Pokémon Stadium 2", "Perfect Dark", "Pokémon Snap", "Hey you, Pikachu!", "Pokémon Snap", "Pokémon Puzzle League", "Pokémon Stadium", "Pokémon Stadium", "Pilotwings 64", "Top Gear Overdrive", "Resident Evil 2", "New Tetris, The", "Star Wars: Rogue Squadron", "Ridge Racer 64", "Star Soldier: Vanishing Earth", "AeroFighters Assault", "Starshot Space Circus", "Super Mario 64", "Starcraft 64", "Rocket: Robot on Wheels", "Space Station Silicon Valley", "Star Wars: Shadows of the Empire", "Tigger's Honey Hunt", "1080º Snowboarding", "Tom & Jerry in Fists of Furry", "Mischief Makers", "All-Star Tennis '99", "Tetrisphere", "V-Rally Edition '99", "V-Rally Edition '99", "WCW/NWO Revenge", "WWF: No Mercy", "Waialae Country Club: True Golf Classics", "Wave Race 64", "Worms Armageddon", "WWF: Wrestlemania 2000", "Cruis'n Exotica", "Yoshi's Story", "Harvest Moon 64", "Legend of Zelda: Ocarina of Time, The", "Legend of Zelda: Majora's Mask, The", "Airboarder 64", "Bakuretsu Muteki Bangaioh", "Choro-Q 64 II", "Custom Robo", "Custom Robo V2", "Densha de Go! 64", "Doraemon: Mittsu no Seireiseki", "Dezaemon 3D", "Transformers Beast Wars", "Transformers Beast Wars Metals", "64 Trump Collection", "Bass Rush", "ECW Hardcore Revolution", "40 Winks", "Aero Gauge", "Aidyn Chronicles The First Mage", "Derby Stallion 64", "Doraemon 2 - Hikari no Shinden", "Doraemon 3 - Nobi Dai No Machi SOS", "F-1 World Grand Prix II", "Fushigi no Dungeon - Furai no Shiren 2", "Heiwa Pachinko World 64", "Neon Genesis Evangelion", "Racing Simulation", "Tsumi to Batsu", "Sonic Wings Assault", "Virtual Pro Wrestling", "Virtual Pro Wrestling 2", "Wild Choppers"}; + char *cartIDs[] = {"DZ", "B6", "ZY", "ZZ", "AD", "AL", "B7", "BC", "BD", "BH", "BK", "BM", "BV", "CC", "CH", "CK", "CR", "CT", "CU", "CW", "DL", "DO", "DP", "DQ", "DU", "DY", "EA", "EP", "ER", "FH", "FU", "FW", "FX", "FZ", "GC", "GE", "GV", "HA", "IC", "IJ", "JD", "JF", "JM", "K2", "K4", "KA", "KG", "KI", "KJ", "KT", "LB", "LR", "M6", "M8", "MF", "MI", "ML", "MO", "MQ", "MR", "MU", "MV", "MW", "MX", "N6", "NA", "NB", "NX", "OB", "P2", "P3", "PD", "PF", "PG", "PH", "PN", "PO", "PS", "PW", "RC", "RE", "RI", "RS", "RZ", "S6", "SA", "SC", "SM", "SQ", "SU", "SV", "SW", "T9", "TE", "TJ", "TM", "TN", "TP", "VL", "VY", "W2", "W4", "WL", "WR", "WU", "WX", "XO", "YS", "YW", "ZL", "ZS", "AB", "BN", "CG", "CX", "CZ", "D6", "DR", "DZ", "OH", "TB", "TC", "VB", "WI", "4W", "AG", "AY", "DA", "D2", "3D", "F2", "SI", "HP", "EV", "MG", "GU", "SA", "VP", "A2", "WC"}; + + //int saveTypes[] = {5, 1, 6, 5, 5, 5, 5, 5, 5, 4, 5, 4, 5, 5, 5, 6, 4, 6, 6, 5, 5, 5, 5, 6, 5, 5, 6, 5, 5, 1, 5, 5, 5, 5, 5, 5, 4, 4, 5, 5, 5, 5, 1, 5, 4, 5, 5, 5, 4, 6, 1, 5, 5, 5, 4, 5, 5, 6, 5, 6, 5, 5, 6, 6, 1, 4, 4, 6, 4, 5, 4, 4, 4, 4, 5, 5, 1, 1, 5, 6, 5, 5, 5, 5, 4, 5, 5, 5, 4, 1, 5, 5, 5, 5, 5, 5, 1, 4, 5, 5, 5, 1, 5, 6, 1, 1, 4, 5, 5, 5, 5, 6, 1, 5, 1, 5, 5, 5, 1, 1, 5, 5, 1, 1, 6, 6, 6, 4, 5, 6, 5, 5, 5, 1, 1, 5}; + // Banjo-Tooie B7 -> set to sram 'cause crk converts ek16->sram + int saveTypes[] = {2, 1, 5, 1, 3, 1, 1, 3, 3, 3, 3, 3, 3, 5, 3, 5, 3, 3, 3, 4, 5, 4, 4, 3, 3, 3, 3, 4, 3, 3, 4, 3, 3, 1, 3, 3, 3, 3, 3, 3, 5, 5, 3, 3, 3, 3, 1, 3, 5, 3, 3, 3, 5, 4, 1, 3, 3, 3, 5, 3, 3, 4, 3, 4, 3, 3, 4, 4, 1, 5, 5, 4, 5, 3, 5, 5, 5, 5, 3, 3, 1, 1, 3, 4, 3, 3, 3, 3, 5, 3, 3, 3, 5, 1, 3, 3, 3, 3, 3, 3, 1, 5, 3, 3, 3, 1, 3, 4, 1, 1, 5, 3, 3, 3, 3, 4, 1, 3, 1, 3, 3, 3, 1, 1, 3, 3, 1, 1, 4, 4, 4, 5, 3, 4, 3, 3, 3, 1, 1, 3}; + + //bt cic to 2 pos6 was 5 + int cicTypes[] = {2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2, 6, 5, 5, 5, 2, 2, 3, 2, 2, 2, 2, 5, 2, 1, 6, 2, 2, 2, 2, 2, 2, 5, 5, 2, 2, 3, 2, 3, 2, 3, 2, 2, 2, 2, 2, 2, 2, 5, 2, 3, 2, 2, 2, 2, 3, 2, 2, 3, 3, 2, 3, 3, 5, 3, 2, 3, 2, 3, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 6, 2, 5, 5, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2}; + + // search for cartid + for (i=0; i + IO_WRITE(PI_BSD_DOM1_LAT_REG, 0x40); + IO_WRITE(PI_BSD_DOM1_PWD_REG, 0x12); + IO_WRITE(PI_BSD_DOM1_PGS_REG, 0x07); + IO_WRITE(PI_BSD_DOM1_RLS_REG, 0x03); + + IO_WRITE(PI_BSD_DOM2_LAT_REG, 0x40); + IO_WRITE(PI_BSD_DOM2_PWD_REG, 0x12); + IO_WRITE(PI_BSD_DOM2_PGS_REG, 0x07); + IO_WRITE(PI_BSD_DOM2_RLS_REG, 0x03); +} + +/* + * Load an image from the rom filesystem, returning a pointer to the + * sprite that hold the image. + */ +sprite_t *loadImageDFS(char *fname) +{ + int size, x, y, n, fd; + u8 *tbuf; + u8 *ibuf; + sprite_t *sbuf; + + fd = dfs_open(fname); + if (fd < 0) + return 0; // couldn't open image + + size = dfs_size(fd); + tbuf = malloc(size); + if (!tbuf) + { + dfs_close(fd); + return 0; // out of memory + } + + dfs_read(tbuf, 1, size, fd); + dfs_close(fd); + + ibuf = stbi_load_from_memory(tbuf, size, &x, &y, &n, 4); + free(tbuf); + if (!ibuf) + return 0; // couldn't decode image + + sbuf = (sprite_t*)malloc(sizeof(sprite_t) + x * y * 2); + if (!sbuf) + { + stbi_image_free(ibuf); + return 0; // out of memory + } + sbuf->width = x; + sbuf->height = y; + sbuf->bitdepth = 2; + sbuf->format = 0; + sbuf->hslices = x / 32; + sbuf->vslices = y / 16; + + color_t *src = (color_t*)ibuf; + u16 *dst = (u16*)((u32)sbuf + sizeof(sprite_t)); + + for (int j=0; jdata, sbuf->width * sbuf->height * sbuf->bitdepth ); + //data_cache_writeback_invalidate( sbuf->data, sbuf->width * sbuf->height * sbuf->bitdepth ); + // data_cache_hit_writeback_invalidate(buffer,size); + + stbi_image_free(ibuf); + return sbuf; +} + + +sprite_t *loadImage32(u8 *png, int size) +{ + int x, y, n, fd; + u8 *tbuf; + u32 *ibuf; + sprite_t *sbuf; + + tbuf = malloc(size); + memcpy(tbuf,png,size); + + ibuf = stbi_load_from_memory(tbuf, size, &x, &y, &n, 4); + free(tbuf); + if (!ibuf) + return 0; // couldn't decode image + + sbuf = (sprite_t*)malloc(sizeof(sprite_t) + x * y * 4); + if (!sbuf) + { + stbi_image_free(ibuf); + return 0; // out of memory + } + sbuf->width = x; + sbuf->height = y; + sbuf->bitdepth = 4; + sbuf->format = 0; + sbuf->hslices = x / 32; + sbuf->vslices = y / 32; + + // color_t *src = (color_t*)ibuf; + u32 *dst = (u32*)((u32)sbuf + sizeof(sprite_t)); + + for (int j=0; jdata, sbuf->width * sbuf->height * sbuf->bitdepth ); + //data_cache_writeback_invalidate( sbuf->data, sbuf->width * sbuf->height * sbuf->bitdepth ); + // data_cache_hit_writeback_invalidate(buffer,size); + + stbi_image_free(ibuf); + return sbuf; +} + + +sprite_t *loadImage32DFS(char *fname) +{ + int size, x, y, n, fd; + u8 *tbuf; + u32 *ibuf; + sprite_t *sbuf; + + fd = dfs_open(fname); + if (fd < 0) + return 0; // couldn't open image + + size = dfs_size(fd); + tbuf = malloc(size); + if (!tbuf) + { + dfs_close(fd); + return 0; // out of memory + } + + dfs_read(tbuf, 1, size, fd); + dfs_close(fd); + + ibuf = stbi_load_from_memory(tbuf, size, &x, &y, &n, 4); + free(tbuf); + if (!ibuf) + return 0; // couldn't decode image + + sbuf = (sprite_t*)malloc(sizeof(sprite_t) + x * y * 4); + if (!sbuf) + { + stbi_image_free(ibuf); + return 0; // out of memory + } + sbuf->width = x; + sbuf->height = y; + sbuf->bitdepth = 4; + sbuf->format = 0; + sbuf->hslices = x / 32; + sbuf->vslices = y / 32; + + // color_t *src = (color_t*)ibuf; + u32 *dst = (u32*)((u32)sbuf + sizeof(sprite_t)); + + for (int j=0; jdata, sbuf->width * sbuf->height * sbuf->bitdepth ); + //data_cache_writeback_invalidate( sbuf->data, sbuf->width * sbuf->height * sbuf->bitdepth ); + // data_cache_hit_writeback_invalidate(buffer,size); + + stbi_image_free(ibuf); + return sbuf; +} + +/* + * Draw an image to the screen using the sprite passed. + */ +void drawImage(display_context_t dcon, sprite_t *sprite) +{ + int x, y = 0; + + rdp_sync(SYNC_PIPE); + rdp_set_default_clipping(); + rdp_enable_texture_copy(); + rdp_attach_display(dcon); + // Draw image + for (int j=0; jvslices; j++) + { + x = 0; + for (int i=0; ihslices; i++) + { + rdp_sync(SYNC_PIPE); + rdp_load_texture_stride(0, 0, MIRROR_DISABLED, sprite, j*sprite->hslices + i); + rdp_draw_sprite(0, x, y); + x += 32; + } + y += 16; + } + rdp_detach_display(); +} + + +#define CIC_6101 1 +#define CIC_6102 2 +#define CIC_6103 3 +#define CIC_6104 4 +#define CIC_6105 5 +#define CIC_6106 6 + + +void globalTest(void){ + +gCheats=1; + +} + + +void simulate_boot(u32 cic_chip, u8 gBootCic) +{ + + if (cic_chip == CIC_6104) + cic_chip = CIC_6102; + + u32 ix, sz, cart, country; + vu32 *src, *dst; + u32 info = *(vu32 *)0xB000003C; + vu64 *gGPR = (vu64 *)0xA03E0000; + //vu64 *gGPR = (vu64 *)0xA0080000; //n + vu32 *codes = (vu32 *)0xA0000180; + u64 bootAddr = 0xFFFFFFFFA4000040LL; + char *cp, *vp, *tp; + char temp[8]; + int i, type, val; + int curr_cheat = 0; + + cart = info >> 16; + country = (info >> 8) & 0xFF; + + if(boot_country!=0){ + switch(boot_country){ + case 1: country = 0x45; break; //ntsc region + case 2: country = 0x50; break; //pal region + default: break; + } + } + + // clear XBUS/Flush/Freeze + ((vu32 *)0xA4100000)[3] = 0x15; + + + sz = (gBootCic != CIC_6105) ? *(vu32 *)0xA0000318 : *(vu32 *)0xA00003F0; + if (cic_chip == CIC_6105) + *(vu32 *)0xA00003F0 = sz; + else + *(vu32 *)0xA0000318 = sz; + + // clear some OS globals for cleaner boot + *(vu32 *)0xA000030C = 0; // cold boot + memset((void *)0xA000031C, 0, 64); // clear app nmi buffer + + + + if (gCheats) + { + + u16 xv, yv, zv; + u32 xx; + vu32 *sp, *dp; + // get rom os boot segment - note, memcpy won't work for copying rom + sp = (vu32 *)0xB0001000; + dp = (vu32 *)0xA02A0000; + for (ix=0; ix<0x100000; ix++) + *dp++ = *sp++; + // default boot address with cheats + sp = (vu32 *)0xB0000008; + bootAddr = 0xFFFFFFFF00000000LL | *sp; + + // move general int handler + sp = (vu32 *)0xA0000180; + dp = (vu32 *)0xA0000120; + for (ix=0; ix<0x60; ix+=4) + *dp++ = *sp++; + + // insert new general int handler prologue + *codes++ = 0x401a6800; // mfc0 k0,c0_cause + *codes++ = 0x241b005c; // li k1,23*4 + *codes++ = 0x335a007c; // andi k0,k0,0x7c + *codes++ = 0x175b0012; // bne k0,k1,0x1d8 + *codes++ = 0x00000000; // nop + *codes++ = 0x40809000; // mtc0 zero,c0_watchlo + *codes++ = 0x401b7000; // mfc0 k1,c0_epc + *codes++ = 0x8f7a0000; // lw k0,0(k1) + *codes++ = 0x3c1b03e0; // lui k1,0x3e0 + *codes++ = 0x035bd024; // and k0,k0,k1 + *codes++ = 0x001ad142; // srl k0,k0,0x5 + *codes++ = 0x3c1ba000; // lui k1,0xa000 + *codes++ = 0x8f7b01cc; // lw k1,0x01cc(k1) + *codes++ = 0x035bd025; // or k0,k0,k1 + *codes++ = 0x3c1ba000; // lui k1,0xa000 + *codes++ = 0xaf7a01cc; // sw k0,0x01cc(k1) + *codes++ = 0x3c1b8000; // lui k1,0x8000 + *codes++ = 0xbf7001cc; // cache 0x10,0x01cc(k1) + *codes++ = 0x3c1aa000; // lui k0,0xa000 + *codes++ = 0x37400120; // ori zero,k0,0x120 + *codes++ = 0x42000018; // eret + *codes++ = 0x00000000; // nop + + // process cheats + while (gGSCodes[curr_cheat].count != 0xFFFF) + { + if (!gGSCodes[curr_cheat].state || !gGSCodes[curr_cheat].count) + { + // cheat not enabled or no codes, skip + curr_cheat++; + continue; + } + + for (i=0; i boot address = 800XXXXX, msn ignored + temp[0] = cp[2]; + temp[1] = cp[3]; + temp[2] = cp[4]; + temp[3] = cp[5]; + temp[4] = cp[6]; + temp[5] = cp[7]; + temp[6] = 0; + val = strtol(temp, (char **)NULL, 16); + bootAddr = 0xFFFFFFFF80000000LL | (val & 0xFFFFF); + break; + case 0xEE: + // deactivate expansion ram using 1st method + // EE000000 0000 + if (cic_chip == CIC_6105) + *(vu32 *)0xA00003F0 = 0x00400000; + else + *(vu32 *)0xA0000318 = 0x00400000; + break; + case 0xF0: + // write 8-bit value to ram before boot + // F0XXXXXX 00YY + temp[0] = cp[2]; + temp[1] = cp[3]; + temp[2] = cp[4]; + temp[3] = cp[5]; + temp[4] = cp[6]; + temp[5] = cp[7]; + temp[6] = 0; + val = strtol(temp, (char **)NULL, 16); + val -= (bootAddr & 0xFFFFFF); + tp = (char *)(0xFFFFFFFFA02A0000LL + val); + if (gGSCodes[curr_cheat].mask) + { + val = gGSCodes[curr_cheat].value & gGSCodes[curr_cheat].mask; + } + else + { + temp[0] = vp[2]; + temp[1] = vp[3]; + temp[2] = 0; + val = strtol(temp, (char **)NULL, 16); + } + *tp = val & 0x00FF; + break; + case 0xF1: + // write 16-bit value to ram before boot + // F1XXXXXX YYYY + temp[0] = cp[2]; + temp[1] = cp[3]; + temp[2] = cp[4]; + temp[3] = cp[5]; + temp[4] = cp[6]; + temp[5] = cp[7]; + temp[6] = 0; + val = strtol(temp, (char **)NULL, 16); + val -= (bootAddr & 0xFFFFFF); + tp = (char *)(0xFFFFFFFFA02A0000LL + val); + if (gGSCodes[curr_cheat].mask) + { + val = gGSCodes[curr_cheat].value & gGSCodes[curr_cheat].mask; + } + else + { + temp[0] = vp[0]; + temp[1] = vp[1]; + temp[2] = vp[2]; + temp[3] = vp[3]; + temp[4] = 0; + val = strtol(temp, (char **)NULL, 16); + } + *tp++ = (val >> 8) & 0x00FF; + *tp = val & 0x00FF; + break; + case 0xFF: + // set code base + // FFXXXXXX 0000 + temp[0] = cp[2]; + temp[1] = cp[3]; + temp[2] = cp[4]; + temp[3] = cp[5]; + temp[4] = cp[6]; + temp[5] = cp[7]; + temp[6] = 0; + val = strtol(temp, (char **)NULL, 16); + //codes = (vu32 *)(0xA0000000 | (val & 0xFFFFFF)); + break; + } + } + curr_cheat++; + } + + // generate jump to moved general int handler + *codes++ = 0x3c1a8000; // lui k0,0x8000 + *codes++ = 0x375a0120; // ori k0,k0,0x120 + *codes++ = 0x03400008; // jr k0 + *codes++ = 0x00000000; // nop + + // flush general int handler memory + data_cache_hit_writeback_invalidate((void *)0x80000120, 0x2E0); + inst_cache_hit_invalidate((void *)0x80000120, 0x2E0); + + // flush os boot segment + data_cache_hit_writeback_invalidate((void *)0x802A0000, 0x100000); + + // flush os boot segment memory + data_cache_hit_writeback_invalidate((void *)bootAddr, 0x100000); + inst_cache_hit_invalidate((void *)bootAddr, 0x100000); + } + + // Copy low 0x1000 bytes to DMEM + //copy bootcode to RSP DMEM starting at 0xA4000040; <- bootaddr + src = (vu32 *)0xB0000000; //i think 0xB0000040; is the right value + dst = (vu32 *)0xA4000000; //0xA4000040; + for (ix=0; ix<(0x1000>>2); ix++) + dst[ix] = src[ix]; + + + // Need to copy crap to IMEM for CIC-6105 boot. + dst = (vu32 *)0xA4001000; + + // register values due to pif boot for CiC chip and country code, and IMEM crap + gGPR[0]=0x0000000000000000LL; + gGPR[6]=0xFFFFFFFFA4001F0CLL; + gGPR[7]=0xFFFFFFFFA4001F08LL; + gGPR[8]=0x00000000000000C0LL; + gGPR[9]=0x0000000000000000LL; + gGPR[10]=0x0000000000000040LL; + gGPR[11]=bootAddr; // 0xFFFFFFFFA4000040LL; + gGPR[16]=0x0000000000000000LL; + gGPR[17]=0x0000000000000000LL; + gGPR[18]=0x0000000000000000LL; + gGPR[19]=0x0000000000000000LL; + gGPR[21]=0x0000000000000000LL; + gGPR[26]=0x0000000000000000LL; + gGPR[27]=0x0000000000000000LL; + gGPR[28]=0x0000000000000000LL; + gGPR[29]=0xFFFFFFFFA4001FF0LL; + gGPR[30]=0x0000000000000000LL; + + switch (country) + { + case 0x44: //Germany + case 0x46: //french + case 0x49: //Italian + case 0x50: //Europe + case 0x53: //Spanish + case 0x55: //Australia + case 0x58: // ???? + case 0x59: // X (PAL) + { + + if(force_tv!=0) + *(u32 *) 0x80000300 = force_tv; //pal + else + *(u32 *) 0x80000300 = 2; + + switch (cic_chip) + { + case CIC_6102: + gGPR[5]=0xFFFFFFFFC0F1D859LL; + gGPR[14]=0x000000002DE108EALL; + gGPR[24]=0x0000000000000000LL; + break; + case CIC_6103: + gGPR[5]=0xFFFFFFFFD4646273LL; + gGPR[14]=0x000000001AF99984LL; + gGPR[24]=0x0000000000000000LL; + break; + case CIC_6105: + dst[0x04>>2] = 0xBDA807FC; + gGPR[5]=0xFFFFFFFFDECAAAD1LL; + gGPR[14]=0x000000000CF85C13LL; + gGPR[24]=0x0000000000000002LL; + break; + case CIC_6106: + gGPR[5]=0xFFFFFFFFB04DC903LL; + gGPR[14]=0x000000001AF99984LL; + gGPR[24]=0x0000000000000002LL; + break; + } + + gGPR[20]=0x0000000000000000LL; + gGPR[23]=0x0000000000000006LL; + gGPR[31]=0xFFFFFFFFA4001554LL; + break; + } + case 0x37: // 7 (Beta) + case 0x41: // ???? + case 0x45: //USA + case 0x4A: //Japan + + if(force_tv!=0) + *(u32 *) 0x80000300 = force_tv; //pal + else + *(u32 *) 0x80000300 = 1; //ntsc + + default: + { + switch (cic_chip) + { + case CIC_6102: + gGPR[5]=0xFFFFFFFFC95973D5LL; + gGPR[14]=0x000000002449A366LL; + break; + case CIC_6103: + gGPR[5]=0xFFFFFFFF95315A28LL; + gGPR[14]=0x000000005BACA1DFLL; + break; + case CIC_6105: + dst[0x04>>2] = 0x8DA807FC; + gGPR[5]=0x000000005493FB9ALL; + gGPR[14]=0xFFFFFFFFC2C20384LL; + break; + case CIC_6106: + gGPR[5]=0xFFFFFFFFE067221FLL; + gGPR[14]=0x000000005CD2B70FLL; + break; + } + + gGPR[20]=0x0000000000000001LL; + gGPR[23]=0x0000000000000000LL; + gGPR[24]=0x0000000000000003LL; + gGPR[31]=0xFFFFFFFFA4001550LL; + break; + } + } + + switch (cic_chip) + { + case CIC_6101: + gGPR[22]=0x000000000000003FLL; + break; + case CIC_6102: + gGPR[1]=0x0000000000000001LL; + gGPR[2]=0x000000000EBDA536LL; + gGPR[3]=0x000000000EBDA536LL; + gGPR[4]=0x000000000000A536LL; + gGPR[12]=0xFFFFFFFFED10D0B3LL; + gGPR[13]=0x000000001402A4CCLL; + gGPR[15]=0x000000003103E121LL; + gGPR[22]=0x000000000000003FLL; + gGPR[25]=0xFFFFFFFF9DEBB54FLL; + break; + case CIC_6103: + gGPR[1]=0x0000000000000001LL; + gGPR[2]=0x0000000049A5EE96LL; + gGPR[3]=0x0000000049A5EE96LL; + gGPR[4]=0x000000000000EE96LL; + gGPR[12]=0xFFFFFFFFCE9DFBF7LL; + gGPR[13]=0xFFFFFFFFCE9DFBF7LL; + gGPR[15]=0x0000000018B63D28LL; + gGPR[22]=0x0000000000000078LL; + gGPR[25]=0xFFFFFFFF825B21C9LL; + break; + case CIC_6105: + dst[0x00>>2] = 0x3C0DBFC0; + dst[0x08>>2] = 0x25AD07C0; + dst[0x0C>>2] = 0x31080080; + dst[0x10>>2] = 0x5500FFFC; + dst[0x14>>2] = 0x3C0DBFC0; + dst[0x18>>2] = 0x8DA80024; + dst[0x1C>>2] = 0x3C0BB000; + gGPR[1]=0x0000000000000000LL; + gGPR[2]=0xFFFFFFFFF58B0FBFLL; + gGPR[3]=0xFFFFFFFFF58B0FBFLL; + gGPR[4]=0x0000000000000FBFLL; + gGPR[12]=0xFFFFFFFF9651F81ELL; + gGPR[13]=0x000000002D42AAC5LL; + gGPR[15]=0x0000000056584D60LL; + gGPR[22]=0x0000000000000091LL; + gGPR[25]=0xFFFFFFFFCDCE565FLL; + break; + case CIC_6106: + gGPR[1]=0x0000000000000000LL; + gGPR[2]=0xFFFFFFFFA95930A4LL; + gGPR[3]=0xFFFFFFFFA95930A4LL; + gGPR[4]=0x00000000000030A4LL; + gGPR[12]=0xFFFFFFFFBCB59510LL; + gGPR[13]=0xFFFFFFFFBCB59510LL; + gGPR[15]=0x000000007A3C07F4LL; + gGPR[22]=0x0000000000000085LL; + gGPR[25]=0x00000000465E3F72LL; + break; + } + + + // set HW registers + IO_WRITE(PI_STATUS_REG, 0x03); + switch (cart) + { + case 0x4258: // 'BX' - Battle Tanx + + IO_WRITE(PI_BSD_DOM1_LAT_REG, 0x80); + IO_WRITE(PI_BSD_DOM1_RLS_REG, 0x37); + IO_WRITE(PI_BSD_DOM1_PWD_REG, 0x12); + IO_WRITE(PI_BSD_DOM1_PGS_REG, 0x40); + + break; + + case 0x4237: // 'B7' - Banjo Tooie + + IO_WRITE(PI_BSD_DOM1_LAT_REG, 0x80); + IO_WRITE(PI_BSD_DOM1_RLS_REG, 0x37); + IO_WRITE(PI_BSD_DOM1_PWD_REG, 0x12); + IO_WRITE(PI_BSD_DOM1_PGS_REG, 0x40); + + break; + + + case 0x5A4C: // 'ZL' - Zelda OOT + +/* + IO_WRITE(PI_BSD_DOM2_LAT_REG, 0x00000005); + IO_WRITE(PI_BSD_DOM2_PWD_REG, 0x0000000C); + IO_WRITE(PI_BSD_DOM2_PGS_REG, 0x0000000D); + IO_WRITE(PI_BSD_DOM2_RLS_REG, 0x00000002); +*/ + +/* unstable + IO_WRITE(PI_BSD_DOM1_LAT_REG, 0x00000040); + IO_WRITE(PI_BSD_DOM1_RLS_REG, 0x00803712); + IO_WRITE(PI_BSD_DOM1_PWD_REG, 0x00008037); + IO_WRITE(PI_BSD_DOM1_PGS_REG, 0x00000803); + */ + break; + default: + break; + } + + + + +/* + + +load immediate: + +li register_destination, value +#load immediate value into destination register + + --- + + Registers in coprocessor 0 cannot be used directly by MIPS instructions. Instead, there are two + instructions that work much like load and store instructions. The mfc0 (move from coprocessor 0) instruction + loads data from a coprocessor 0 register into a CPU register. The mtc0 likewise stores data in a cp0 register. + +Note + +The mtc0 instruction, like the store instruction has the destination last. This is especially important to note, + since the syntax for cp0 registers looks the same as the syntax for CPU registers. For example, the following copies + the contents of CPU register 13 to cp0 register 12. + mtc0 $13, $12 + + + mthi 010001 MoveTo hi = $s + + + LUI -- Load upper immediate + +Description: +The immediate value is shifted left 16 bits and stored in the register. The lower 16 bits are zeroes. +Operation: +$t = (imm << 16); advance_pc (4); +Syntax: +lui $t, imm +Encoding: +0011 11-- ---t tttt iiii iiii iiii iiii + + * */ + + // now set MIPS registers - set CP0, and then GPRs, then jump thru gpr11 (which is usually 0xA400040) + if (!gCheats) + + asm(".set noat\n\t" + ".set noreorder\n\t" + "li $8,0x34000000\n\t" + "mtc0 $8,$12\n\t" + "nop\n\t" + "nop\n\t" + "li $9,0x0006E463\n\t" + "mtc0 $9,$16\n\t" + "nop\n\t" + "nop\n\t" + "li $8,0x00005000\n\t" + "mtc0 $8,$9\n\t" + "nop\n\t" + "nop\n\t" + "li $9,0x0000005C\n\t" + "mtc0 $9,$13\n\t" + "nop\n\t" + "nop\n\t" + "li $8,0x007FFFF0\n\t" + "mtc0 $8,$4\n\t" + "nop\n\t" + "nop\n\t" + "nop\n\t" + "li $9,0xFFFFFFFF\n\t" + "mtc0 $9,$14\n\t" + "nop\n\t" + "nop\n\t" + "mtc0 $9,$8\n\t" + "nop\n\t" + "nop\n\t" + "mtc0 $9,$30\n\t" + "nop\n\t" + "nop\n\t" + "lui $8,0\n\t" + "mthi $8\n\t" + "nop\n\t" + "nop\n\t" + "mtlo $8\n\t" + "nop\n\t" + "nop\n\t" + "ctc1 $8,$31\n\t" + "nop\n\t" + "lui $31,0xA03E\n\t" + //"lui $31,0xA008\n\t" + "ld $1,0x08($31)\n\t" + "ld $2,0x10($31)\n\t" + "ld $3,0x18($31)\n\t" + "ld $4,0x20($31)\n\t" + "ld $5,0x28($31)\n\t" + "ld $6,0x30($31)\n\t" + "ld $7,0x38($31)\n\t" + "ld $8,0x40($31)\n\t" + "ld $9,0x48($31)\n\t" + "ld $10,0x50($31)\n\t" + "ld $11,0x58($31)\n\t" + "ld $12,0x60($31)\n\t" + "ld $13,0x68($31)\n\t" + "ld $14,0x70($31)\n\t" + "ld $15,0x78($31)\n\t" + "ld $16,0x80($31)\n\t" + "ld $17,0x88($31)\n\t" + "ld $18,0x90($31)\n\t" + "ld $19,0x98($31)\n\t" + "ld $20,0xA0($31)\n\t" + "ld $21,0xA8($31)\n\t" + "ld $22,0xB0($31)\n\t" + "ld $23,0xB8($31)\n\t" + "ld $24,0xC0($31)\n\t" + "ld $25,0xC8($31)\n\t" + "ld $26,0xD0($31)\n\t" + "ld $27,0xD8($31)\n\t" + "ld $28,0xE0($31)\n\t" + "ld $29,0xE8($31)\n\t" + "ld $30,0xF0($31)\n\t" + "ld $31,0xF8($31)\n\t" + "jr $11\n\t" + "nop" + ::: "$8" ); + + + + + else + asm(".set noreorder\n\t" + "li $8,0x34000000\n\t" + "mtc0 $8,$12\n\t" + "nop\n\t" + "li $9,0x0006E463\n\t" + "mtc0 $9,$16\n\t" + "nop\n\t" + "li $8,0x00005000\n\t" + "mtc0 $8,$9\n\t" + "nop\n\t" + "li $9,0x0000005C\n\t" + "mtc0 $9,$13\n\t" + "nop\n\t" + "li $8,0x007FFFF0\n\t" + "mtc0 $8,$4\n\t" + "nop\n\t" + "li $9,0xFFFFFFFF\n\t" + "mtc0 $9,$14\n\t" + "nop\n\t" + "mtc0 $9,$30\n\t" + "nop\n\t" + "lui $8,0\n\t" + "mthi $8\n\t" + "nop\n\t" + "mtlo $8\n\t" + "nop\n\t" + "ctc1 $8,$31\n\t" + "nop\n\t" + "li $9,0x00000183\n\t" + "mtc0 $9,$18\n\t" + "nop\n\t" + "mtc0 $zero,$19\n\t" + "nop\n\t" + "lui $8,0xA03C\n\t" + "la $9,2f\n\t" + "la $10,9f\n\t" + ".set noat\n" + "1:\n\t" + "lw $2,($9)\n\t" + "sw $2,($8)\n\t" + "addiu $8,$8,4\n\t" + "addiu $9,$9,4\n\t" + "bne $9,$10,1b\n\t" + "nop\n\t" + "lui $8,0xA03C\n\t" + "jr $8\n\t" + "nop\n" + "2:\n\t" + "lui $9,0xB000\n\t" + "lw $9,8($9)\n\t" + "lui $8,0x2000\n\t" + "or $8,$8,$9\n\t" + "lui $9,0xA02A\n\t" + "lui $10,0xA03A\n\t" + "3:\n\t" + "lw $2,($9)\n\t" + "sw $2,($8)\n\t" + "addiu $8,$8,4\n\t" + "addiu $9,$9,4\n\t" + "bne $9,$10,3b\n\t" + "nop\n\t" + "lui $31,0xA03E\n\t" + "ld $1,0x08($31)\n\t" + "ld $2,0x10($31)\n\t" + "ld $3,0x18($31)\n\t" + "ld $4,0x20($31)\n\t" + "ld $5,0x28($31)\n\t" + "ld $6,0x30($31)\n\t" + "ld $7,0x38($31)\n\t" + "ld $8,0x40($31)\n\t" + "ld $9,0x48($31)\n\t" + "ld $10,0x50($31)\n\t" + "ld $11,0x58($31)\n\t" + "ld $12,0x60($31)\n\t" + "ld $13,0x68($31)\n\t" + "ld $14,0x70($31)\n\t" + "ld $15,0x78($31)\n\t" + "ld $16,0x80($31)\n\t" + "ld $17,0x88($31)\n\t" + "ld $18,0x90($31)\n\t" + "ld $19,0x98($31)\n\t" + "ld $20,0xA0($31)\n\t" + "ld $21,0xA8($31)\n\t" + "ld $22,0xB0($31)\n\t" + "ld $23,0xB8($31)\n\t" + "ld $24,0xC0($31)\n\t" + "ld $25,0xC8($31)\n\t" + "ld $26,0xD0($31)\n\t" + "ld $27,0xD8($31)\n\t" + "ld $28,0xE0($31)\n\t" + "ld $29,0xE8($31)\n\t" + "ld $30,0xF0($31)\n\t" + "ld $31,0xF8($31)\n\t" + "jr $11\n\t" + "nop\n" + "9:\n" + ::: "$8" ); +} diff --git a/utils.h b/utils.h new file mode 100644 index 0000000..3c3761c --- /dev/null +++ b/utils.h @@ -0,0 +1,170 @@ +// rom.h +// rom tools - header inspect +#include +#include + +/* + * + +0000h (1 byte): initial PI_BSB_DOM1_LAT_REG value (0x80) +0001h (1 byte): initial PI_BSB_DOM1_PGS_REG value (0x37) +0002h (1 byte): initial PI_BSB_DOM1_PWD_REG value (0x12) +0003h (1 byte): initial PI_BSB_DOM1_PGS_REG value (0x40) +0004h - 0007h (1 dword): ClockRate +0008h - 000Bh (1 dword): Program Counter (PC) +000Ch - 000Fh (1 dword): Release +0010h - 0013h (1 dword): CRC1 +0014h - 0017h (1 dword): CRC2 +0018h - 001Fh (2 dwords): Unknown (0x0000000000000000) +0020h - 0033h (20 bytes): Image name + Padded with 0x00 or spaces (0x20) +0034h - 0037h (1 dword): Unknown (0x00000000) +0038h - 003Bh (1 dword): Manufacturer ID + 0x0000004E = Nintendo ('N') +003Ch - 003Dh (1 word): Cartridge ID +003Eh - 003Fh (1 word): Country code + 0x4400 = Germany ('D') + 0x4500 = USA ('E') + 0x4A00 = Japan ('J') + 0x5000 = Europe ('P') + 0x5500 = Australia ('U') +0040h - 0FFFh (1008 dwords): Boot code +*/ + +#define PI_BASE_REG 0x04600000 +#define PIF_RAM_START 0x1FC007C0 + + +/* + * PI status register has 3 bits active when read from (PI_STATUS_REG - read) + * Bit 0: DMA busy - set when DMA is in progress + * Bit 1: IO busy - set when IO is in progress + * Bit 2: Error - set when CPU issues IO request while DMA is busy + */ + +#define PI_STATUS_REG (PI_BASE_REG+0x10) + +/* PI DRAM address (R/W): starting RDRAM address */ +#define PI_DRAM_ADDR_REG (PI_BASE_REG+0x00) /* DRAM address */ + +/* PI pbus (cartridge) address (R/W): starting AD16 address */ +#define PI_CART_ADDR_REG (PI_BASE_REG+0x04) + +/* PI read length (R/W): read data length */ +#define PI_RD_LEN_REG (PI_BASE_REG+0x08) + +/* PI write length (R/W): write data length */ +#define PI_WR_LEN_REG (PI_BASE_REG+0x0C) + +/* + * PI status (R): [0] DMA busy, [1] IO busy, [2], error + * (W): [0] reset controller (and abort current op), [1] clear intr + */ + +#define PI_BSD_DOM1_LAT_REG (PI_BASE_REG+0x14) + +/* PI dom1 pulse width (R/W): [7:0] domain 1 device R/W strobe pulse width */ +#define PI_BSD_DOM1_PWD_REG (PI_BASE_REG+0x18) + +/* PI dom1 page size (R/W): [3:0] domain 1 device page size */ +#define PI_BSD_DOM1_PGS_REG (PI_BASE_REG+0x1C) /* page size */ + +/* PI dom1 release (R/W): [1:0] domain 1 device R/W release duration */ +#define PI_BSD_DOM1_RLS_REG (PI_BASE_REG+0x20) +/* PI dom2 latency (R/W): [7:0] domain 2 device latency */ +#define PI_BSD_DOM2_LAT_REG (PI_BASE_REG+0x24) /* Domain 2 latency */ + +/* PI dom2 pulse width (R/W): [7:0] domain 2 device R/W strobe pulse width */ +#define PI_BSD_DOM2_PWD_REG (PI_BASE_REG+0x28) /* pulse width */ + +/* PI dom2 page size (R/W): [3:0] domain 2 device page size */ +#define PI_BSD_DOM2_PGS_REG (PI_BASE_REG+0x2C) /* page size */ + +/* PI dom2 release (R/W): [1:0] domain 2 device R/W release duration */ +#define PI_BSD_DOM2_RLS_REG (PI_BASE_REG+0x30) /* release duration */ + + +#define PI_DOMAIN1_REG PI_BSD_DOM1_LAT_REG +#define PI_DOMAIN2_REG PI_BSD_DOM2_LAT_REG + + +#define PI_STATUS_ERROR 0x04 +#define PI_STATUS_IO_BUSY 0x02 +#define PI_STATUS_DMA_BUSY 0x01 + +#define PHYS_TO_K0(x) ((u32)(x)|0x80000000) /* physical to kseg0 */ +#define K0_TO_PHYS(x) ((u32)(x)&0x1FFFFFFF) /* kseg0 to physical */ +#define PHYS_TO_K1(x) ((u32)(x)|0xA0000000) /* physical to kseg1 */ +#define K1_TO_PHYS(x) ((u32)(x)&0x1FFFFFFF) /* kseg1 to physical */ + +#define IO_READ(addr) (*(volatile u32*)PHYS_TO_K1(addr)) +#define IO_WRITE(addr,data) (*(volatile u32*)PHYS_TO_K1(addr)=(u32)(data)) + +#define SAVE_SIZE_SRAM 32768 +#define SAVE_SIZE_SRAM128 131072 +#define SAVE_SIZE_EEP4k 4096 +#define SAVE_SIZE_EEP16k 16384 +#define SAVE_SIZE_FLASH 131072 + +#define ROM_ADDR 0xb0000000 + + +#define FRAM_EXECUTE_CMD 0xD2000000 +#define FRAM_STATUS_MODE_CMD 0xE1000000 +#define FRAM_ERASE_OFFSET_CMD 0x4B000000 +#define FRAM_WRITE_OFFSET_CMD 0xA5000000 +#define FRAM_ERASE_MODE_CMD 0x78000000 +#define FRAM_WRITE_MODE_CMD 0xB4000000 +#define FRAM_READ_MODE_CMD 0xF0000000 + +#define FRAM_STATUS_REG 0xA8000000 +#define FRAM_COMMAND_REG 0xA8010000 + + +#define CIC_6101 1 +#define CIC_6102 2 +#define CIC_6103 3 +#define CIC_6104 4 +#define CIC_6105 5 +#define CIC_6106 6 + +sprite_t *loadImage32DFS(char *fname); +sprite_t *loadImageDFS(char *fname); +sprite_t *loadImage32(u8 *tbuf, int size); +void drawImage(display_context_t dcon, sprite_t *sprite); +void _sync_bus(void); +void _data_cache_invalidate_all(void); +void printText(char *msg, int x, int y, display_context_t dcon); + +// End ... +int is_valid_rom(unsigned char *buffer); +void swap_header(unsigned char* header, int loadlength); + +void restoreTiming(void); + +void simulate_boot(u32 boot_cic, u8 bios_cic); +void globalTest(void); + + +u8 getCicType(u8 bios_cic); +int get_cic(unsigned char *buffer); +int get_cic_save(char *cartid, int *cic, int *save); +//const char* saveTypeToExtension(int type); +const char* saveTypeToExtension(int type, int etype); +int saveTypeToSize(int type); +int getSaveFromCart(int stype, uint8_t *buffer); +int pushSaveToCart(int stype, uint8_t *buffer); + +int getSRAM( uint8_t *buffer,int size); +int getSRAM32( uint8_t *buffer); +int getSRAM128( uint8_t *buffer); +int getEeprom4k( uint8_t *buffer); +int getEeprom16k( uint8_t *buffer); +int getFlashRAM( uint8_t *buffer); + +int setSRAM(uint8_t *buffer,int size); +int setSRAM32( uint8_t *buffer); +int setSRAM128( uint8_t *buffer); +int setEeprom4k( uint8_t *buffer); +int setEeprom16k( uint8_t *buffer); +int setFlashRAM( uint8_t *buffer);