mirror of
https://github.com/bsnes-emu/bsnes.git
synced 2025-04-02 10:42:14 -04:00
84e98833ca
byuu says:
This release refines HSU1 support as a bidirectional protocol, nests SFC
manifests as "release/cartridge" and "release/information" (but release/
is not guaranteed to be finalized just yet), removes the database
integration, and adds support for ananke.
ananke represents inevitability. It's a library that, when installed,
higan can use to load files from the command-line, and also from a new
File -> Load Game menu option.
I need to change the build rules a bit for it to work on Windows (need
to make phoenix a DLL, basically), but it works now on Linux.
Right now, it only takes *.sfc file names, looks them up in the included
database, converts them to game folders, and returns the game folder
path for higan to load.
The idea is to continue expanding it to support everything we can that
I don't want in the higan core:
- load *.sfc, *.smc, *.swc, *.fig files
- remove SNES copier headers
- split apart merged firmware files
- pull in external firmware files (eg dsp1b.rom - these are staying
merged, just as SPC7110 prg+dat are merged)
- load *.zip and *.7z archives
- prompt for selection on multi-file archives
- generate manifest files based on heuristics
- apply BPS patches
The "Load" menu option has been renamed to "Library", to represent games
in your library. I'm going to add some sort of suffix to indicate
unverified games, and use a different folder icon for those (eg
manifests built on heuristics rather than from the database.)
So basically, to future end users:
File -> Load Game will be how they play games.
Library -> (specific system) can be thought of as an infinitely-sized
recent games list.
purify will likely become a simple stub that invokes ananke's functions.
No reason to duplicate all that code.
101 lines
3.3 KiB
C++
101 lines
3.3 KiB
C++
#ifndef NALL_BMP_HPP
|
|
#define NALL_BMP_HPP
|
|
|
|
#include <nall/file.hpp>
|
|
|
|
//BMP reader / writer
|
|
//author: byuu
|
|
//note: only 24-bit RGB and 32-bit ARGB uncompressed images supported
|
|
|
|
namespace nall {
|
|
|
|
struct bmp {
|
|
inline static bool read(const string &filename, uint32_t *&data, unsigned &width, unsigned &height);
|
|
inline static bool write(const string &filename, const uint32_t *data, unsigned width, unsigned height, unsigned pitch, bool alpha = false);
|
|
};
|
|
|
|
bool bmp::read(const string &filename, uint32_t *&data, unsigned &width, unsigned &height) {
|
|
file fp;
|
|
if(fp.open(filename, file::mode::read) == false) return false;
|
|
if(fp.size() < 0x36) return false;
|
|
|
|
if(fp.readm(2) != 0x424d) return false;
|
|
fp.seek(0x000a);
|
|
unsigned offset = fp.readl(4);
|
|
unsigned dibsize = fp.readl(4);
|
|
if(dibsize != 40) return false;
|
|
signed headerWidth = fp.readl(4);
|
|
if(headerWidth < 0) return false;
|
|
signed headerHeight = fp.readl(4);
|
|
fp.readl(2);
|
|
unsigned bitsPerPixel = fp.readl(2);
|
|
if(bitsPerPixel != 24 && bitsPerPixel != 32) return false;
|
|
unsigned compression = fp.readl(4);
|
|
if(compression != 0) return false;
|
|
fp.seek(offset);
|
|
|
|
bool noFlip = headerHeight < 0;
|
|
width = headerWidth, height = abs(headerHeight);
|
|
data = new uint32_t[width * height];
|
|
|
|
unsigned bytesPerPixel = bitsPerPixel / 8;
|
|
unsigned alignedWidth = width * bytesPerPixel;
|
|
unsigned paddingLength = 0;
|
|
while(alignedWidth % 4) alignedWidth++, paddingLength++;
|
|
|
|
for(unsigned y = 0; y < height; y++) {
|
|
uint32_t *p = noFlip ? data + y * width : data + (height - 1 - y) * width;
|
|
for(unsigned x = 0; x < width; x++, p++) {
|
|
*p = fp.readl(bytesPerPixel);
|
|
if(bytesPerPixel == 3) *p |= 255 << 24;
|
|
}
|
|
if(paddingLength) fp.readl(paddingLength);
|
|
}
|
|
|
|
fp.close();
|
|
return true;
|
|
}
|
|
|
|
bool bmp::write(const string &filename, const uint32_t *data, unsigned width, unsigned height, unsigned pitch, bool alpha) {
|
|
file fp;
|
|
if(fp.open(filename, file::mode::write) == false) return false;
|
|
|
|
unsigned bitsPerPixel = alpha ? 32 : 24;
|
|
unsigned bytesPerPixel = bitsPerPixel / 8;
|
|
unsigned alignedWidth = width * bytesPerPixel;
|
|
unsigned paddingLength = 0;
|
|
unsigned imageSize = alignedWidth * height;
|
|
unsigned fileSize = 0x36 + imageSize;
|
|
while(alignedWidth % 4) alignedWidth++, paddingLength++;
|
|
|
|
fp.writem(0x424d, 2); //signature
|
|
fp.writel(fileSize, 4); //file size
|
|
fp.writel(0, 2); //reserved
|
|
fp.writel(0, 2); //reserved
|
|
fp.writel(0x36, 4); //offset
|
|
|
|
fp.writel(40, 4); //DIB size
|
|
fp.writel(width, 4); //width
|
|
fp.writel(-height, 4); //height
|
|
fp.writel(1, 2); //color planes
|
|
fp.writel(bitsPerPixel, 2); //bits per pixel
|
|
fp.writel(0, 4); //compression method (BI_RGB)
|
|
fp.writel(imageSize, 4); //image data size
|
|
fp.writel(3780, 4); //horizontal resolution
|
|
fp.writel(3780, 4); //vertical resolution
|
|
fp.writel(0, 4); //palette size
|
|
fp.writel(0, 4); //important color count
|
|
|
|
for(unsigned y = 0; y < height; y++) {
|
|
const uint32_t *p = (const uint32_t*)((const uint8_t*)data + y * pitch);
|
|
for(unsigned x = 0; x < width; x++) fp.writel(*p++, bytesPerPixel);
|
|
if(paddingLength) fp.writel(0, paddingLength);
|
|
}
|
|
|
|
fp.close();
|
|
return true;
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|