|
|
|
|
@ -83,6 +83,12 @@ static void filereader_close(void* file_handle)
|
|
|
|
|
fclose((FILE*)file_handle);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* for unit tests - normally would call rc_hash_init_custom_filereader(NULL) */
|
|
|
|
|
void rc_hash_reset_filereader()
|
|
|
|
|
{
|
|
|
|
|
filereader = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void rc_hash_init_custom_filereader(struct rc_hash_filereader* reader)
|
|
|
|
|
{
|
|
|
|
|
/* initialize with defaults first */
|
|
|
|
|
@ -193,13 +199,13 @@ static size_t rc_cd_read_sector(void* track_handle, uint32_t sector, void* buffe
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static uint32_t rc_cd_absolute_sector_to_track_sector(void* track_handle, uint32_t sector)
|
|
|
|
|
static uint32_t rc_cd_first_track_sector(void* track_handle)
|
|
|
|
|
{
|
|
|
|
|
if (cdreader && cdreader->absolute_sector_to_track_sector)
|
|
|
|
|
return cdreader->absolute_sector_to_track_sector(track_handle, sector);
|
|
|
|
|
if (cdreader && cdreader->first_track_sector)
|
|
|
|
|
return cdreader->first_track_sector(track_handle);
|
|
|
|
|
|
|
|
|
|
rc_hash_error("no hook registered for cdreader_absolute_sector_to_track_sector");
|
|
|
|
|
return sector;
|
|
|
|
|
rc_hash_error("no hook registered for cdreader_first_track_sector");
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void rc_cd_close_track(void* track_handle)
|
|
|
|
|
@ -242,7 +248,7 @@ static uint32_t rc_cd_find_file_sector(void* track_handle, const char* path, uns
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* find the cd information */
|
|
|
|
|
if (!rc_cd_read_sector(track_handle, 16, buffer, 256))
|
|
|
|
|
if (!rc_cd_read_sector(track_handle, rc_cd_first_track_sector(track_handle) + 16, buffer, 256))
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
/* the directory_record starts at 156, the sector containing the table of contents is 2 bytes into that.
|
|
|
|
|
@ -252,7 +258,6 @@ static uint32_t rc_cd_find_file_sector(void* track_handle, const char* path, uns
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* fetch and process the directory record */
|
|
|
|
|
sector = rc_cd_absolute_sector_to_track_sector(track_handle, sector);
|
|
|
|
|
if (!rc_cd_read_sector(track_handle, sector, buffer, sizeof(buffer)))
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
@ -405,7 +410,7 @@ static int rc_hash_cd_file(md5_state_t* md5, void* track_handle, uint32_t sector
|
|
|
|
|
if (name)
|
|
|
|
|
snprintf(message, sizeof(message), "Hashing %s title (%u bytes) and contents (%u bytes) ", name, (unsigned)strlen(name), size);
|
|
|
|
|
else
|
|
|
|
|
snprintf(message, sizeof(message), "Hashing %s contents (%u bytes)", description, size);
|
|
|
|
|
snprintf(message, sizeof(message), "Hashing %s contents (%u bytes @ sector %u)", description, size, sector);
|
|
|
|
|
|
|
|
|
|
verbose_message_callback(message);
|
|
|
|
|
}
|
|
|
|
|
@ -648,6 +653,37 @@ static int rc_hash_arcade(char hash[33], const char* path)
|
|
|
|
|
return rc_hash_buffer(hash, (uint8_t*)filename, filename_length);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int rc_hash_text(char hash[33], const uint8_t* buffer, size_t buffer_size)
|
|
|
|
|
{
|
|
|
|
|
md5_state_t md5;
|
|
|
|
|
const uint8_t* scan = buffer;
|
|
|
|
|
const uint8_t* stop = buffer + buffer_size;
|
|
|
|
|
|
|
|
|
|
md5_init(&md5);
|
|
|
|
|
|
|
|
|
|
do {
|
|
|
|
|
/* find end of line */
|
|
|
|
|
while (scan < stop && *scan != '\r' && *scan != '\n')
|
|
|
|
|
++scan;
|
|
|
|
|
|
|
|
|
|
md5_append(&md5, buffer, (int)(scan - buffer));
|
|
|
|
|
|
|
|
|
|
/* include a normalized line ending */
|
|
|
|
|
/* NOTE: this causes a line ending to be hashed at the end of the file, even if one was not present */
|
|
|
|
|
md5_append(&md5, (const uint8_t*)"\n", 1);
|
|
|
|
|
|
|
|
|
|
/* skip newline */
|
|
|
|
|
if (scan < stop && *scan == '\r')
|
|
|
|
|
++scan;
|
|
|
|
|
if (scan < stop && *scan == '\n')
|
|
|
|
|
++scan;
|
|
|
|
|
|
|
|
|
|
buffer = scan;
|
|
|
|
|
} while (scan < stop);
|
|
|
|
|
|
|
|
|
|
return rc_hash_finalize(&md5, hash);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int rc_hash_lynx(char hash[33], const uint8_t* buffer, size_t buffer_size)
|
|
|
|
|
{
|
|
|
|
|
/* if the file contains a header, ignore it */
|
|
|
|
|
@ -711,86 +747,7 @@ static void rc_hash_n64_to_z64(uint8_t* buffer, const uint8_t* stop)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int rc_hash_n64(char hash[33], const uint8_t* buffer, size_t buffer_size)
|
|
|
|
|
{
|
|
|
|
|
uint8_t* swapbuffer;
|
|
|
|
|
uint8_t* stop;
|
|
|
|
|
const size_t swapbuffer_size = 65536;
|
|
|
|
|
md5_state_t md5;
|
|
|
|
|
size_t remaining;
|
|
|
|
|
int is_v64;
|
|
|
|
|
|
|
|
|
|
if (buffer[0] == 0x80) /* z64 format (big endian [native]) */
|
|
|
|
|
{
|
|
|
|
|
return rc_hash_buffer(hash, buffer, buffer_size);
|
|
|
|
|
}
|
|
|
|
|
else if (buffer[0] == 0x37) /* v64 format (byteswapped) */
|
|
|
|
|
{
|
|
|
|
|
rc_hash_verbose("converting v64 to z64");
|
|
|
|
|
is_v64 = 1;
|
|
|
|
|
}
|
|
|
|
|
else if (buffer[0] == 0x40) /* n64 format (little endian) */
|
|
|
|
|
{
|
|
|
|
|
rc_hash_verbose("converting n64 to z64");
|
|
|
|
|
is_v64 = 0;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
rc_hash_verbose("Not a Nintendo 64 ROM");
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
swapbuffer = (uint8_t*)malloc(swapbuffer_size);
|
|
|
|
|
if (!swapbuffer)
|
|
|
|
|
return rc_hash_error("Could not allocate temporary buffer");
|
|
|
|
|
stop = swapbuffer + swapbuffer_size;
|
|
|
|
|
|
|
|
|
|
md5_init(&md5);
|
|
|
|
|
|
|
|
|
|
if (buffer_size > MAX_BUFFER_SIZE)
|
|
|
|
|
remaining = MAX_BUFFER_SIZE;
|
|
|
|
|
else
|
|
|
|
|
remaining = (size_t)buffer_size;
|
|
|
|
|
|
|
|
|
|
if (verbose_message_callback)
|
|
|
|
|
{
|
|
|
|
|
char message[64];
|
|
|
|
|
snprintf(message, sizeof(message), "Hashing %u bytes", (unsigned)remaining);
|
|
|
|
|
verbose_message_callback(message);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
while (remaining >= swapbuffer_size)
|
|
|
|
|
{
|
|
|
|
|
memcpy(swapbuffer, buffer, swapbuffer_size);
|
|
|
|
|
|
|
|
|
|
if (is_v64)
|
|
|
|
|
rc_hash_v64_to_z64(swapbuffer, stop);
|
|
|
|
|
else
|
|
|
|
|
rc_hash_n64_to_z64(swapbuffer, stop);
|
|
|
|
|
|
|
|
|
|
md5_append(&md5, swapbuffer, (int)swapbuffer_size);
|
|
|
|
|
buffer += swapbuffer_size;
|
|
|
|
|
remaining -= swapbuffer_size;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (remaining > 0)
|
|
|
|
|
{
|
|
|
|
|
memcpy(swapbuffer, buffer, remaining);
|
|
|
|
|
|
|
|
|
|
stop = swapbuffer + remaining;
|
|
|
|
|
if (is_v64)
|
|
|
|
|
rc_hash_v64_to_z64(swapbuffer, stop);
|
|
|
|
|
else
|
|
|
|
|
rc_hash_n64_to_z64(swapbuffer, stop);
|
|
|
|
|
|
|
|
|
|
md5_append(&md5, swapbuffer, (int)remaining);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
free(swapbuffer);
|
|
|
|
|
return rc_hash_finalize(&md5, hash);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int rc_hash_n64_file(char hash[33], const char* path)
|
|
|
|
|
static int rc_hash_n64(char hash[33], const char* path)
|
|
|
|
|
{
|
|
|
|
|
uint8_t* buffer;
|
|
|
|
|
uint8_t* stop;
|
|
|
|
|
@ -1026,7 +983,7 @@ static int rc_hash_pce_track(char hash[33], void* track_handle)
|
|
|
|
|
* the string "PC Engine CD-ROM SYSTEM" should exist at 32 bytes into the sector
|
|
|
|
|
* http://shu.sheldows.com/shu/download/pcedocs/pce_cdrom.html
|
|
|
|
|
*/
|
|
|
|
|
if (rc_cd_read_sector(track_handle, 1, buffer, 128) < 128)
|
|
|
|
|
if (rc_cd_read_sector(track_handle, rc_cd_first_track_sector(track_handle) + 1, buffer, 128) < 128)
|
|
|
|
|
{
|
|
|
|
|
return rc_hash_error("Not a PC Engine CD");
|
|
|
|
|
}
|
|
|
|
|
@ -1059,6 +1016,7 @@ static int rc_hash_pce_track(char hash[33], void* track_handle)
|
|
|
|
|
verbose_message_callback(message);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
sector += rc_cd_first_track_sector(track_handle);
|
|
|
|
|
while (num_sectors > 0)
|
|
|
|
|
{
|
|
|
|
|
rc_cd_read_sector(track_handle, sector, buffer, sizeof(buffer));
|
|
|
|
|
@ -1122,7 +1080,8 @@ static int rc_hash_pcfx_cd(char hash[33], const char* path)
|
|
|
|
|
return rc_hash_error("Could not open track");
|
|
|
|
|
|
|
|
|
|
/* PC-FX CD will have a header marker in sector 0 */
|
|
|
|
|
rc_cd_read_sector(track_handle, 0, buffer, 32);
|
|
|
|
|
sector = rc_cd_first_track_sector(track_handle);
|
|
|
|
|
rc_cd_read_sector(track_handle, sector, buffer, 32);
|
|
|
|
|
if (memcmp("PC-FX:Hu_CD-ROM", &buffer[0], 15) != 0)
|
|
|
|
|
{
|
|
|
|
|
rc_cd_close_track(track_handle);
|
|
|
|
|
@ -1132,7 +1091,8 @@ static int rc_hash_pcfx_cd(char hash[33], const char* path)
|
|
|
|
|
if (!track_handle)
|
|
|
|
|
return rc_hash_error("Could not open track");
|
|
|
|
|
|
|
|
|
|
rc_cd_read_sector(track_handle, 0, buffer, 32);
|
|
|
|
|
sector = rc_cd_first_track_sector(track_handle);
|
|
|
|
|
rc_cd_read_sector(track_handle, sector, buffer, 32);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (memcmp("PC-FX:Hu_CD-ROM", &buffer[0], 15) == 0)
|
|
|
|
|
@ -1140,7 +1100,7 @@ static int rc_hash_pcfx_cd(char hash[33], const char* path)
|
|
|
|
|
/* PC-FX boot header fills the first two sectors of the disc
|
|
|
|
|
* https://bitbucket.org/trap15/pcfxtools/src/master/pcfx-cdlink.c
|
|
|
|
|
* the important stuff is the first 128 bytes of the second sector (title being the first 32) */
|
|
|
|
|
rc_cd_read_sector(track_handle, 1, buffer, 128);
|
|
|
|
|
rc_cd_read_sector(track_handle, sector + 1, buffer, 128);
|
|
|
|
|
|
|
|
|
|
md5_init(&md5);
|
|
|
|
|
md5_append(&md5, buffer, 128);
|
|
|
|
|
@ -1166,6 +1126,7 @@ static int rc_hash_pcfx_cd(char hash[33], const char* path)
|
|
|
|
|
verbose_message_callback(message);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
sector += rc_cd_first_track_sector(track_handle);
|
|
|
|
|
while (num_sectors > 0)
|
|
|
|
|
{
|
|
|
|
|
rc_cd_read_sector(track_handle, sector, buffer, sizeof(buffer));
|
|
|
|
|
@ -1178,7 +1139,7 @@ static int rc_hash_pcfx_cd(char hash[33], const char* path)
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
int result = 0;
|
|
|
|
|
rc_cd_read_sector(track_handle, 1, buffer, 128);
|
|
|
|
|
rc_cd_read_sector(track_handle, sector + 1, buffer, 128);
|
|
|
|
|
|
|
|
|
|
/* some PC-FX CDs still identify as PCE CDs */
|
|
|
|
|
if (memcmp("PC Engine CD-ROM SYSTEM", &buffer[32], 23) == 0)
|
|
|
|
|
@ -1198,30 +1159,41 @@ static int rc_hash_pcfx_cd(char hash[33], const char* path)
|
|
|
|
|
|
|
|
|
|
static int rc_hash_dreamcast(char hash[33], const char* path)
|
|
|
|
|
{
|
|
|
|
|
uint8_t buffer[256];
|
|
|
|
|
uint8_t buffer[256] = "";
|
|
|
|
|
void* track_handle;
|
|
|
|
|
void* last_track_handle;
|
|
|
|
|
char exe_file[32] = "";
|
|
|
|
|
unsigned size;
|
|
|
|
|
uint32_t sector;
|
|
|
|
|
uint32_t track_sector;
|
|
|
|
|
int result = 0;
|
|
|
|
|
md5_state_t md5;
|
|
|
|
|
int i = 0;
|
|
|
|
|
|
|
|
|
|
/* track 03 is the data track that contains the TOC and IP.BIN */
|
|
|
|
|
track_handle = rc_cd_open_track(path, 3);
|
|
|
|
|
if (!track_handle)
|
|
|
|
|
return rc_hash_error("Could not open track");
|
|
|
|
|
|
|
|
|
|
/* first 256 bytes from first sector should have IP.BIN structure that stores game meta information
|
|
|
|
|
* https://mc.pp.se/dc/ip.bin.html */
|
|
|
|
|
rc_cd_read_sector(track_handle, 0, buffer, sizeof(buffer));
|
|
|
|
|
if (track_handle)
|
|
|
|
|
{
|
|
|
|
|
/* first 256 bytes from first sector should have IP.BIN structure that stores game meta information
|
|
|
|
|
* https://mc.pp.se/dc/ip.bin.html */
|
|
|
|
|
rc_cd_read_sector(track_handle, rc_cd_first_track_sector(track_handle), buffer, sizeof(buffer));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (memcmp(&buffer[0], "SEGA SEGAKATANA ", 16) != 0)
|
|
|
|
|
{
|
|
|
|
|
rc_cd_close_track(track_handle);
|
|
|
|
|
return rc_hash_error("Not a Dreamcast CD");
|
|
|
|
|
if (track_handle)
|
|
|
|
|
rc_cd_close_track(track_handle);
|
|
|
|
|
|
|
|
|
|
/* not a gd-rom dreamcast file. check for mil-cd by looking for the marker in the first data track */
|
|
|
|
|
track_handle = rc_cd_open_track(path, RC_HASH_CDTRACK_FIRST_DATA);
|
|
|
|
|
if (!track_handle)
|
|
|
|
|
return rc_hash_error("Could not open track");
|
|
|
|
|
|
|
|
|
|
rc_cd_read_sector(track_handle, rc_cd_first_track_sector(track_handle), buffer, sizeof(buffer));
|
|
|
|
|
if (memcmp(&buffer[0], "SEGA SEGAKATANA ", 16) != 0)
|
|
|
|
|
{
|
|
|
|
|
/* did not find marker on track 3 or first data track */
|
|
|
|
|
rc_cd_close_track(track_handle);
|
|
|
|
|
return rc_hash_error("Not a Dreamcast CD");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* start the hash with the game meta information */
|
|
|
|
|
@ -1258,30 +1230,26 @@ static int rc_hash_dreamcast(char hash[33], const char* path)
|
|
|
|
|
exe_file[i] = '\0';
|
|
|
|
|
|
|
|
|
|
sector = rc_cd_find_file_sector(track_handle, exe_file, &size);
|
|
|
|
|
|
|
|
|
|
rc_cd_close_track(track_handle);
|
|
|
|
|
|
|
|
|
|
if (sector == 0)
|
|
|
|
|
{
|
|
|
|
|
rc_cd_close_track(track_handle);
|
|
|
|
|
return rc_hash_error("Could not locate boot executable");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* last track contains the boot executable */
|
|
|
|
|
last_track_handle = rc_cd_open_track(path, RC_HASH_CDTRACK_LAST);
|
|
|
|
|
track_sector = rc_cd_absolute_sector_to_track_sector(last_track_handle, sector);
|
|
|
|
|
|
|
|
|
|
if ((int32_t)track_sector < 0)
|
|
|
|
|
if (rc_cd_read_sector(track_handle, sector, buffer, 1))
|
|
|
|
|
{
|
|
|
|
|
/* boot executable is not in the last track; try the primary data track.
|
|
|
|
|
* There's only a handful of games that do this: Q*bert was the first identified. */
|
|
|
|
|
rc_cd_close_track(last_track_handle);
|
|
|
|
|
|
|
|
|
|
rc_hash_verbose("Boot executable not found in last track, trying primary track");
|
|
|
|
|
last_track_handle = rc_cd_open_track(path, 3);
|
|
|
|
|
track_sector = rc_cd_absolute_sector_to_track_sector(last_track_handle, sector);
|
|
|
|
|
/* the boot executable is in the primary data track */
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
rc_cd_close_track(track_handle);
|
|
|
|
|
|
|
|
|
|
result = rc_hash_cd_file(&md5, last_track_handle, track_sector, NULL, size, "boot executable");
|
|
|
|
|
/* the boot executable is normally in the last track */
|
|
|
|
|
track_handle = rc_cd_open_track(path, RC_HASH_CDTRACK_LAST);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
rc_cd_close_track(last_track_handle);
|
|
|
|
|
result = rc_hash_cd_file(&md5, track_handle, sector, NULL, size, "boot executable");
|
|
|
|
|
rc_cd_close_track(track_handle);
|
|
|
|
|
|
|
|
|
|
rc_hash_finalize(&md5, hash);
|
|
|
|
|
return result;
|
|
|
|
|
@ -1547,6 +1515,84 @@ static int rc_hash_snes(char hash[33], const uint8_t* buffer, size_t buffer_size
|
|
|
|
|
return rc_hash_buffer(hash, buffer, buffer_size);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
struct rc_buffered_file
|
|
|
|
|
{
|
|
|
|
|
const uint8_t* read_ptr;
|
|
|
|
|
const uint8_t* data;
|
|
|
|
|
size_t data_size;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static struct rc_buffered_file rc_buffered_file;
|
|
|
|
|
|
|
|
|
|
static void* rc_file_open_buffered_file(const char* path)
|
|
|
|
|
{
|
|
|
|
|
struct rc_buffered_file* handle = (struct rc_buffered_file*)malloc(sizeof(struct rc_buffered_file));
|
|
|
|
|
memcpy(handle, &rc_buffered_file, sizeof(rc_buffered_file));
|
|
|
|
|
return handle;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void rc_file_seek_buffered_file(void* file_handle, int64_t offset, int origin)
|
|
|
|
|
{
|
|
|
|
|
struct rc_buffered_file* buffered_file = (struct rc_buffered_file*)file_handle;
|
|
|
|
|
switch (origin)
|
|
|
|
|
{
|
|
|
|
|
case SEEK_SET: buffered_file->read_ptr = buffered_file->data + offset; break;
|
|
|
|
|
case SEEK_CUR: buffered_file->read_ptr += offset; break;
|
|
|
|
|
case SEEK_END: buffered_file->read_ptr = buffered_file->data + buffered_file->data_size - offset; break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (buffered_file->read_ptr < buffered_file->data)
|
|
|
|
|
buffered_file->read_ptr = buffered_file->data;
|
|
|
|
|
else if (buffered_file->read_ptr > buffered_file->data + buffered_file->data_size)
|
|
|
|
|
buffered_file->read_ptr = buffered_file->data + buffered_file->data_size;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int64_t rc_file_tell_buffered_file(void* file_handle)
|
|
|
|
|
{
|
|
|
|
|
struct rc_buffered_file* buffered_file = (struct rc_buffered_file*)file_handle;
|
|
|
|
|
return (buffered_file->read_ptr - buffered_file->data);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
size_t rc_file_read_buffered_file(void* file_handle, void* buffer, size_t requested_bytes)
|
|
|
|
|
{
|
|
|
|
|
struct rc_buffered_file* buffered_file = (struct rc_buffered_file*)file_handle;
|
|
|
|
|
const int64_t remaining = buffered_file->data_size - (buffered_file->read_ptr - buffered_file->data);
|
|
|
|
|
if ((int)requested_bytes > remaining)
|
|
|
|
|
requested_bytes = (int)remaining;
|
|
|
|
|
|
|
|
|
|
memcpy(buffer, buffered_file->read_ptr, requested_bytes);
|
|
|
|
|
buffered_file->read_ptr += requested_bytes;
|
|
|
|
|
return requested_bytes;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void rc_file_close_buffered_file(void* file_handle)
|
|
|
|
|
{
|
|
|
|
|
free(file_handle);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int rc_hash_file_from_buffer(char hash[33], int console_id, const uint8_t* buffer, size_t buffer_size)
|
|
|
|
|
{
|
|
|
|
|
struct rc_hash_filereader buffered_filereader_funcs;
|
|
|
|
|
struct rc_hash_filereader* old_filereader = filereader;
|
|
|
|
|
int result;
|
|
|
|
|
|
|
|
|
|
memset(&buffered_filereader_funcs, 0, sizeof(buffered_filereader_funcs));
|
|
|
|
|
buffered_filereader_funcs.open = rc_file_open_buffered_file;
|
|
|
|
|
buffered_filereader_funcs.close = rc_file_close_buffered_file;
|
|
|
|
|
buffered_filereader_funcs.read = rc_file_read_buffered_file;
|
|
|
|
|
buffered_filereader_funcs.seek = rc_file_seek_buffered_file;
|
|
|
|
|
buffered_filereader_funcs.tell = rc_file_tell_buffered_file;
|
|
|
|
|
filereader = &buffered_filereader_funcs;
|
|
|
|
|
|
|
|
|
|
rc_buffered_file.data = rc_buffered_file.read_ptr = buffer;
|
|
|
|
|
rc_buffered_file.data_size = buffer_size;
|
|
|
|
|
|
|
|
|
|
result = rc_hash_generate_from_file(hash, console_id, "[buffered file]");
|
|
|
|
|
|
|
|
|
|
filereader = old_filereader;
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int rc_hash_generate_from_buffer(char hash[33], int console_id, const uint8_t* buffer, size_t buffer_size)
|
|
|
|
|
{
|
|
|
|
|
switch (console_id)
|
|
|
|
|
@ -1558,6 +1604,7 @@ int rc_hash_generate_from_buffer(char hash[33], int console_id, const uint8_t* b
|
|
|
|
|
return rc_hash_error(message);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
case RC_CONSOLE_AMSTRAD_PC:
|
|
|
|
|
case RC_CONSOLE_APPLE_II:
|
|
|
|
|
case RC_CONSOLE_ATARI_2600:
|
|
|
|
|
case RC_CONSOLE_ATARI_JAGUAR:
|
|
|
|
|
@ -1570,6 +1617,7 @@ int rc_hash_generate_from_buffer(char hash[33], int console_id, const uint8_t* b
|
|
|
|
|
case RC_CONSOLE_MAGNAVOX_ODYSSEY2:
|
|
|
|
|
case RC_CONSOLE_MASTER_SYSTEM:
|
|
|
|
|
case RC_CONSOLE_MEGA_DRIVE:
|
|
|
|
|
case RC_CONSOLE_MEGADUCK:
|
|
|
|
|
case RC_CONSOLE_MSX:
|
|
|
|
|
case RC_CONSOLE_NEOGEO_POCKET:
|
|
|
|
|
case RC_CONSOLE_ORIC:
|
|
|
|
|
@ -1584,6 +1632,10 @@ int rc_hash_generate_from_buffer(char hash[33], int console_id, const uint8_t* b
|
|
|
|
|
case RC_CONSOLE_WONDERSWAN:
|
|
|
|
|
return rc_hash_buffer(hash, buffer, buffer_size);
|
|
|
|
|
|
|
|
|
|
case RC_CONSOLE_ARDUBOY:
|
|
|
|
|
/* https://en.wikipedia.org/wiki/Intel_HEX */
|
|
|
|
|
return rc_hash_text(hash, buffer, buffer_size);
|
|
|
|
|
|
|
|
|
|
case RC_CONSOLE_ATARI_7800:
|
|
|
|
|
return rc_hash_7800(hash, buffer, buffer_size);
|
|
|
|
|
|
|
|
|
|
@ -1593,14 +1645,15 @@ int rc_hash_generate_from_buffer(char hash[33], int console_id, const uint8_t* b
|
|
|
|
|
case RC_CONSOLE_NINTENDO:
|
|
|
|
|
return rc_hash_nes(hash, buffer, buffer_size);
|
|
|
|
|
|
|
|
|
|
case RC_CONSOLE_NINTENDO_64:
|
|
|
|
|
return rc_hash_n64(hash, buffer, buffer_size);
|
|
|
|
|
|
|
|
|
|
case RC_CONSOLE_PC_ENGINE: /* NOTE: does not support PCEngine CD */
|
|
|
|
|
return rc_hash_pce(hash, buffer, buffer_size);
|
|
|
|
|
|
|
|
|
|
case RC_CONSOLE_SUPER_NINTENDO:
|
|
|
|
|
return rc_hash_snes(hash, buffer, buffer_size);
|
|
|
|
|
|
|
|
|
|
case RC_CONSOLE_NINTENDO_64:
|
|
|
|
|
case RC_CONSOLE_NINTENDO_DS:
|
|
|
|
|
return rc_hash_file_from_buffer(hash, console_id, buffer, buffer_size);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
@ -1842,7 +1895,6 @@ int rc_hash_generate_from_file(char hash[33], int console_id, const char* path)
|
|
|
|
|
return rc_hash_error(buffer);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
case RC_CONSOLE_APPLE_II:
|
|
|
|
|
case RC_CONSOLE_ATARI_2600:
|
|
|
|
|
case RC_CONSOLE_ATARI_JAGUAR:
|
|
|
|
|
case RC_CONSOLE_COLECOVISION:
|
|
|
|
|
@ -1854,6 +1906,7 @@ int rc_hash_generate_from_file(char hash[33], int console_id, const char* path)
|
|
|
|
|
case RC_CONSOLE_MAGNAVOX_ODYSSEY2:
|
|
|
|
|
case RC_CONSOLE_MASTER_SYSTEM:
|
|
|
|
|
case RC_CONSOLE_MEGA_DRIVE:
|
|
|
|
|
case RC_CONSOLE_MEGADUCK:
|
|
|
|
|
case RC_CONSOLE_NEOGEO_POCKET:
|
|
|
|
|
case RC_CONSOLE_ORIC:
|
|
|
|
|
case RC_CONSOLE_POKEMON_MINI:
|
|
|
|
|
@ -1867,6 +1920,8 @@ int rc_hash_generate_from_file(char hash[33], int console_id, const char* path)
|
|
|
|
|
/* generic whole-file hash - don't buffer */
|
|
|
|
|
return rc_hash_whole_file(hash, path);
|
|
|
|
|
|
|
|
|
|
case RC_CONSOLE_AMSTRAD_PC:
|
|
|
|
|
case RC_CONSOLE_APPLE_II:
|
|
|
|
|
case RC_CONSOLE_MSX:
|
|
|
|
|
case RC_CONSOLE_PC8800:
|
|
|
|
|
/* generic whole-file hash with m3u support - don't buffer */
|
|
|
|
|
@ -1875,6 +1930,7 @@ int rc_hash_generate_from_file(char hash[33], int console_id, const char* path)
|
|
|
|
|
|
|
|
|
|
return rc_hash_whole_file(hash, path);
|
|
|
|
|
|
|
|
|
|
case RC_CONSOLE_ARDUBOY:
|
|
|
|
|
case RC_CONSOLE_ATARI_7800:
|
|
|
|
|
case RC_CONSOLE_ATARI_LYNX:
|
|
|
|
|
case RC_CONSOLE_NINTENDO:
|
|
|
|
|
@ -1892,7 +1948,7 @@ int rc_hash_generate_from_file(char hash[33], int console_id, const char* path)
|
|
|
|
|
return rc_hash_arcade(hash, path);
|
|
|
|
|
|
|
|
|
|
case RC_CONSOLE_NINTENDO_64:
|
|
|
|
|
return rc_hash_n64_file(hash, path);
|
|
|
|
|
return rc_hash_n64(hash, path);
|
|
|
|
|
|
|
|
|
|
case RC_CONSOLE_NINTENDO_DS:
|
|
|
|
|
return rc_hash_nintendo_ds(hash, path);
|
|
|
|
|
@ -1986,6 +2042,9 @@ static void rc_hash_initialize_dsk_iterator(struct rc_hash_iterator* iterator, c
|
|
|
|
|
{
|
|
|
|
|
/* FAT-12 5.25" DD (512 byte sectors, 9 sectors per track, 40 tracks per side */
|
|
|
|
|
iterator->consoles[0] = RC_CONSOLE_MSX;
|
|
|
|
|
|
|
|
|
|
/* AMSDOS 3" - 40 tracks */
|
|
|
|
|
iterator->consoles[1] = RC_CONSOLE_AMSTRAD_PC;
|
|
|
|
|
}
|
|
|
|
|
else if (size == 256 * 16 * 35) /* 140KB */
|
|
|
|
|
{
|
|
|
|
|
@ -2002,6 +2061,7 @@ static void rc_hash_initialize_dsk_iterator(struct rc_hash_iterator* iterator, c
|
|
|
|
|
|
|
|
|
|
/* check MSX first, as Apple II isn't supported by RetroArch, and RAppleWin won't use the iterator */
|
|
|
|
|
rc_hash_iterator_append_console(iterator, RC_CONSOLE_MSX);
|
|
|
|
|
rc_hash_iterator_append_console(iterator, RC_CONSOLE_AMSTRAD_PC);
|
|
|
|
|
rc_hash_iterator_append_console(iterator, RC_CONSOLE_APPLE_II);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
@ -2072,7 +2132,7 @@ void rc_hash_initialize_iterator(struct rc_hash_iterator* iterator, const char*
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* bin is associated with MegaDrive, Sega32X, Atari 2600, and Watara Supervision.
|
|
|
|
|
/* bin is associated with MegaDrive, Sega32X, Atari 2600, Watara Supervision, and MegaDuck.
|
|
|
|
|
* Since they all use the same hashing algorithm, only specify one of them */
|
|
|
|
|
iterator->consoles[0] = RC_CONSOLE_MEGA_DRIVE;
|
|
|
|
|
}
|
|
|
|
|
@ -2087,10 +2147,11 @@ void rc_hash_initialize_iterator(struct rc_hash_iterator* iterator, const char*
|
|
|
|
|
{
|
|
|
|
|
iterator->consoles[0] = RC_CONSOLE_PLAYSTATION;
|
|
|
|
|
iterator->consoles[1] = RC_CONSOLE_PLAYSTATION_2;
|
|
|
|
|
iterator->consoles[2] = RC_CONSOLE_PC_ENGINE;
|
|
|
|
|
iterator->consoles[3] = RC_CONSOLE_3DO;
|
|
|
|
|
iterator->consoles[4] = RC_CONSOLE_PCFX;
|
|
|
|
|
iterator->consoles[5] = RC_CONSOLE_SEGA_CD; /* ASSERT: handles both Sega CD and Saturn */
|
|
|
|
|
iterator->consoles[2] = RC_CONSOLE_DREAMCAST;
|
|
|
|
|
iterator->consoles[3] = RC_CONSOLE_SEGA_CD; /* ASSERT: handles both Sega CD and Saturn */
|
|
|
|
|
iterator->consoles[4] = RC_CONSOLE_PC_ENGINE;
|
|
|
|
|
iterator->consoles[5] = RC_CONSOLE_3DO;
|
|
|
|
|
iterator->consoles[6] = RC_CONSOLE_PCFX;
|
|
|
|
|
need_path = 1;
|
|
|
|
|
}
|
|
|
|
|
else if (rc_path_compare_extension(ext, "chd"))
|
|
|
|
|
@ -2098,10 +2159,10 @@ void rc_hash_initialize_iterator(struct rc_hash_iterator* iterator, const char*
|
|
|
|
|
iterator->consoles[0] = RC_CONSOLE_PLAYSTATION;
|
|
|
|
|
iterator->consoles[1] = RC_CONSOLE_PLAYSTATION_2;
|
|
|
|
|
iterator->consoles[2] = RC_CONSOLE_DREAMCAST;
|
|
|
|
|
iterator->consoles[3] = RC_CONSOLE_PC_ENGINE;
|
|
|
|
|
iterator->consoles[4] = RC_CONSOLE_3DO;
|
|
|
|
|
iterator->consoles[5] = RC_CONSOLE_PCFX;
|
|
|
|
|
iterator->consoles[6] = RC_CONSOLE_SEGA_CD; /* ASSERT: handles both Sega CD and Saturn */
|
|
|
|
|
iterator->consoles[3] = RC_CONSOLE_SEGA_CD; /* ASSERT: handles both Sega CD and Saturn */
|
|
|
|
|
iterator->consoles[4] = RC_CONSOLE_PC_ENGINE;
|
|
|
|
|
iterator->consoles[5] = RC_CONSOLE_3DO;
|
|
|
|
|
iterator->consoles[6] = RC_CONSOLE_PCFX;
|
|
|
|
|
need_path = 1;
|
|
|
|
|
}
|
|
|
|
|
else if (rc_path_compare_extension(ext, "col"))
|
|
|
|
|
@ -2164,6 +2225,13 @@ void rc_hash_initialize_iterator(struct rc_hash_iterator* iterator, const char*
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case 'h':
|
|
|
|
|
if (rc_path_compare_extension(ext, "hex"))
|
|
|
|
|
{
|
|
|
|
|
iterator->consoles[0] = RC_CONSOLE_ARDUBOY;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case 'i':
|
|
|
|
|
if (rc_path_compare_extension(ext, "iso"))
|
|
|
|
|
{
|
|
|
|
|
|
Connor McLaughlin
4 years ago