int main(int argc, char *argv[])
{
// validate arguments
if (argc < 3)
{
fprintf(stderr, "Usage:\n%s <input.png> [<input2.png> [...]] <output.bdc>\n", argv[0]);
return 1;
}
const char *bdcname = argv[argc - 1];
// iterate over input files
static render_font font;
bool error = false;
for (int curarg = 1; curarg < argc - 1; curarg++)
{
// load the png file
const char *pngname = argv[curarg];
core_file *file;
file_error filerr = core_fopen(pngname, OPEN_FLAG_READ, &file);
if (filerr != FILERR_NONE)
{
fprintf(stderr, "Error %d attempting to open PNG file\n", filerr);
error = true;
break;
}
bitmap_argb32 bitmap;
png_error pngerr = png_read_bitmap(file, bitmap);
core_fclose(file);
if (pngerr != PNGERR_NONE)
{
fprintf(stderr, "Error %d reading PNG file\n", pngerr);
error = true;
break;
}
// parse the PNG into characters
error = bitmap_to_chars(bitmap, font);
if (error)
break;
}
// write out the resulting font
if (!error)
error = render_font_save_cached(font, bdcname, 0);
// cleanup after ourselves
return error ? 1 : 0;
}
static core_file *create_file_and_output_header(astring &filename, astring &templatefile, astring &path)
{
// create the indexfile
core_file *file;
if (core_fopen(filename, OPEN_FLAG_WRITE | OPEN_FLAG_CREATE | OPEN_FLAG_CREATE_PATHS | OPEN_FLAG_NO_BOM, &file) != FILERR_NONE)
return NULL;
// print a header
astring modified(templatefile);
modified.replace(0, "<!--PATH-->", path.cstr());
core_fwrite(file, modified.cstr(), modified.len());
// return the file
return file;
}
file_error emu_file::open_next()
{
// if we're open from a previous attempt, close up now
if (m_file != NULL)
close();
// loop over paths
file_error filerr = FILERR_NOT_FOUND;
while (m_iterator.next(m_fullpath, m_filename))
{
// attempt to open the file directly
filerr = core_fopen(m_fullpath, m_openflags, &m_file);
if (filerr == FILERR_NONE)
break;
// if we're opening for read-only we have other options
if ((m_openflags & (OPEN_FLAG_READ | OPEN_FLAG_WRITE)) == OPEN_FLAG_READ)
{
filerr = attempt_zipped();
if (filerr == FILERR_NONE)
break;
//FIXME
#if 0
// mamep: load zipped inp file
{
astring zipped_fullname;
int offset = 0;
int n = m_filename.rchr(offset, '.');
if (n > 0)
offset = n;
zipped_fullname.cpy(m_filename, offset);
zipped_fullname.cat(PATH_SEPARATOR);
zipped_fullname.cat(m_filename);
filerr = fopen_attempt_zipped(m_filename, crc, openflags, &m_file);
if (filerr == FILERR_NONE)
break;
}
#endif
}
}
return filerr;
}
static bool find_include_file(astring &srcincpath, int srcrootlen, const astring &srcfile, const astring &filename)
{
// iterate over include paths and find the file
for (include_path *curpath = incpaths; curpath != NULL; curpath = curpath->next)
{
// a '.' include path is specially treated
if (curpath->path == ".")
srcincpath.cpysubstr(srcfile, 0, srcfile.rchr(0, PATH_SEPARATOR[0]));
else
srcincpath.cpy(curpath->path);
// append the filename piecemeal to account for directories
int lastsepindex = 0;
int sepindex;
while ((sepindex = filename.chr(lastsepindex, '/')) != -1)
{
astring pathpart(filename, lastsepindex, sepindex - lastsepindex);
// handle .. by removing a chunk from the incpath
if (pathpart == "..")
{
int sepindex_part = srcincpath.rchr(0, PATH_SEPARATOR[0]);
if (sepindex_part != -1)
srcincpath.substr(0, sepindex_part);
}
// otherwise, append a path separator and the pathpart
else
srcincpath.cat(PATH_SEPARATOR).cat(pathpart);
// advance past the previous index
lastsepindex = sepindex + 1;
}
// now append the filename
srcincpath.cat(PATH_SEPARATOR).catsubstr(filename, lastsepindex, -1);
// see if we can open it
core_file *testfile;
if (core_fopen(srcincpath, OPEN_FLAG_READ, &testfile) == FILERR_NONE)
{
// close the file
core_fclose(testfile);
return true;
}
}
return false;
}
static core_file *create_file_and_output_header(astring &filename, astring &templatefile, astring &title)
{
core_file *file;
/* create the indexfile */
if (core_fopen(filename.c_str(), OPEN_FLAG_WRITE | OPEN_FLAG_CREATE | OPEN_FLAG_CREATE_PATHS | OPEN_FLAG_NO_BOM, &file) != FILERR_NONE)
return NULL;
/* print a header */
astring modified(templatefile);
modified.replace("<!--TITLE-->", title.c_str());
core_fwrite(file, modified.c_str(), modified.len());
/* return the file */
return file;
}
static core_file *create_file_and_output_header(const astring *filename, const astring *templatefile, const astring *title)
{
astring *modified;
core_file *file;
/* create the indexfile */
if (core_fopen(astring_c(filename), OPEN_FLAG_WRITE | OPEN_FLAG_CREATE | OPEN_FLAG_CREATE_PATHS | OPEN_FLAG_NO_BOM, &file) != FILERR_NONE)
return NULL;
/* print a header */
modified = astring_dup(templatefile);
astring_replacec(modified, 0, "<!--TITLE-->", astring_c(title));
core_fwrite(file, astring_c(modified), astring_len(modified));
/* return the file */
astring_free(modified);
return file;
}
static core_file *create_file_and_output_header(const astring *filename, const char *title, const char *subtitle)
{
core_file *file;
/* create the indexfile */
if (core_fopen(astring_c(filename), OPEN_FLAG_WRITE | OPEN_FLAG_CREATE | OPEN_FLAG_CREATE_PATHS | OPEN_FLAG_NO_BOM, &file) != FILERR_NONE)
return NULL;
/* print a header */
core_fprintf(file,
"<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Transitional//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\">\n"
"\n"
"<html xmlns=\"http://www.w3.org/1999/xhtml\">\n"
"<head>\n"
"\t<meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\" />\n"
"\t<title>%s</title>\n"
"\t<link rel=\"stylesheet\" href=\"http://mamedev.org/styles-site.css\" type=\"text/css\" />\n"
"</head>\n"
"\n"
"<body>\n"
"\t<div id=\"outer\">\n"
"\n"
"\t<div id=\"banner\">\n"
"\t<h1>%s</h1>\n"
"\t<h2>%s</h2>\n"
"\t</div>\n"
"\n"
"\t<div id=\"left\">\n"
"\t<div class=\"sidebar\">\n"
"\t<!--#include virtual=\"/links.txt\" -->\n"
"\t</div>\n"
"\t</div>\n"
"\n"
"\t<div id=\"center\">\n"
"\t<div class=\"content\">\n"
"\n",
title, title, (subtitle == NULL) ? " " : subtitle
);
/* return the file */
return file;
}
static file_error OpenDIBFile(const char *dir_name, const char *zip_name, const char *filename,
core_file **file, void **buffer)
{
file_error filerr;
zip_error ziperr;
zip_file *zip;
const zip_file_header *zip_header;
astring *fname;
// clear out result
*file = NULL;
// look for the raw file
fname = astring_assemble_3(astring_alloc(), dir_name, PATH_SEPARATOR, filename);
filerr = core_fopen(astring_c(fname), OPEN_FLAG_READ, file);
astring_free(fname);
// did the raw file not exist?
if (filerr != FILERR_NONE)
{
// look into zip file
fname = astring_assemble_4(astring_alloc(), dir_name, PATH_SEPARATOR, zip_name, ".zip");
ziperr = zip_file_open(astring_c(fname), &zip);
astring_free(fname);
if (ziperr == ZIPERR_NONE)
{
zip_header = zip_file_seek_file(zip, filename);
if (zip_header != NULL)
{
*buffer = malloc(zip_header->uncompressed_length);
ziperr = zip_file_decompress(zip, *buffer, zip_header->uncompressed_length);
if (ziperr == ZIPERR_NONE)
{
filerr = core_fopen_ram(*buffer, zip_header->uncompressed_length, OPEN_FLAG_READ, file);
}
}
zip_file_close(zip);
}
}
return filerr;
}
file_error core_fload(const char *filename, void **data, UINT32 *length)
{
core_file *file = NULL;
file_error err;
UINT64 size;
/* attempt to open the file */
err = core_fopen(filename, OPEN_FLAG_READ, &file);
if (err != FILERR_NONE)
return err;
/* get the size */
size = core_fsize(file);
if ((UINT32)size != size)
{
core_fclose(file);
return FILERR_OUT_OF_MEMORY;
}
/* allocate memory */
*data = osd_malloc(size);
if (length != NULL)
*length = (UINT32)size;
/* read the data */
if (core_fread(file, *data, size) != size)
{
core_fclose(file);
free(*data);
return FILERR_FAILURE;
}
/* close the file and return data */
core_fclose(file);
return FILERR_NONE;
}
static int output_file(file_type type, int srcrootlen, int dstrootlen, astring &srcfile, astring &dstfile, bool link_to_file, astring &tempheader, astring &tempfooter)
{
// extract a normalized subpath
astring srcfile_subpath;
normalized_subpath(srcfile_subpath, srcfile, srcrootlen + 1);
fprintf(stderr, "Processing %s\n", srcfile_subpath.cstr());
// set some defaults
bool color_quotes = false;
const char *comment_start = "";
const char *comment_start_esc = "";
const char *comment_end = "";
const char *comment_end_esc = "";
const char *comment_inline = "";
const char *comment_inline_esc = "";
const char *token_chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_#";
const token_entry *token_table = dummy_token_table;
// based on the file type, set the comment info
switch (type)
{
case FILE_TYPE_C:
color_quotes = true;
comment_start = comment_start_esc = "/*";
comment_end = comment_end_esc = "*/";
comment_inline = comment_inline_esc = "//";
token_table = c_token_table;
break;
case FILE_TYPE_MAKE:
color_quotes = true;
comment_inline = comment_inline_esc = "#";
break;
case FILE_TYPE_XML:
color_quotes = true;
comment_start = "<!--";
comment_start_esc = "<!--";
comment_end = "-->";
comment_end_esc = "-->";
break;
default:
case FILE_TYPE_TEXT:
break;
}
// make the token lookup table
bool is_token[256];
memset(is_token, 0, sizeof(is_token));
for (int toknum = 0; token_chars[toknum] != 0; toknum++)
is_token[(UINT8)token_chars[toknum]] = true;
// open the source file
core_file *src;
if (core_fopen(srcfile, OPEN_FLAG_READ, &src) != FILERR_NONE)
{
fprintf(stderr, "Unable to read file '%s'\n", srcfile.cstr());
return 1;
}
// open the output file
core_file *dst = create_file_and_output_header(dstfile, tempheader, srcfile_subpath);
if (dst == NULL)
{
fprintf(stderr, "Unable to write file '%s'\n", dstfile.cstr());
core_fclose(src);
return 1;
}
// output the directory navigation
core_fprintf(dst, "<h3>Viewing File: ");
output_path_as_links(dst, srcfile_subpath, false, link_to_file);
core_fprintf(dst, "</h3>");
// start with some tags
core_fprintf(dst, "\t<pre class=\"source\">\n");
// iterate over lines in the source file
int linenum = 1;
bool in_comment = false;
char srcline[4096];
while (core_fgets(srcline, ARRAY_LENGTH(srcline), src) != NULL)
{
// start with the line number
astring dstline;
dstline.catprintf("<span class=\"linenum\">%5d</span> ", linenum++);
// iterate over characters in the source line
bool escape = false;
bool in_quotes = false;
bool in_inline_comment = false;
bool last_token_was_include = false;
bool last_was_token = false;
bool quotes_are_linked = false;
UINT8 curquote = 0;
int curcol = 0;
for (char *srcptr = srcline; *srcptr != 0; )
{
UINT8 ch = *srcptr++;
// track whether or not we are within an extended (C-style) comment
if (!in_quotes && !in_inline_comment)
{
if (!in_comment && ch == comment_start[0] && strncmp(srcptr - 1, comment_start, strlen(comment_start)) == 0)
{
dstline.catprintf("<span class=\"comment\">%s", comment_start_esc);
curcol += strlen(comment_start);
srcptr += strlen(comment_start) - 1;
ch = 0;
in_comment = true;
}
else if (in_comment && ch == comment_end[0] && strncmp(srcptr - 1, comment_end, strlen(comment_end)) == 0)
{
dstline.catprintf("%s</span>", comment_end_esc);
curcol += strlen(comment_end);
srcptr += strlen(comment_end) - 1;
ch = 0;
in_comment = false;
}
}
// track whether or not we are within an inline (C++-style) comment
if (!in_quotes && !in_comment && !in_inline_comment && ch == comment_inline[0] && strncmp(srcptr - 1, comment_inline, strlen(comment_inline)) == 0)
{
dstline.catprintf("<span class=\"comment\">%s", comment_inline_esc);
curcol += strlen(comment_inline);
srcptr += strlen(comment_inline) - 1;
ch = 0;
in_inline_comment = true;
}
// if this is the start of a new token, see if we want to color it
if (!in_quotes && !in_comment && !in_inline_comment && !last_was_token && is_token[ch])
{
const token_entry *curtoken;
char *temp = srcptr;
int toklength;
// find the end of the token
while (*temp != 0 && is_token[(UINT8)*temp])
temp++;
toklength = temp - (srcptr - 1);
// scan the token table
last_token_was_include = false;
for (curtoken = token_table; curtoken->token != NULL; curtoken++)
if (strncmp(srcptr - 1, curtoken->token, toklength) == 0 && strlen(curtoken->token) == toklength)
{
dstline.catprintf("<span class=\"%s\">%s</span>", curtoken->color, curtoken->token);
curcol += strlen(curtoken->token);
srcptr += strlen(curtoken->token) - 1;
ch = 0;
// look for include tokens specially
if (type == FILE_TYPE_C && strcmp(curtoken->token, "#include") == 0)
last_token_was_include = true;
break;
}
}
last_was_token = is_token[ch];
// if we hit a tab, expand it
if (ch == 0x09)
{
// compute how many spaces
int spaces = 4 - curcol % 4;
while (spaces--)
{
dstline.cat(' ');
curcol++;
}
}
// otherwise, copy the source character
else if (ch != 0x0a && ch != 0x0d && ch != 0)
{
// track opening quotes
if (!in_comment && !in_inline_comment && !in_quotes && (ch == '"' || ch == '\''))
{
if (color_quotes)
dstline.catprintf("<span class=\"string\">%c", ch);
else
dstline.cat(ch);
in_quotes = true;
curquote = ch;
// handle includes
if (last_token_was_include)
{
char *endquote = strchr(srcptr, ch);
if (endquote != NULL)
{
astring filename(srcptr, endquote - srcptr);
astring target;
if (find_include_file(target, srcrootlen, dstrootlen, srcfile, dstfile, filename))
{
dstline.catprintf("<a href=\"%s\">", target.cstr());
quotes_are_linked = true;
}
}
}
}
// track closing quotes
else if (!in_comment && !in_inline_comment && in_quotes && (ch == curquote) && !escape)
{
if (quotes_are_linked)
dstline.catprintf("</a>");
if (color_quotes)
dstline.catprintf("%c</span>", ch);
else
dstline.cat(ch);
in_quotes = false;
curquote = 0;
quotes_are_linked = false;
}
// else just output the current character
else if (ch == '&')
dstline.catprintf("&");
else if (ch == '<')
dstline.catprintf("<");
else if (ch == '>')
dstline.catprintf(">");
else
dstline.cat(ch);
curcol++;
}
// Update escape state
if (in_quotes)
escape = (ch == '\\' && type == FILE_TYPE_C) ? !escape : false;
}
// finish inline comments
if (in_inline_comment)
{
dstline.catprintf("</span>");
in_inline_comment = false;
}
// append a break and move on
dstline.catprintf("\n");
core_fputs(dst, dstline);
}
// close tags
core_fprintf(dst, "\t</pre>\n");
// close the file
output_footer_and_close_file(dst, tempfooter, srcfile_subpath);
core_fclose(src);
return 0;
}
file_error zippath_fopen(const char *filename, UINT32 openflags, core_file *&file, std::string &revised_path)
{
file_error filerr = FILERR_NOT_FOUND;
zip_error ziperr;
zip_file *zip = NULL;
const zip_file_header *header;
osd_dir_entry_type entry_type;
char *alloc_fullpath = NULL;
int len;
/* first, set up the two types of paths */
std::string mainpath(filename);
std::string subpath;
file = NULL;
/* loop through */
while((file == NULL) && (mainpath.length() > 0)
&& ((openflags == OPEN_FLAG_READ) || (subpath.length() == 0)))
{
/* is the mainpath a ZIP path? */
if (is_zip_file(mainpath.c_str()))
{
/* this file might be a zip file - lets take a look */
ziperr = zip_file_open(mainpath.c_str(), &zip);
if (ziperr == ZIPERR_NONE)
{
/* it is a zip file - error if we're not opening for reading */
if (openflags != OPEN_FLAG_READ)
{
filerr = FILERR_ACCESS_DENIED;
goto done;
}
if (subpath.length() > 0)
header = zippath_find_sub_path(zip, subpath.c_str(), &entry_type);
else
header = zip_file_first_file(zip);
if (header == NULL)
{
filerr = FILERR_NOT_FOUND;
goto done;
}
/* attempt to read the file */
filerr = create_core_file_from_zip(zip, header, file);
if (filerr != FILERR_NONE)
goto done;
/* update subpath, if appropriate */
if (subpath.length() == 0)
subpath.assign(header->filename);
/* we're done */
goto done;
}
}
else if (is_7z_file(mainpath.c_str()))
{
filerr = FILERR_INVALID_DATA;
goto done;
}
if (subpath.length() == 0)
filerr = core_fopen(filename, openflags, &file);
else
filerr = FILERR_NOT_FOUND;
/* if we errored, then go up a directory */
if (filerr != FILERR_NONE)
{
/* go up a directory */
std::string temp;
zippath_parent(temp, mainpath.c_str());
/* append to the sub path */
if (subpath.length() > 0)
{
std::string temp2;
mainpath = mainpath.substr(temp.length());
temp2.assign(mainpath).append(PATH_SEPARATOR).append(subpath);
subpath.assign(temp2);
}
else
{
mainpath = mainpath.substr(temp.length());
subpath.assign(mainpath);
}
/* get the new main path, truncating path separators */
len = temp.length();
while (len > 0 && is_zip_file_separator(temp[len - 1]))
len--;
temp = temp.substr(0, len);
mainpath.assign(temp);
}
}
done:
/* store the revised path */
revised_path.clear();
if (filerr == FILERR_NONE)
{
/* cannonicalize mainpath */
filerr = osd_get_full_path(&alloc_fullpath, mainpath.c_str());
if (filerr == FILERR_NONE)
{
if (subpath.length() > 0)
revised_path.assign(alloc_fullpath).append(PATH_SEPARATOR).append(subpath);
else
revised_path.assign(alloc_fullpath);
}
}
if (zip != NULL)
zip_file_close(zip);
if (alloc_fullpath != NULL)
osd_free(alloc_fullpath);
return filerr;
}
cdrom_file *cdrom_open(const char *inputfile)
{
int i;
cdrom_file *file;
UINT32 physofs;
/* allocate memory for the CD-ROM file */
file = (cdrom_file *)malloc(sizeof(cdrom_file));
if (file == NULL)
return NULL;
/* setup the CDROM module and get the disc info */
chd_error err = chdcd_parse_toc(inputfile, &file->cdtoc, &file->track_info);
if (err != CHDERR_NONE)
{
fprintf(stderr, "Error reading input file: %s\n", chd_error_string(err));
return NULL;
}
/* fill in the data */
file->chd = NULL;
file->hunksectors = 1;
file->cachehunk = -1;
LOG(("CD has %d tracks\n", file->cdtoc.numtrks));
for (i = 0; i < file->cdtoc.numtrks; i++)
{
file_error filerr = core_fopen(file->track_info.fname[i], OPEN_FLAG_READ, &file->fhandle[i]);
if (filerr != FILERR_NONE)
{
fprintf(stderr, "Unable to open file: %s\n", file->track_info.fname[i]);
return NULL;
}
}
/* calculate the starting frame for each track, keeping in mind that CHDMAN
pads tracks out with extra frames to fit hunk size boundries
*/
physofs = 0;
for (i = 0; i < file->cdtoc.numtrks; i++)
{
file->cdtoc.tracks[i].physframeofs = physofs;
file->cdtoc.tracks[i].chdframeofs = 0;
physofs += file->cdtoc.tracks[i].frames;
LOG(("Track %02d is format %d subtype %d datasize %d subsize %d frames %d extraframes %d physofs %d chdofs %d\n", i+1,
file->cdtoc.tracks[i].trktype,
file->cdtoc.tracks[i].subtype,
file->cdtoc.tracks[i].datasize,
file->cdtoc.tracks[i].subsize,
file->cdtoc.tracks[i].frames,
file->cdtoc.tracks[i].extraframes,
file->cdtoc.tracks[i].physframeofs,
file->cdtoc.tracks[i].chdframeofs));
}
/* fill out dummy entries for the last track to help our search */
file->cdtoc.tracks[i].physframeofs = physofs;
file->cdtoc.tracks[i].chdframeofs = 0;
/* allocate a cache */
file->cache = (UINT8 *)malloc(CD_FRAME_SIZE);
if (file->cache == NULL)
{
free(file);
return NULL;
}
return file;
}
static int generate_png_diff(const summary_file *curfile, astring &destdir, const char *destname)
{
bitmap_argb32 bitmaps[MAX_COMPARES];
astring srcimgname;
astring dstfilename;
astring tempname;
bitmap_argb32 finalbitmap;
int width, height, maxwidth;
int bitmapcount = 0;
int listnum, bmnum;
core_file *file = NULL;
file_error filerr;
png_error pngerr;
int error = -1;
int starty;
/* generate the common source filename */
dstfilename.printf("%s" PATH_SEPARATOR "%s", destdir.c_str(), destname);
srcimgname.printf("snap" PATH_SEPARATOR "%s" PATH_SEPARATOR "final.png", curfile->name);
/* open and load all unique bitmaps */
for (listnum = 0; listnum < list_count; listnum++)
if (curfile->matchbitmap[listnum] == listnum)
{
tempname.printf("%s" PATH_SEPARATOR "%s", lists[listnum].dir, srcimgname.c_str());
/* open the source image */
filerr = core_fopen(tempname.c_str(), OPEN_FLAG_READ, &file);
if (filerr != FILERR_NONE)
goto error;
/* load the source image */
pngerr = png_read_bitmap(file, bitmaps[bitmapcount++]);
core_fclose(file);
if (pngerr != PNGERR_NONE)
goto error;
}
/* if there's only one unique bitmap, skip it */
if (bitmapcount <= 1)
goto error;
/* determine the size of the final bitmap */
height = width = 0;
maxwidth = bitmaps[0].width();
for (bmnum = 1; bmnum < bitmapcount; bmnum++)
{
int curwidth;
/* determine the maximal width */
maxwidth = MAX(maxwidth, bitmaps[bmnum].width());
curwidth = bitmaps[0].width() + BITMAP_SPACE + maxwidth + BITMAP_SPACE + maxwidth;
width = MAX(width, curwidth);
/* add to the height */
height += MAX(bitmaps[0].height(), bitmaps[bmnum].height());
if (bmnum != 1)
height += BITMAP_SPACE;
}
/* allocate the final bitmap */
finalbitmap.allocate(width, height);
/* now copy and compare each set of bitmaps */
starty = 0;
for (bmnum = 1; bmnum < bitmapcount; bmnum++)
{
bitmap_argb32 &bitmap1 = bitmaps[0];
bitmap_argb32 &bitmap2 = bitmaps[bmnum];
int curheight = MAX(bitmap1.height(), bitmap2.height());
int x, y;
/* iterate over rows in these bitmaps */
for (y = 0; y < curheight; y++)
{
UINT32 *src1 = (y < bitmap1.height()) ? &bitmap1.pix32(y) : NULL;
UINT32 *src2 = (y < bitmap2.height()) ? &bitmap2.pix32(y) : NULL;
UINT32 *dst1 = &finalbitmap.pix32(starty + y, 0);
UINT32 *dst2 = &finalbitmap.pix32(starty + y, bitmap1.width() + BITMAP_SPACE);
UINT32 *dstdiff = &finalbitmap.pix32(starty + y, bitmap1.width() + BITMAP_SPACE + maxwidth + BITMAP_SPACE);
/* now iterate over columns */
for (x = 0; x < maxwidth; x++)
{
int pix1 = -1, pix2 = -2;
if (src1 != NULL && x < bitmap1.width())
pix1 = dst1[x] = src1[x];
if (src2 != NULL && x < bitmap2.width())
pix2 = dst2[x] = src2[x];
dstdiff[x] = (pix1 != pix2) ? 0xffffffff : 0xff000000;
}
}
/* update the starting Y position */
starty += BITMAP_SPACE + MAX(bitmap1.height(), bitmap2.height());
}
/* write the final PNG */
filerr = core_fopen(dstfilename.c_str(), OPEN_FLAG_WRITE | OPEN_FLAG_CREATE, &file);
if (filerr != FILERR_NONE)
goto error;
pngerr = png_write_bitmap(file, NULL, finalbitmap, 0, NULL);
core_fclose(file);
if (pngerr != PNGERR_NONE)
goto error;
/* if we get here, we are error free */
error = 0;
error:
if (error)
osd_rmfile(dstfilename.c_str());
return error;
}
static int compare_screenshots(summary_file *curfile)
{
bitmap_argb32 bitmaps[MAX_COMPARES];
int unique[MAX_COMPARES];
int numunique = 0;
int listnum;
/* iterate over all files and load their bitmaps */
for (listnum = 0; listnum < list_count; listnum++)
if (curfile->status[listnum] == STATUS_SUCCESS)
{
astring fullname;
file_error filerr;
core_file *file;
/* get the filename for the image */
fullname.printf("%s" PATH_SEPARATOR "snap" PATH_SEPARATOR "%s" PATH_SEPARATOR "final.png", lists[listnum].dir, curfile->name);
/* open the file */
filerr = core_fopen(fullname.c_str(), OPEN_FLAG_READ, &file);
/* if that failed, look in the old location */
if (filerr != FILERR_NONE)
{
/* get the filename for the image */
fullname.printf("%s" PATH_SEPARATOR "snap" PATH_SEPARATOR "_%s.png", lists[listnum].dir, curfile->name);
/* open the file */
filerr = core_fopen(fullname.c_str(), OPEN_FLAG_READ, &file);
}
/* if that worked, load the file */
if (filerr == FILERR_NONE)
{
png_read_bitmap(file, bitmaps[listnum]);
core_fclose(file);
}
}
/* now find all the different bitmap types */
for (listnum = 0; listnum < list_count; listnum++)
{
curfile->matchbitmap[listnum] = 0xff;
if (bitmaps[listnum].valid())
{
bitmap_argb32 &this_bitmap = bitmaps[listnum];
/* compare against all unique bitmaps */
int compnum;
for (compnum = 0; compnum < numunique; compnum++)
{
/* if the sizes are different, we differ; otherwise start off assuming we are the same */
bitmap_argb32 &base_bitmap = bitmaps[unique[compnum]];
bool bitmaps_differ = (this_bitmap.width() != base_bitmap.width() || this_bitmap.height() != base_bitmap.height());
/* compare scanline by scanline */
for (int y = 0; y < this_bitmap.height() && !bitmaps_differ; y++)
{
UINT32 *base = &base_bitmap.pix32(y);
UINT32 *curr = &this_bitmap.pix32(y);
/* scan the scanline */
int x;
for (x = 0; x < this_bitmap.width(); x++)
if (*base++ != *curr++)
break;
bitmaps_differ = (x != this_bitmap.width());
}
/* if we matched, remember which listnum index we matched, and stop */
if (!bitmaps_differ)
{
curfile->matchbitmap[listnum] = unique[compnum];
break;
}
/* if different from the first unique entry, adjust the status */
if (bitmaps_differ && compnum == 0)
curfile->status[listnum] = STATUS_SUCCESS_DIFFERENT;
}
/* if we're unique, add ourselves to the list */
if (compnum >= numunique)
{
unique[numunique++] = listnum;
curfile->matchbitmap[listnum] = listnum;
continue;
}
}
}
/* if all screenshots matched, we're good */
if (numunique == 1)
return BUCKET_GOOD;
/* if the last screenshot matched the first unique one, we're good but changed */
if (curfile->matchbitmap[listnum - 1] == unique[0])
return BUCKET_GOOD_BUT_CHANGED_SCREENSHOTS;
/* otherwise we're just changed */
return BUCKET_CHANGED;
}
static int output_file(file_type type, int srcrootlen, int dstrootlen, const astring *srcfile, const astring *dstfile, int link_to_file)
{
const char *comment_start, *comment_end, *comment_inline, *token_chars;
const char *comment_start_esc, *comment_end_esc, *comment_inline_esc;
const token_entry *token_table;
const astring *srcfile_subpath;
char srcline[4096], *srcptr;
int in_comment = FALSE;
UINT8 is_token[256];
int color_quotes;
core_file *src;
core_file *dst;
int toknum;
int linenum = 1;
/* extract a normalized subpath */
srcfile_subpath = normalized_subpath(srcfile, srcrootlen + 1);
if (srcfile_subpath == NULL)
return 1;
fprintf(stderr, "Processing %s\n", astring_c(srcfile_subpath));
/* set some defaults */
color_quotes = FALSE;
comment_start = comment_start_esc = "";
comment_end = comment_end_esc = "";
comment_inline = comment_inline_esc = "";
token_chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_#";
token_table = dummy_token_table;
/* based on the file type, set the comment info */
switch (type)
{
case FILE_TYPE_C:
color_quotes = TRUE;
comment_start = comment_start_esc = "/*";
comment_end = comment_end_esc = "*/";
comment_inline = comment_inline_esc = "//";
token_table = c_token_table;
break;
case FILE_TYPE_MAKE:
color_quotes = TRUE;
comment_inline = comment_inline_esc = "#";
break;
case FILE_TYPE_XML:
color_quotes = TRUE;
comment_start = "<!--";
comment_start_esc = "<!--";
comment_end = "-->";
comment_end_esc = "-->";
break;
default:
case FILE_TYPE_TEXT:
break;
}
/* make the token lookup table */
memset(is_token, 0, sizeof(is_token));
for (toknum = 0; token_chars[toknum] != 0; toknum++)
is_token[(UINT8)token_chars[toknum]] = TRUE;
/* open the source file */
if (core_fopen(astring_c(srcfile), OPEN_FLAG_READ, &src) != FILERR_NONE)
{
fprintf(stderr, "Unable to read file '%s'\n", astring_c(srcfile));
return 1;
}
/* open the output file */
dst = create_file_and_output_header(dstfile, "MAME Source Code", astring_c(srcfile_subpath));
if (dst == NULL)
{
fprintf(stderr, "Unable to write file '%s'\n", astring_c(dstfile));
core_fclose(src);
return 1;
}
/* output the directory navigation */
core_fprintf(dst, "<h3>Viewing File: ");
output_path_as_links(dst, srcfile_subpath, FALSE, link_to_file);
core_fprintf(dst, "</h3>");
astring_free((astring *)srcfile_subpath);
/* start with some tags */
core_fprintf(dst, "\t<pre style=\"font-family:'Courier New','Courier',monospace; font-size:12px;\">\n");
/* iterate over lines in the source file */
while (core_fgets(srcline, ARRAY_LENGTH(srcline), src) != NULL)
{
char dstline[4096], *dstptr = dstline;
int in_inline_comment = FALSE;
int last_token_was_include = FALSE;
int last_was_token = FALSE;
int quotes_are_linked = FALSE;
char in_quotes = 0;
int curcol = 0;
/* start with the line number */
dstptr += sprintf(dstptr, "<span style=\"" LINENUM_STYLE "\">%5d</span> ", linenum++);
/* iterate over characters in the source line */
for (srcptr = srcline; *srcptr != 0; )
{
UINT8 ch = *srcptr++;
/* track whether or not we are within an extended (C-style) comment */
if (!in_quotes && !in_inline_comment)
{
if (!in_comment && ch == comment_start[0] && strncmp(srcptr - 1, comment_start, strlen(comment_start)) == 0)
{
dstptr += sprintf(dstptr, "<span style=\"" COMMENT_STYLE "\">%s", comment_start_esc);
curcol += strlen(comment_start);
srcptr += strlen(comment_start) - 1;
ch = 0;
in_comment = TRUE;
}
else if (in_comment && ch == comment_end[0] && strncmp(srcptr - 1, comment_end, strlen(comment_end)) == 0)
{
dstptr += sprintf(dstptr, "%s</span>", comment_end_esc);
curcol += strlen(comment_end);
srcptr += strlen(comment_end) - 1;
ch = 0;
in_comment = FALSE;
}
}
/* track whether or not we are within an inline (C++-style) comment */
if (!in_quotes && !in_comment && !in_inline_comment && ch == comment_inline[0] && strncmp(srcptr - 1, comment_inline, strlen(comment_inline)) == 0)
{
dstptr += sprintf(dstptr, "<span style=\"" COMMENT_STYLE "\">%s", comment_inline_esc);
curcol += strlen(comment_inline);
srcptr += strlen(comment_inline) - 1;
ch = 0;
in_inline_comment = TRUE;
}
/* if this is the start of a new token, see if we want to color it */
if (!in_quotes && !in_comment && !in_inline_comment && !last_was_token && is_token[ch])
{
const token_entry *curtoken;
char *temp = srcptr;
int toklength;
/* find the end of the token */
while (*temp != 0 && is_token[(UINT8)*temp])
temp++;
toklength = temp - (srcptr - 1);
/* scan the token table */
last_token_was_include = FALSE;
for (curtoken = token_table; curtoken->token != NULL; curtoken++)
if (strncmp(srcptr - 1, curtoken->token, toklength) == 0 && strlen(curtoken->token) == toklength)
{
dstptr += sprintf(dstptr, "<span style=\"%s\">%s</span>", curtoken->color, curtoken->token);
curcol += strlen(curtoken->token);
srcptr += strlen(curtoken->token) - 1;
ch = 0;
/* look for include tokens specially */
if (type == FILE_TYPE_C && strcmp(curtoken->token, "#include") == 0)
last_token_was_include = TRUE;
break;
}
}
last_was_token = is_token[ch];
/* if we hit a tab, expand it */
if (ch == 0x09)
{
/* compute how many spaces */
int spaces = 4 - curcol % 4;
while (spaces--)
{
*dstptr++ = ' ';
curcol++;
}
}
/* otherwise, copy the source character */
else if (ch != 0x0a && ch != 0x0d && ch != 0)
{
/* track opening quotes */
if (!in_comment && !in_inline_comment && !in_quotes && (ch == '"' || ch == '\''))
{
if (color_quotes)
dstptr += sprintf(dstptr, "<span style=\"" STRING_STYLE "\">%c", ch);
else
*dstptr++ = ch;
in_quotes = ch;
/* handle includes */
if (last_token_was_include)
{
char *endquote = strchr(srcptr, ch);
if (endquote != NULL)
{
astring *filename = astring_dupch(srcptr, endquote - srcptr);
astring *target = find_include_file(srcrootlen, dstrootlen, srcfile, dstfile, filename);
if (target != NULL)
{
dstptr += sprintf(dstptr, "<a href=\"%s\">", astring_c(target));
quotes_are_linked = TRUE;
astring_free(target);
}
astring_free(filename);
}
}
}
/* track closing quotes */
else if (!in_comment && !in_inline_comment && in_quotes && ch == in_quotes && (type != FILE_TYPE_C || srcptr[-2] != '\\' || srcptr[-3] == '\\'))
{
if (quotes_are_linked)
dstptr += sprintf(dstptr, "</a>");
if (color_quotes)
dstptr += sprintf(dstptr, "%c</span>", ch);
else
*dstptr++ = ch;
in_quotes = 0;
quotes_are_linked = FALSE;
}
/* else just output the current character */
else if (ch == '&')
dstptr += sprintf(dstptr, "&");
else if (ch == '<')
dstptr += sprintf(dstptr, "<");
else if (ch == '>')
dstptr += sprintf(dstptr, ">");
else
*dstptr++ = ch;
curcol++;
}
}
/* finish inline comments */
if (in_inline_comment)
{
dstptr += sprintf(dstptr, "</span>");
in_inline_comment = FALSE;
}
/* append a break and move on */
dstptr += sprintf(dstptr, "\n");
core_fputs(dst, dstline);
}
/* close tags */
core_fprintf(dst, "\t</pre>\n");
/* close the file */
output_footer_and_close_file(dst);
core_fclose(src);
return 0;
}
static astring *find_include_file(int srcrootlen, int dstrootlen, const astring *srcfile, const astring *dstfile, const astring *filename)
{
include_path *curpath;
/* iterate over include paths and find the file */
for (curpath = incpaths; curpath != NULL; curpath = curpath->next)
{
astring *srcincpath = astring_cat(astring_dupsubstr(srcfile, 0, srcrootlen + 1), curpath->path);
core_file *testfile;
int lastsepindex = 0;
int sepindex;
/* a '.' include path is specially treated */
if (astring_cmpc(curpath->path, ".") == 0)
astring_cpysubstr(srcincpath, srcfile, 0, astring_rchr(srcfile, 0, PATH_SEPARATOR[0]));
/* append the filename piecemeal to account for directories */
while ((sepindex = astring_chr(filename, lastsepindex, '/')) != -1)
{
astring *pathpart = astring_dupsubstr(filename, lastsepindex, sepindex - lastsepindex);
/* handle .. by removing a chunk from the incpath */
if (astring_cmpc(pathpart, "..") == 0)
{
sepindex = astring_rchr(srcincpath, 0, PATH_SEPARATOR[0]);
if (sepindex != -1)
astring_substr(srcincpath, 0, sepindex);
}
/* otherwise, append a path separator and the pathpart */
else
astring_cat(astring_catc(srcincpath, PATH_SEPARATOR), pathpart);
/* advance past the previous index */
lastsepindex = sepindex + 1;
/* free the path part we extracted */
astring_free(pathpart);
}
/* now append the filename */
astring_catsubstr(astring_catc(srcincpath, PATH_SEPARATOR), filename, lastsepindex, -1);
/* see if we can open it */
if (core_fopen(astring_c(srcincpath), OPEN_FLAG_READ, &testfile) == FILERR_NONE)
{
astring *tempfile = astring_alloc();
astring *tempinc = astring_alloc();
/* close the file */
core_fclose(testfile);
/* find the longest matching directory substring between the include and source file */
lastsepindex = 0;
while ((sepindex = astring_chr(srcincpath, lastsepindex, PATH_SEPARATOR[0])) != -1)
{
/* get substrings up to the current directory */
astring_cpysubstr(tempfile, srcfile, 0, sepindex);
astring_cpysubstr(tempinc, srcincpath, 0, sepindex);
/* if we don't match, stop */
if (astring_cmp(tempfile, tempinc) != 0)
break;
lastsepindex = sepindex + 1;
}
/* chop off the common parts of the paths */
astring_cpysubstr(tempfile, srcfile, lastsepindex, -1);
astring_replacechr(astring_substr(srcincpath, lastsepindex, -1), PATH_SEPARATOR[0], '/');
/* for each directory left in the filename, we need to prepend a "../" */
while ((sepindex = astring_chr(tempfile, 0, PATH_SEPARATOR[0])) != -1)
{
astring_substr(tempfile, sepindex + 1, -1);
astring_insc(srcincpath, 0, "../");
}
astring_catc(srcincpath, ".html");
/* free the strings and return the include path */
astring_free(tempfile);
astring_free(tempinc);
return srcincpath;
}
/* free our include path */
astring_free(srcincpath);
}
return NULL;
}
static bool render_font_save_cached(render_font &font, const char *filename, UINT32 hash)
{
// attempt to open the file
core_file *file;
file_error filerr = core_fopen(filename, OPEN_FLAG_WRITE | OPEN_FLAG_CREATE, &file);
if (filerr != FILERR_NONE)
return true;
try
{
// determine the number of characters
int numchars = 0;
for (int chnum = 0; chnum < 65536; chnum++)
if (font.chars[chnum].width > 0)
numchars++;
// write the header
dynamic_buffer tempbuffer(65536);
UINT8 *dest = &tempbuffer[0];
*dest++ = 'f';
*dest++ = 'o';
*dest++ = 'n';
*dest++ = 't';
*dest++ = hash >> 24;
*dest++ = hash >> 16;
*dest++ = hash >> 8;
*dest++ = hash & 0xff;
*dest++ = font.height >> 8;
*dest++ = font.height & 0xff;
*dest++ = font.yoffs >> 8;
*dest++ = font.yoffs & 0xff;
*dest++ = numchars >> 24;
*dest++ = numchars >> 16;
*dest++ = numchars >> 8;
*dest++ = numchars & 0xff;
write_data(*file, tempbuffer, dest);
// write the empty table to the beginning of the file
dynamic_buffer chartable(numchars * CACHED_CHAR_SIZE + 1, 0);
write_data(*file, &chartable[0], &chartable[numchars * CACHED_CHAR_SIZE]);
// loop over all characters
int tableindex = 0;
for (int chnum = 0; chnum < 65536; chnum++)
{
render_font_char &ch = font.chars[chnum];
if (ch.width > 0)
{
// write out a bit-compressed bitmap if we have one
if (ch.bitmap != NULL)
{
// write the data to the tempbuffer
dest = tempbuffer;
UINT8 accum = 0;
UINT8 accbit = 7;
// bit-encode the character data
for (int y = 0; y < ch.bmheight; y++)
{
int desty = y + font.height + font.yoffs - ch.yoffs - ch.bmheight;
const UINT32 *src = (desty >= 0 && desty < font.height) ? &ch.bitmap->pix32(desty) : NULL;
for (int x = 0; x < ch.bmwidth; x++)
{
if (src != NULL && src[x] != 0)
accum |= 1 << accbit;
if (accbit-- == 0)
{
*dest++ = accum;
accum = 0;
accbit = 7;
}
}
}
// flush any extra
if (accbit != 7)
*dest++ = accum;
// write the data
write_data(*file, tempbuffer, dest);
// free the bitmap and texture
global_free(ch.bitmap);
ch.bitmap = NULL;
}
// compute the table entry
dest = &chartable[tableindex++ * CACHED_CHAR_SIZE];
*dest++ = chnum >> 8;
*dest++ = chnum & 0xff;
*dest++ = ch.width >> 8;
*dest++ = ch.width & 0xff;
*dest++ = ch.xoffs >> 8;
*dest++ = ch.xoffs & 0xff;
*dest++ = ch.yoffs >> 8;
*dest++ = ch.yoffs & 0xff;
*dest++ = ch.bmwidth >> 8;
*dest++ = ch.bmwidth & 0xff;
*dest++ = ch.bmheight >> 8;
*dest++ = ch.bmheight & 0xff;
}
}
// seek back to the beginning and rewrite the table
core_fseek(file, CACHED_HEADER_SIZE, SEEK_SET);
write_data(*file, &chartable[0], &chartable[numchars * CACHED_CHAR_SIZE]);
// all done
core_fclose(file);
return false;
}
catch (...)
{
core_fclose(file);
osd_rmfile(filename);
return true;
}
}
static int generate_png_diff(const astring& imgfile1, const astring& imgfile2, const astring& outfilename)
{
bitmap_argb32 bitmap1;
bitmap_argb32 bitmap2;
bitmap_argb32 finalbitmap;
int width, height, maxwidth;
core_file *file = NULL;
file_error filerr;
png_error pngerr;
int error = 100;
bool bitmaps_differ;
int x, y;
/* open the source image */
filerr = core_fopen(imgfile1, OPEN_FLAG_READ, &file);
if (filerr != FILERR_NONE)
{
printf("Could not open %s (%d)\n", imgfile1.cstr(), filerr);
goto error;
}
/* load the source image */
pngerr = png_read_bitmap(file, bitmap1);
core_fclose(file);
if (pngerr != PNGERR_NONE)
{
printf("Could not read %s (%d)\n", imgfile1.cstr(), pngerr);
goto error;
}
/* open the source image */
filerr = core_fopen(imgfile2, OPEN_FLAG_READ, &file);
if (filerr != FILERR_NONE)
{
printf("Could not open %s (%d)\n", imgfile2.cstr(), filerr);
goto error;
}
/* load the source image */
pngerr = png_read_bitmap(file, bitmap2);
core_fclose(file);
if (pngerr != PNGERR_NONE)
{
printf("Could not read %s (%d)\n", imgfile2.cstr(), pngerr);
goto error;
}
/* if the sizes are different, we differ; otherwise start off assuming we are the same */
bitmaps_differ = (bitmap2.width() != bitmap1.width() || bitmap2.height() != bitmap1.height());
/* compare scanline by scanline */
for (y = 0; y < bitmap2.height() && !bitmaps_differ; y++)
{
UINT32 *base = &bitmap1.pix32(y);
UINT32 *curr = &bitmap2.pix32(y);
/* scan the scanline */
for (x = 0; x < bitmap2.width(); x++)
if (*base++ != *curr++)
break;
bitmaps_differ = (x != bitmap2.width());
}
if (bitmaps_differ)
{
/* determine the size of the final bitmap */
height = width = 0;
{
/* determine the maximal width */
maxwidth = MAX(bitmap1.width(), bitmap2.width());
width = bitmap1.width() + BITMAP_SPACE + maxwidth + BITMAP_SPACE + maxwidth;
/* add to the height */
height += MAX(bitmap1.height(), bitmap2.height());
}
/* allocate the final bitmap */
finalbitmap.allocate(width, height);
/* now copy and compare each set of bitmaps */
int curheight = MAX(bitmap1.height(), bitmap2.height());
/* iterate over rows in these bitmaps */
for (y = 0; y < curheight; y++)
{
UINT32 *src1 = (y < bitmap1.height()) ? &bitmap1.pix32(y) : NULL;
UINT32 *src2 = (y < bitmap2.height()) ? &bitmap2.pix32(y) : NULL;
UINT32 *dst1 = &finalbitmap.pix32(y);
UINT32 *dst2 = &finalbitmap.pix32(y, bitmap1.width() + BITMAP_SPACE);
UINT32 *dstdiff = &finalbitmap.pix32(y, bitmap1.width() + BITMAP_SPACE + maxwidth + BITMAP_SPACE);
/* now iterate over columns */
for (x = 0; x < maxwidth; x++)
{
int pix1 = -1, pix2 = -2;
if (src1 != NULL && x < bitmap1.width())
pix1 = dst1[x] = src1[x];
if (src2 != NULL && x < bitmap2.width())
pix2 = dst2[x] = src2[x];
dstdiff[x] = (pix1 != pix2) ? 0xffffffff : 0xff000000;
}
}
/* write the final PNG */
filerr = core_fopen(outfilename, OPEN_FLAG_WRITE | OPEN_FLAG_CREATE, &file);
if (filerr != FILERR_NONE)
{
printf("Could not open %s (%d)\n", outfilename.cstr(), filerr);
goto error;
}
pngerr = png_write_bitmap(file, NULL, finalbitmap, 0, NULL);
core_fclose(file);
if (pngerr != PNGERR_NONE)
{
printf("Could not write %s (%d)\n", outfilename.cstr(), pngerr);
goto error;
}
}
/* if we get here, we are error free */
if (bitmaps_differ)
error = 1;
else
error = 0;
error:
if (error == -1)
osd_rmfile(outfilename);
return error;
}
static int compare_screenshots(summary_file *curfile)
{
bitmap_t *bitmaps[MAX_COMPARES];
int unique[MAX_COMPARES];
int numunique = 0;
int listnum;
/* iterate over all files and load their bitmaps */
for (listnum = 0; listnum < list_count; listnum++)
{
bitmaps[listnum] = NULL;
if (curfile->status[listnum] == STATUS_SUCCESS)
{
file_error filerr;
const char *fullname;
char imgname[100];
core_file *file;
/* get the filename for the image */
sprintf(imgname, "snap" PATH_SEPARATOR "%s" PATH_SEPARATOR "final.png", curfile->name);
fullname = alloc_filename(lists[listnum].dir, imgname);
/* open the file */
filerr = core_fopen(fullname, OPEN_FLAG_READ, &file);
free((void *)fullname);
/* if that failed, look in the old location */
if (filerr != FILERR_NONE)
{
/* get the filename for the image */
sprintf(imgname, "snap" PATH_SEPARATOR "_%s.png", curfile->name);
fullname = alloc_filename(lists[listnum].dir, imgname);
/* open the file */
filerr = core_fopen(fullname, OPEN_FLAG_READ, &file);
free((void *)fullname);
}
/* if that worked, load the file */
if (filerr == FILERR_NONE)
{
png_read_bitmap(file, &bitmaps[listnum]);
core_fclose(file);
}
}
}
/* now find all the different bitmap types */
for (listnum = 0; listnum < list_count; listnum++)
{
curfile->matchbitmap[listnum] = 0xff;
if (bitmaps[listnum] != NULL)
{
bitmap_t *this_bitmap = bitmaps[listnum];
int compnum;
/* compare against all unique bitmaps */
for (compnum = 0; compnum < numunique; compnum++)
{
bitmap_t *base_bitmap = bitmaps[unique[compnum]];
int bitmaps_differ;
int x, y;
/* if the sizes are different, we differ; otherwise start off assuming we are the same */
bitmaps_differ = (this_bitmap->width != base_bitmap->width || this_bitmap->height != base_bitmap->height);
/* compare scanline by scanline */
for (y = 0; y < this_bitmap->height && !bitmaps_differ; y++)
{
UINT32 *base = BITMAP_ADDR32(base_bitmap, y, 0);
UINT32 *curr = BITMAP_ADDR32(this_bitmap, y, 0);
/* scan the scanline */
for (x = 0; x < this_bitmap->width; x++)
if (*base++ != *curr++)
break;
bitmaps_differ = (x != this_bitmap->width);
}
/* if we matched, remember which listnum index we matched, and stop */
if (!bitmaps_differ)
{
curfile->matchbitmap[listnum] = unique[compnum];
break;
}
/* if different from the first unique entry, adjust the status */
if (bitmaps_differ && compnum == 0)
curfile->status[listnum] = STATUS_SUCCESS_DIFFERENT;
}
/* if we're unique, add ourselves to the list */
if (compnum >= numunique)
{
unique[numunique++] = listnum;
curfile->matchbitmap[listnum] = listnum;
continue;
}
}
}
/* free the bitmaps */
for (listnum = 0; listnum < list_count; listnum++)
if (bitmaps[listnum] != NULL)
bitmap_free(bitmaps[listnum]);
/* if all screenshots matched, we're good */
if (numunique == 1)
return BUCKET_GOOD;
/* if the last screenshot matched the first unique one, we're good but changed */
if (curfile->matchbitmap[listnum - 1] == unique[0])
return BUCKET_GOOD_BUT_CHANGED_SCREENSHOTS;
/* otherwise we're just changed */
return BUCKET_CHANGED;
}
Disc* load_gdi(const char* file)
{
u32 iso_tc;
Disc* disc = new Disc();
//memset(&gdi_toc,0xFFFFFFFF,sizeof(gdi_toc));
//memset(&gdi_ses,0xFFFFFFFF,sizeof(gdi_ses));
core_file* t=core_fopen(file);
if (!t)
return 0;
size_t gdi_len = core_fsize(t);
char gdi_data[8193] = { 0 };
if (gdi_len >= sizeof(gdi_data))
{
core_fclose(t);
return 0;
}
core_fread(t, gdi_data, gdi_len);
core_fclose(t);
istringstream gdi(gdi_data);
gdi >> iso_tc;
printf("\nGDI : %d tracks\n",iso_tc);
char path[512];
strcpy(path,file);
size_t len=strlen(file);
while (len>2)
{
if (path[len]=='\\' || path[len]=='/')
break;
len--;
}
len++;
char* pathptr=&path[len];
u32 TRACK=0,FADS=0,CTRL=0,SSIZE=0;
s32 OFFSET=0;
for (u32 i=0;i<iso_tc;i++)
{
string track_filename;
//TRACK FADS CTRL SSIZE file OFFSET
gdi >> TRACK;
gdi >> FADS;
gdi >> CTRL;
gdi >> SSIZE;
char last;
do {
gdi >> last;
} while (isspace(last));
if (last == '"')
{
gdi >> std::noskipws;
for(;;) {
gdi >> last;
if (last == '"')
break;
track_filename += last;
}
gdi >> std::skipws;
}
else
{
static bool find_include_file(astring &srcincpath, int srcrootlen, int dstrootlen, astring &srcfile, astring &dstfile, astring &filename)
{
// iterate over include paths and find the file
for (include_path *curpath = incpaths; curpath != NULL; curpath = curpath->next)
{
// a '.' include path is specially treated
if (curpath->path == ".")
srcincpath.cpysubstr(srcfile, 0, srcfile.rchr(0, PATH_SEPARATOR[0]));
else
srcincpath.cpysubstr(srcfile, 0, srcrootlen + 1).cat(curpath->path);
// append the filename piecemeal to account for directories
int lastsepindex = 0;
int sepindex;
while ((sepindex = filename.chr(lastsepindex, '/')) != -1)
{
// handle .. by removing a chunk from the incpath
astring pathpart(filename, lastsepindex, sepindex - lastsepindex);
if (pathpart == "..")
{
sepindex = srcincpath.rchr(0, PATH_SEPARATOR[0]);
if (sepindex != -1)
srcincpath.substr(0, sepindex);
}
// otherwise, append a path separator and the pathpart
else
srcincpath.cat(PATH_SEPARATOR).cat(pathpart);
// advance past the previous index
lastsepindex = sepindex + 1;
}
// now append the filename
srcincpath.cat(PATH_SEPARATOR).catsubstr(filename, lastsepindex, -1);
// see if we can open it
core_file *testfile;
if (core_fopen(srcincpath, OPEN_FLAG_READ, &testfile) == FILERR_NONE)
{
// close the file
core_fclose(testfile);
// find the longest matching directory substring between the include and source file
lastsepindex = 0;
while ((sepindex = srcincpath.chr(lastsepindex, PATH_SEPARATOR[0])) != -1)
{
// get substrings up to the current directory
astring tempfile(srcfile, 0, sepindex);
astring tempinc(srcincpath, 0, sepindex);
// if we don't match, stop
if (tempfile != tempinc)
break;
lastsepindex = sepindex + 1;
}
// chop off the common parts of the paths
astring tempfile(srcfile, lastsepindex, -1);
srcincpath.substr(lastsepindex, -1).replacechr(PATH_SEPARATOR[0], '/');
// for each directory left in the filename, we need to prepend a "../"
while ((sepindex = tempfile.chr(0, PATH_SEPARATOR[0])) != -1)
{
tempfile.substr(sepindex + 1, -1);
srcincpath.ins(0, "../");
}
srcincpath.cat(".html");
// free the strings and return the include path
return true;
}
}
return false;
}
static int generate_png_diff(const summary_file *curfile, const astring *destdir, const char *destname)
{
bitmap_t *bitmaps[MAX_COMPARES] = { NULL };
astring *srcimgname = astring_alloc();
astring *dstfilename = astring_alloc();
astring *tempname = astring_alloc();
bitmap_t *finalbitmap = NULL;
int width, height, maxwidth;
int bitmapcount = 0;
int listnum, bmnum;
core_file *file = NULL;
file_error filerr;
png_error pngerr;
int error = -1;
int starty;
/* generate the common source filename */
astring_printf(dstfilename, "%s" PATH_SEPARATOR "%s", astring_c(destdir), destname);
astring_printf(srcimgname, "snap" PATH_SEPARATOR "%s" PATH_SEPARATOR "final.png", curfile->name);
/* open and load all unique bitmaps */
for (listnum = 0; listnum < list_count; listnum++)
if (curfile->matchbitmap[listnum] == listnum)
{
astring_printf(tempname, "%s" PATH_SEPARATOR "%s", lists[listnum].dir, astring_c(srcimgname));
/* open the source image */
filerr = core_fopen(astring_c(tempname), OPEN_FLAG_READ, &file);
if (filerr != FILERR_NONE)
goto error;
/* load the source image */
pngerr = png_read_bitmap(file, &bitmaps[bitmapcount++]);
core_fclose(file);
if (pngerr != PNGERR_NONE)
goto error;
}
/* if there's only one unique bitmap, skip it */
if (bitmapcount <= 1)
goto error;
/* determine the size of the final bitmap */
height = width = 0;
maxwidth = bitmaps[0]->width;
for (bmnum = 1; bmnum < bitmapcount; bmnum++)
{
int curwidth;
/* determine the maximal width */
maxwidth = MAX(maxwidth, bitmaps[bmnum]->width);
curwidth = bitmaps[0]->width + BITMAP_SPACE + maxwidth + BITMAP_SPACE + maxwidth;
width = MAX(width, curwidth);
/* add to the height */
height += MAX(bitmaps[0]->height, bitmaps[bmnum]->height);
if (bmnum != 1)
height += BITMAP_SPACE;
}
/* allocate the final bitmap */
finalbitmap = bitmap_alloc(width, height, BITMAP_FORMAT_ARGB32);
if (finalbitmap == NULL)
goto error;
/* now copy and compare each set of bitmaps */
starty = 0;
for (bmnum = 1; bmnum < bitmapcount; bmnum++)
{
bitmap_t *bitmap1 = bitmaps[0];
bitmap_t *bitmap2 = bitmaps[bmnum];
int curheight = MAX(bitmap1->height, bitmap2->height);
int x, y;
/* iterate over rows in these bitmaps */
for (y = 0; y < curheight; y++)
{
UINT32 *src1 = (y < bitmap1->height) ? BITMAP_ADDR32(bitmap1, y, 0) : NULL;
UINT32 *src2 = (y < bitmap2->height) ? BITMAP_ADDR32(bitmap2, y, 0) : NULL;
UINT32 *dst1 = BITMAP_ADDR32(finalbitmap, starty + y, 0);
UINT32 *dst2 = BITMAP_ADDR32(finalbitmap, starty + y, bitmap1->width + BITMAP_SPACE);
UINT32 *dstdiff = BITMAP_ADDR32(finalbitmap, starty + y, bitmap1->width + BITMAP_SPACE + maxwidth + BITMAP_SPACE);
/* now iterate over columns */
for (x = 0; x < maxwidth; x++)
{
int pix1 = -1, pix2 = -2;
if (src1 != NULL && x < bitmap1->width)
pix1 = dst1[x] = src1[x];
if (src2 != NULL && x < bitmap2->width)
pix2 = dst2[x] = src2[x];
dstdiff[x] = (pix1 != pix2) ? 0xffffffff : 0xff000000;
}
}
/* update the starting Y position */
starty += BITMAP_SPACE + MAX(bitmap1->height, bitmap2->height);
}
/* write the final PNG */
filerr = core_fopen(astring_c(dstfilename), OPEN_FLAG_WRITE | OPEN_FLAG_CREATE, &file);
if (filerr != FILERR_NONE)
goto error;
pngerr = png_write_bitmap(file, NULL, finalbitmap, 0, NULL);
core_fclose(file);
if (pngerr != PNGERR_NONE)
goto error;
/* if we get here, we are error free */
error = 0;
error:
if (finalbitmap != NULL)
bitmap_free(finalbitmap);
for (bmnum = 0; bmnum < bitmapcount; bmnum++)
if (bitmaps[bmnum] != NULL)
bitmap_free(bitmaps[bmnum]);
if (error)
osd_rmfile(astring_c(dstfilename));
astring_free(dstfilename);
astring_free(srcimgname);
astring_free(tempname);
return error;
}
imgtool_stream *stream_open(const char *fname, int read_or_write)
{
file_error filerr;
const char *ext;
imgtool_stream *imgfile = NULL;
static const UINT32 write_modes[] =
{
OPEN_FLAG_READ,
OPEN_FLAG_WRITE | OPEN_FLAG_CREATE,
OPEN_FLAG_READ | OPEN_FLAG_WRITE,
OPEN_FLAG_READ | OPEN_FLAG_WRITE | OPEN_FLAG_CREATE
};
core_file *f = NULL;
char *buf = NULL;
int len, i;
imgtool_stream *s = NULL;
char c;
/* maybe we are just a ZIP? */
ext = strrchr(fname, '.');
if (ext && !mame_stricmp(ext, ".zip"))
return stream_open_zip(fname, NULL, read_or_write);
filerr = core_fopen(fname, write_modes[read_or_write], &f);
if (filerr != FILERR_NONE)
{
if (!read_or_write)
{
len = strlen(fname);
/* can't open the file; try opening ZIP files with other names */
buf = (char*)malloc(len + 1);
if (!buf)
goto error;
strcpy(buf, fname);
for(i = len-1; !s && (i >= 0); i--)
{
if ((buf[i] == '\\') || (buf[i] == '/'))
{
c = buf[i];
buf[i] = '\0';
s = stream_open_zip(buf, buf + i + 1, read_or_write);
buf[i] = c;
}
}
free(buf);
buf = NULL;
if (s)
return s;
}
/* ah well, it was worth a shot */
goto error;
}
imgfile = (imgtool_stream *)malloc(sizeof(struct _imgtool_stream));
if (!imgfile)
goto error;
/* Normal file */
memset(imgfile, 0, sizeof(*imgfile));
imgfile->imgtype = IMG_FILE;
imgfile->position = 0;
imgfile->filesize = core_fsize(f);
imgfile->write_protect = read_or_write ? 0 : 1;
imgfile->u.file = f;
imgfile->name = fname;
return imgfile;
error:
if (imgfile != NULL)
free((void *) imgfile);
if (f != NULL)
core_fclose(f);
if (buf)
free(buf);
return (imgtool_stream *) NULL;
}
int parse_for_drivers(const char *srcfile)
{
// read source file
core_file *file = NULL;
file_error filerr = core_fopen(srcfile, OPEN_FLAG_READ, &file);
if (filerr != FILERR_NONE)
{
fprintf(stderr, "Unable to read source file '%s'\n", srcfile);
return 1;
}
// loop over lines in the file
char buffer[4096];
while (core_fgets(buffer, ARRAY_LENGTH(buffer), file) != NULL)
{
astring line;
// rip through it to find all drivers
char *srcptr = (char *)buffer;
char *endptr = srcptr + strlen(buffer);
bool in_comment = false;
while (srcptr < endptr)
{
char c = *srcptr++;
// skip any spaces
if (isspace(c))
continue;
// look for end of C comment
if (in_comment && c == '*' && *srcptr == '/')
{
srcptr++;
in_comment = false;
continue;
}
// skip anything else inside a C comment
if (in_comment)
continue;
// look for start of C comment
if (c == '/' && *srcptr == '*')
{
srcptr++;
in_comment = true;
continue;
}
// if we hit a C++ comment, scan to the end of line
if (c == '/' && *srcptr == '/')
{
while (srcptr < endptr && *srcptr != 13 && *srcptr != 10)
srcptr++;
continue;
}
srcptr--;
for (int pos = 0; srcptr < endptr && !isspace(*srcptr); pos++)
{
line.cat(*srcptr++);
}
}
if ((line.find(0,"GAME(")==0) || (line.find(0,"GAMEL(")==0) ||
(line.find(0,"COMP(")==0) || (line.find(0,"CONS(")==0) ||
(line.find(0,"SYST(")==0))
{
int p1 = line.find(0,",");
if (p1<0) continue;
int p2 = line.find(p1+1,",");
if (p2<0) continue;
printf("%s\n",line.substr(p1+1,p2-p1-1).cstr());
}
}
core_fclose(file);
return 0;
}
