static zip_error get_compressed_data_offset(zip_file *zip, UINT64 *offset)
{
file_error error;
UINT32 read_length;
/* make sure the file handle is open */
if (zip->file == nullptr)
{
int filerr = osd_open(zip->filename, OPEN_FLAG_READ, &zip->file, &zip->length);
if (filerr != FILERR_NONE)
return ZIPERR_FILE_ERROR;
}
/* now go read the fixed-sized part of the local file header */
error = osd_read(zip->file, zip->buffer, zip->header.local_header_offset, ZIPNAME, &read_length);
if (error != FILERR_NONE || read_length != ZIPNAME)
return (error == FILERR_NONE) ? ZIPERR_FILE_TRUNCATED : ZIPERR_FILE_ERROR;
/* compute the final offset */
*offset = zip->header.local_header_offset + ZIPNAME;
*offset += read_word(zip->buffer + ZIPFNLN);
*offset += read_word(zip->buffer + ZIPXTRALN);
return ZIPERR_NONE;
}
WRes File_Read(CSzFile *p, void *data, size_t *size)
{
// file_error err;
UINT32 read_length;
if (!p->_7z_osdfile)
{
printf("un7z.c: called File_Read without file\n");
return 1;
}
size_t originalSize = *size;
if (originalSize == 0)
return 0;
// err =
osd_read( p->_7z_osdfile, data, p->_7z_currfpos, originalSize, &read_length );
*size = read_length;
p->_7z_currfpos += read_length;
if (*size == originalSize)
return 0;
return 0;
}
static file_error osd_or_zlib_read(core_file *file, void *buffer, UINT64 offset, UINT32 length, UINT32 *actual)
{
/* if no compression, just pass through */
if (file->zdata == NULL)
return osd_read(file->file, buffer, offset, length, actual);
/* if the offset doesn't match the next offset, fail */
if (offset != file->zdata->nextoffset)
return FILERR_INVALID_ACCESS;
/* set up the destination */
file->zdata->stream.next_out = (Bytef *)buffer;
file->zdata->stream.avail_out = length;
while (file->zdata->stream.avail_out != 0)
{
file_error filerr;
UINT32 actualdata;
int zerr = Z_OK;
/* if we didn't make progress, report an error or the end */
if (file->zdata->stream.avail_in != 0)
zerr = inflate(&file->zdata->stream, Z_SYNC_FLUSH);
if (zerr != Z_OK)
{
*actual = length - file->zdata->stream.avail_out;
file->zdata->nextoffset += *actual;
return (zerr == Z_STREAM_END) ? FILERR_NONE : FILERR_INVALID_DATA;
}
/* fetch more data if needed */
if (file->zdata->stream.avail_in == 0)
{
filerr = osd_read(file->file, file->zdata->buffer, file->zdata->realoffset, sizeof(file->zdata->buffer), &actualdata);
if (filerr != FILERR_NONE)
return filerr;
file->zdata->realoffset += actualdata;
file->zdata->stream.next_in = file->zdata->buffer;
file->zdata->stream.avail_in = sizeof(file->zdata->buffer);
}
}
/* we read everything */
*actual = length;
file->zdata->nextoffset += *actual;
return FILERR_NONE;
}
ssize_t device_pty_interface::read(UINT8 *rx_chars , size_t count) const
{
UINT32 actual_bytes;
if (m_opened && osd_read(m_pty_master, rx_chars, 0, count, &actual_bytes) == FILERR_NONE) {
return actual_bytes;
} else {
return -1;
}
}
UINT32 image_fread(mess_image *image, void *buffer, UINT32 length)
{
length = MIN(length, image->length - image->pos);
if (image->file)
osd_read(image->file, buffer, image->pos, length, &length);
else if (image->ptr)
memcpy(buffer, ((UINT8 *) image->ptr) + image->pos, length);
else
length = 0;
image->pos += length;
return length;
}
static zip_error decompress_data_type_0(zip_file *zip, UINT64 offset, void *buffer, UINT32 length)
{
file_error filerr;
UINT32 read_length;
/* the data is uncompressed; just read it */
filerr = osd_read(zip->file, buffer, offset, zip->header.compressed_length, &read_length);
if (filerr != FILERR_NONE)
return ZIPERR_FILE_ERROR;
else if (read_length != zip->header.compressed_length)
return ZIPERR_FILE_TRUNCATED;
else
return ZIPERR_NONE;
}
static void identify_file(const char *name, romident_status *status)
{
file_error filerr;
osd_file *file;
UINT64 length;
/* open for read and process if it opens and has a valid length */
filerr = osd_open(name, OPEN_FLAG_READ, &file, &length);
if (filerr == FILERR_NONE && length > 0 && (UINT32)length == length)
{
UINT8 *data = (UINT8 *)malloc(length);
if (data != NULL)
{
UINT32 bytes;
/* read file data into RAM and identify it */
filerr = osd_read(file, data, 0, length, &bytes);
if (filerr == FILERR_NONE)
identify_data(name, data, bytes, status);
free(data);
}
osd_close(file);
}
}
/*-------------------------------------------------
parse_wav_sample - takes a .WAV file, verifies
that the file is 16 bits, and returns the
length in bytes of the data and the offset in
bytes to where the data starts in the file.
-------------------------------------------------*/
static UINT32 parse_wav_sample(const char *filename, UINT32 *dataoffs)
{
unsigned long offset = 0;
UINT32 length, rate, filesize;
UINT16 bits, temp16;
char buf[32];
osd_file *file;
file_error filerr;
UINT64 fsize = 0;
UINT32 actual;
filerr = osd_open(filename, OPEN_FLAG_READ, &file, &fsize);
if (filerr != FILERR_NONE)
{
printf("ERROR: could not open (%s)\n", filename);
return 0;
}
/* read the core header and make sure it's a WAVE file */
osd_read(file, buf, 0, 4, &actual);
offset += actual;
if (offset < 4)
{
osd_close(file);
printf("ERROR: unexpected RIFF offset %lu (%s)\n", offset, filename);
return 0;
}
if (memcmp(&buf[0], "RIFF", 4) != 0)
{
osd_close(file);
printf("ERROR: could not find RIFF header (%s)\n", filename);
return 0;
}
/* get the total size */
osd_read(file, &filesize, offset, 4, &actual);
offset += actual;
if (offset < 8)
{
osd_close(file);
printf("ERROR: unexpected size offset %lu (%s)\n", offset, filename);
return 0;
}
filesize = LITTLE_ENDIANIZE_INT32(filesize);
/* read the RIFF file type and make sure it's a WAVE file */
osd_read(file, buf, offset, 4, &actual);
offset += actual;
if (offset < 12)
{
osd_close(file);
printf("ERROR: unexpected WAVE offset %lu (%s)\n", offset, filename);
return 0;
}
if (memcmp(&buf[0], "WAVE", 4) != 0)
{
osd_close(file);
printf("ERROR: could not find WAVE header (%s)\n", filename);
return 0;
}
/* seek until we find a format tag */
while (1)
{
osd_read(file, buf, offset, 4, &actual);
offset += actual;
osd_read(file, &length, offset, 4, &actual);
offset += actual;
length = LITTLE_ENDIANIZE_INT32(length);
if (memcmp(&buf[0], "fmt ", 4) == 0)
break;
/* seek to the next block */
offset += length;
if (offset >= filesize)
{
osd_close(file);
printf("ERROR: could not find fmt tag (%s)\n", filename);
return 0;
}
}
/* read the format -- make sure it is PCM */
osd_read(file, &temp16, offset, 2, &actual);
offset += actual;
temp16 = LITTLE_ENDIANIZE_INT16(temp16);
if (temp16 != 1)
{
osd_close(file);
printf("ERROR: unsupported format %u - only PCM is supported (%s)\n", temp16, filename);
return 0;
}
/* number of channels -- only stereo is supported */
osd_read(file, &temp16, offset, 2, &actual);
offset += actual;
temp16 = LITTLE_ENDIANIZE_INT16(temp16);
if (temp16 != 2)
{
osd_close(file);
printf("ERROR: unsupported number of channels %u - only stereo is supported (%s)\n", temp16, filename);
return 0;
}
/* sample rate */
osd_read(file, &rate, offset, 4, &actual);
offset += actual;
rate = LITTLE_ENDIANIZE_INT32(rate);
if (rate != 44100)
{
osd_close(file);
printf("ERROR: unsupported samplerate %u - only 44100 is supported (%s)\n", rate, filename);
return 0;
}
/* bytes/second and block alignment are ignored */
osd_read(file, buf, offset, 6, &actual);
offset += actual;
/* bits/sample */
osd_read(file, &bits, offset, 2, &actual);
offset += actual;
if (bits != 16)
{
osd_close(file);
printf("ERROR: unsupported bits/sample %u - only 16 is supported (%s)\n", bits, filename);
return 0;
}
/* seek past any extra data */
offset += length - 16;
/* seek until we find a data tag */
while (1)
{
osd_read(file, buf, offset, 4, &actual);
offset += actual;
osd_read(file, &length, offset, 4, &actual);
offset += actual;
length = LITTLE_ENDIANIZE_INT32(length);
if (memcmp(&buf[0], "data", 4) == 0)
break;
/* seek to the next block */
offset += length;
if (offset >= filesize)
{
osd_close(file);
printf("ERROR: could not find data tag (%s)\n", filename);
return 0;
}
}
osd_close(file);
/* if there was a 0 length data block, we're done */
if (length == 0)
{
printf("ERROR: empty data block (%s)\n", filename);
return 0;
}
*dataoffs = offset;
return length;
}
static zip_error decompress_data_type_8(zip_file *zip, UINT64 offset, void *buffer, UINT32 length)
{
UINT32 input_remaining = zip->header.compressed_length;
UINT32 read_length;
z_stream stream;
int filerr;
int zerr;
/* make sure we don't need a newer mechanism */
if (zip->header.version_needed > 0x14)
return ZIPERR_UNSUPPORTED;
/* reset the stream */
memset(&stream, 0, sizeof(stream));
stream.next_out = (Bytef *)buffer;
stream.avail_out = length;
/* initialize the decompressor */
zerr = inflateInit2(&stream, -MAX_WBITS);
if (zerr != Z_OK)
return ZIPERR_DECOMPRESS_ERROR;
/* loop until we're done */
while (1)
{
/* read in the next chunk of data */
filerr = osd_read(zip->file, zip->buffer, offset, MIN(input_remaining, sizeof(zip->buffer)), &read_length);
if (filerr != FILERR_NONE)
{
inflateEnd(&stream);
return ZIPERR_FILE_ERROR;
}
offset += read_length;
/* if we read nothing, but still have data left, the file is truncated */
if (read_length == 0 && input_remaining > 0)
{
inflateEnd(&stream);
return ZIPERR_FILE_TRUNCATED;
}
/* fill out the input data */
stream.next_in = zip->buffer;
stream.avail_in = read_length;
input_remaining -= read_length;
/* add a dummy byte at end of compressed data */
if (input_remaining == 0)
stream.avail_in++;
/* now inflate */
zerr = inflate(&stream, Z_NO_FLUSH);
if (zerr == Z_STREAM_END)
break;
if (zerr != Z_OK)
{
inflateEnd(&stream);
return ZIPERR_DECOMPRESS_ERROR;
}
}
/* finish decompression */
zerr = inflateEnd(&stream);
if (zerr != Z_OK)
return ZIPERR_DECOMPRESS_ERROR;
/* if anything looks funny, report an error */
if (stream.avail_out > 0 || input_remaining > 0)
return ZIPERR_DECOMPRESS_ERROR;
return ZIPERR_NONE;
}
static zip_error read_ecd(zip_file *zip)
{
UINT32 buflen = 1024;
UINT8 *buffer;
/* we may need multiple tries */
while (buflen < 65536)
{
file_error error;
UINT32 read_length;
INT32 offset;
/* max out the buffer length at the size of the file */
if (buflen > zip->length)
buflen = zip->length;
/* allocate buffer */
buffer = (UINT8 *)malloc(buflen + 1);
if (buffer == nullptr)
return ZIPERR_OUT_OF_MEMORY;
/* read in one buffers' worth of data */
error = osd_read(zip->file, buffer, zip->length - buflen, buflen, &read_length);
if (error != FILERR_NONE || read_length != buflen)
{
free(buffer);
return ZIPERR_FILE_ERROR;
}
/* find the ECD signature */
for (offset = buflen - 22; offset >= 0; offset--)
if (buffer[offset + 0] == 'P' && buffer[offset + 1] == 'K' && buffer[offset + 2] == 0x05 && buffer[offset + 3] == 0x06)
break;
/* if we found it, fill out the data */
if (offset >= 0)
{
/* reuse the buffer as our ECD buffer */
zip->ecd.raw = buffer;
zip->ecd.rawlength = buflen - offset;
/* append a NULL terminator to the comment */
memmove(&buffer[0], &buffer[offset], zip->ecd.rawlength);
zip->ecd.raw[zip->ecd.rawlength] = 0;
/* extract ecd info */
zip->ecd.signature = read_dword(zip->ecd.raw + ZIPESIG);
zip->ecd.disk_number = read_word (zip->ecd.raw + ZIPEDSK);
zip->ecd.cd_start_disk_number = read_word (zip->ecd.raw + ZIPECEN);
zip->ecd.cd_disk_entries = read_word (zip->ecd.raw + ZIPENUM);
zip->ecd.cd_total_entries = read_word (zip->ecd.raw + ZIPECENN);
zip->ecd.cd_size = read_dword(zip->ecd.raw + ZIPECSZ);
zip->ecd.cd_start_disk_offset = read_dword(zip->ecd.raw + ZIPEOFST);
zip->ecd.comment_length = read_word (zip->ecd.raw + ZIPECOML);
zip->ecd.comment = (const char *)(zip->ecd.raw + ZIPECOM);
return ZIPERR_NONE;
}
/* didn't find it; free this buffer and expand our search */
free(buffer);
if (buflen < zip->length)
buflen *= 2;
else
return ZIPERR_BAD_SIGNATURE;
}
return ZIPERR_OUT_OF_MEMORY;
}
zip_error zip_file_open(const char *filename, zip_file **zip)
{
zip_error ziperr = ZIPERR_NONE;
file_error filerr;
UINT32 read_length;
zip_file *newzip;
char *string;
int cachenum;
/* ensure we start with a NULL result */
*zip = nullptr;
/* see if we are in the cache, and reopen if so */
for (cachenum = 0; cachenum < ARRAY_LENGTH(zip_cache); cachenum++)
{
zip_file *cached = zip_cache[cachenum];
/* if we have a valid entry and it matches our filename, use it and remove from the cache */
if (cached != nullptr && cached->filename != nullptr && strcmp(filename, cached->filename) == 0)
{
*zip = cached;
zip_cache[cachenum] = nullptr;
return ZIPERR_NONE;
}
}
/* allocate memory for the zip_file structure */
newzip = (zip_file *)malloc(sizeof(*newzip));
if (newzip == nullptr)
return ZIPERR_OUT_OF_MEMORY;
memset(newzip, 0, sizeof(*newzip));
/* open the file */
filerr = osd_open(filename, OPEN_FLAG_READ, &newzip->file, &newzip->length);
if (filerr != FILERR_NONE)
{
ziperr = ZIPERR_FILE_ERROR;
goto error;
}
/* read ecd data */
ziperr = read_ecd(newzip);
if (ziperr != ZIPERR_NONE)
goto error;
/* verify that we can work with this zipfile (no disk spanning allowed) */
if (newzip->ecd.disk_number != newzip->ecd.cd_start_disk_number || newzip->ecd.cd_disk_entries != newzip->ecd.cd_total_entries)
{
ziperr = ZIPERR_UNSUPPORTED;
goto error;
}
/* allocate memory for the central directory */
newzip->cd = (UINT8 *)malloc(newzip->ecd.cd_size + 1);
if (newzip->cd == nullptr)
{
ziperr = ZIPERR_OUT_OF_MEMORY;
goto error;
}
/* read the central directory */
filerr = osd_read(newzip->file, newzip->cd, newzip->ecd.cd_start_disk_offset, newzip->ecd.cd_size, &read_length);
if (filerr != FILERR_NONE || read_length != newzip->ecd.cd_size)
{
ziperr = (filerr == FILERR_NONE) ? ZIPERR_FILE_TRUNCATED : ZIPERR_FILE_ERROR;
goto error;
}
/* make a copy of the filename for caching purposes */
string = (char *)malloc(strlen(filename) + 1);
if (string == nullptr)
{
ziperr = ZIPERR_OUT_OF_MEMORY;
goto error;
}
strcpy(string, filename);
newzip->filename = string;
*zip = newzip;
return ZIPERR_NONE;
error:
free_zip_file(newzip);
return ziperr;
}
static void identify_file(core_options *options, const char *name, romident_status *status)
{
file_error filerr;
osd_file *file;
UINT64 length;
if (core_filename_ends_with(name, ".chd"))
{
chd_file *chd;
chd_error err;
astring basename;
int found = 0;
core_filename_extract_base(&basename, name, FALSE);
mame_printf_info("%-20s", basename.cstr());
status->total++;
err = chd_open(name, CHD_OPEN_READ, NULL, &chd);
if (err != CHDERR_NONE)
{
mame_printf_info("NOT A CHD\n");
status->nonroms++;
}
else
{
chd_header header;
header = *chd_get_header(chd);
if (header.flags & CHDFLAGS_IS_WRITEABLE)
{
mame_printf_info("is a writable CHD\n");
}
else
{
static const UINT8 nullhash[HASH_BUF_SIZE] = { 0 };
char hash[HASH_BUF_SIZE]; /* actual hash information */
hash_data_clear(hash);
/* if there's an MD5 or SHA1 hash, add them to the output hash */
if (memcmp(nullhash, header.md5, sizeof(header.md5)) != 0)
hash_data_insert_binary_checksum(hash, HASH_MD5, header.md5);
if (memcmp(nullhash, header.sha1, sizeof(header.sha1)) != 0)
hash_data_insert_binary_checksum(hash, HASH_SHA1, header.sha1);
length = header.logicalbytes;
match_roms(options, hash, length, &found);
if (found == 0)
{
mame_printf_info("NO MATCH\n");
}
/* if we did find it, count it as a match */
else
status->matches++;
}
chd_close(chd);
}
}
else
{
/* open for read and process if it opens and has a valid length */
filerr = osd_open(name, OPEN_FLAG_READ, &file, &length);
if (filerr == FILERR_NONE && length > 0 && (UINT32)length == length)
{
UINT8 *data = global_alloc_array(UINT8, length);
if (data != NULL)
{
UINT32 bytes;
/* read file data into RAM and identify it */
filerr = osd_read(file, data, 0, length, &bytes);
if (filerr == FILERR_NONE)
identify_data(options, name, data, bytes, status);
global_free(data);
}
osd_close(file);
}
}
}
