void LanguageManager::createTable(Common::File *fp) {
// get number of languages
_numLanguages =
(gameVersion >= VERSION(1, 3)) ? (fp->readByte()) : 0;
debugC(2, kSludgeDebugDataLoad, "numLanguages : %c", _numLanguages);
// make language table
_languageTable = new uint[_numLanguages + 1];
if (!checkNew(_languageTable))
return;
_languageNames = new Common::String[_numLanguages + 1];
if (!checkNew(_languageNames))
return;
for (uint i = 0; i <= _numLanguages; i++) {
_languageTable[i] = i ? fp->readUint16BE() : 0;
debugC(2, kSludgeDebugDataLoad, "languageTable %i: %i", i, _languageTable[i]);
_languageNames[i].clear();
if (gameVersion >= VERSION(2, 0)) {
if (_numLanguages) {
_languageNames[i] = readString(fp);
debugC(2, kSludgeDebugDataLoad, "languageName %i: %s\n", i, _languageNames[i].c_str());
}
}
}
}
void postDump(IntX level, LongN start)
{
DL(1, (OUTPUTBUFF, "### [post] (%08lx)\n", start));
if (!loaded)
return;
DLV(2, "version =", post->version);
DLF(2, "italicAngle =", post->italicAngle);
DLs(2, "underlinePosition =", post->underlinePosition);
DLs(2, "underlineThickness=", post->underlineThickness);
DLU(2, "isFixedPitch =", post->isFixedPitch);
DLU(2, "minMemType42 =", post->minMemType42);
DLU(2, "maxMemType42 =", post->maxMemType42);
DLU(2, "minMemType1 =", post->minMemType1);
DLU(2, "maxMemType1 =", post->maxMemType1);
switch (post->version)
{
case VERSION(1,0):
break;
case VERSION(2,0):
dump2_0((Format2_0 *)post->format, level);
break;
case VERSION(2,5):
dump2_5((Format2_5 *)post->format, level);
break;
case VERSION(3,0):
break;
case VERSION(4,0):
dump4_0((Format4_0 *)post->format, level);
}
}
void GraphicsManager::showThumbnail(const Common::String &filename, int atX, int atY) {
Common::InSaveFile *fp = g_system->getSavefileManager()->openForLoading(filename);
if (fp == nullptr)
return;
bool headerBad = false;
if (fp->readByte() != 'S')
headerBad = true;
if (fp->readByte() != 'L')
headerBad = true;
if (fp->readByte() != 'U')
headerBad = true;
if (fp->readByte() != 'D')
headerBad = true;
if (fp->readByte() != 'S')
headerBad = true;
if (fp->readByte() != 'A')
headerBad = true;
if (headerBad) {
fatal(ERROR_GAME_LOAD_NO, filename);
return;
}
char c = fp->readByte();
while ((c = fp->readByte()))
;
int majVersion = fp->readByte();
int minVersion = fp->readByte();
int ssgVersion = VERSION(majVersion, minVersion);
if (ssgVersion >= VERSION(1, 4)) {
int fileWidth = fp->readUint32LE();
int fileHeight = fp->readUint32LE();
Graphics::TransparentSurface thumbnail;
if (!ImgLoader::loadPNGImage(fp, &thumbnail))
return;
delete fp;
fp = nullptr;
if (atX < 0) {
fileWidth += atX;
atX = 0;
}
if (atY < 0) {
fileHeight += atY;
atY = 0;
}
if (fileWidth + atX > (int)_sceneWidth)
fileWidth = _sceneWidth - atX;
if (fileHeight + atY > (int)_sceneHeight)
fileHeight = _sceneHeight - atY;
thumbnail.blit(_backdropSurface, atX, atY, Graphics::FLIP_NONE, nullptr, TS_ARGB(255, 255, 255, 255), fileWidth, fileHeight);
thumbnail.free();
}
}
static void
allrdatasets(isc_assertioncallback_t callback) {
isc_result_t result;
dns_dbnode_t *node = NULL;
dns_rdatasetiter_t *iterator = NULL;
result = dns_test_begin(NULL, ISC_FALSE);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
setup_db();
result = dns_db_findnode(db1, dns_rootname, ISC_FALSE, &node);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
isc_assertion_setcallback(callback);
result = dns_db_allrdatasets(db1, node, VERSION(callback), 0,
&iterator);
if (callback != NULL)
atf_tc_fail("dns_db_allrdatasets did not assert");
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
dns_rdatasetiter_destroy(&iterator);
ATF_REQUIRE_EQ(iterator, NULL);
dns_db_detachnode(db1, &node);
ATF_REQUIRE_EQ(node, NULL);
close_db();
dns_test_end();
}
static struct oio_url_s *
_metacd_load_url (struct req_args_s *args)
{
const gchar *s;
struct oio_url_s *url = oio_url_empty();
if (NULL != (s = NS()))
oio_url_set (url, OIOURL_NS, s);
if (NULL != (s = ACCOUNT()))
oio_url_set (url, OIOURL_ACCOUNT, s);
if (NULL != (s = REF()))
oio_url_set (url, OIOURL_USER, s);
if (NULL != (s = TYPE()))
oio_url_set (url, OIOURL_TYPE, s);
if (NULL != (s = PATH())) {
oio_url_set (url, OIOURL_PATH, s);
if (NULL != (s = VERSION()))
oio_url_set (url, OIOURL_VERSION, s);
}
if (NULL != (s = CID()))
oio_url_set (url, OIOURL_HEXID, s);
if (NULL != (s = CONTENT()))
oio_url_set (url, OIOURL_CONTENTID, s);
return url;
}
void NEAR
displayBanner()
{
#ifdef LEADING_ZEROES
char szRevisionNo[5]; /* For '.nnn\0' */
char szMinorVersion[3]; /* For 'nn\0' */
#endif
if (bannerDisplayed)
return;
bannerDisplayed = TRUE;
#ifdef LEADING_ZEROES
szMinorVersion[0] = '0';
szMinorVersion[1] = '0';
itoa(rmm, szMinorVersion + (rmm < 10 ? 1 : 0), 10);
szRevisionNo[0] = rup ? '.' : '\0'; /* if 0 Revision is not shown */
szRevisionNo[1] = '0';
szRevisionNo[2] = '0';
itoa(rup, szRevisionNo + (rup < 10 ? 3 : (rup < 100 ? 2 : 1)), 10);
makeMessage(COPYRIGHT_MESSAGE_1, rmj, szMinorVersion, szRevisionNo);
#endif
makeMessage(COPYRIGHT_MESSAGE_1, VERSION(rmj, rmm, rup));
makeMessage(COPYRIGHT_MESSAGE_2, CopyRightYrs);
fflush(stderr);
}
/* Get glyph name for glyphId */
Byte8 *postGetName(GlyphId glyphId, IntX *length)
{
switch (post->version)
{
case VERSION(1,0):
return getName1_0(glyphId, length);
case VERSION(2,0):
return getName2_0((Format2_0 *)post->format, glyphId, length);
case VERSION(2,5):
return getName2_5((Format2_5 *)post->format, glyphId, length);
case VERSION(4,0):
return getNam4_0((Format4_0 *)post->format, glyphId, length);
}
*length = 0;
return NULL;
}
static void
deleterdataset(isc_assertioncallback_t callback) {
isc_result_t result;
dns_rdataset_t rdataset;
dns_fixedname_t fixed;
dns_dbnode_t *node = NULL;
result = dns_test_begin(NULL, ISC_FALSE);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
setup_db();
dns_rdataset_init(&rdataset);
dns_fixedname_init(&fixed);
result = dns_db_findnode(db1, dns_rootname, ISC_FALSE, &node);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
isc_assertion_setcallback(callback);
result = dns_db_deleterdataset(db1, node, VERSION(callback),
dns_rdatatype_soa, 0);
if (callback != NULL)
atf_tc_fail("dns_db_deleterdataset did not assert");
ATF_REQUIRE_EQ(result, DNS_R_UNCHANGED);
dns_db_detachnode(db1, &node);
ATF_REQUIRE_EQ(node, NULL);
close_db();
dns_test_end();
}
static void
dump(isc_assertioncallback_t callback) {
isc_result_t result;
FILE *f = NULL;
result = dns_test_begin(NULL, ISC_FALSE);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
setup_db();
result = isc_file_openunique(tempname, &f);
fclose(f);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
isc_assertion_setcallback(callback);
result = dns_db_dump(db1, VERSION(callback), tempname);
(void)unlink(tempname);
if (callback != NULL)
atf_tc_fail("dns_db_dump did not assert");
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
close_db();
dns_test_end();
}
static void
getnsec3parameters(isc_assertioncallback_t callback) {
isc_result_t result;
dns_hash_t hash;
isc_uint8_t flags;
isc_uint16_t iterations;
unsigned char salt[DNS_NSEC3_SALTSIZE];
size_t salt_length = sizeof(salt);
result = dns_test_begin(NULL, ISC_FALSE);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
setup_db();
isc_assertion_setcallback(callback);
result = dns_db_getnsec3parameters(db1, VERSION(callback), &hash,
&flags, &iterations, salt,
&salt_length);
if (callback != NULL)
atf_tc_fail("dns_db_dump did not assert");
ATF_REQUIRE_EQ(result, ISC_R_NOTFOUND);
close_db();
dns_test_end();
}
static int readFile(char * filename)
{
Card32 value;
/* See if we can recognize the file type */
value = fileSniff();
switch (value)
{
case bits_:
case typ1_:
case true_:
case mor0_:
case OTTO_:
case VERSION(1,0):
sfntRead(0, -1); /* Read plain sfnt file */
sfntDump();
sfntFree(1);
break;
case ttcf_:
sfntTTCRead(0); /* Read TTC and dump file */
break;
case 256:
SEEK_ABS(0); /* Raw resource file as a data fork */
resRead(0); /* Read and dump Macintosh resource file */
break;
case sig_AppleSingle:
case sig_AppleDouble:
doASDFormats((ctlTag)value);
break;
default:
warning(SPOT_MSG_BADFILE, filename);
return 1;
}
return 0;
}
static void
find(isc_assertioncallback_t callback) {
isc_result_t result;
dns_rdataset_t rdataset;
dns_fixedname_t fixed;
result = dns_test_begin(NULL, ISC_FALSE);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
setup_db();
dns_rdataset_init(&rdataset);
dns_fixedname_init(&fixed);
isc_assertion_setcallback(callback);
result = dns_db_find(db1, dns_rootname, VERSION(callback),
dns_rdatatype_soa, 0, 0, NULL,
dns_fixedname_name(&fixed), &rdataset, NULL);
if (callback != NULL)
atf_tc_fail("dns_db_find did not assert");
ATF_REQUIRE_EQ(result, DNS_R_NXDOMAIN);
close_db();
dns_test_end();
}
void USAGE()
{
printf("E8::Script ");
VERSION();
printf("\n");
printf(
"USAGE: e8script [PARAMS] filename [script-params]\n"
"Available params:\n"
"\t--profile out profile code\n"
"\t--no-run do not execute file, just compile (and profile)\n"
"\t--dl=<unit> attach unit before script compiling\n"
"\t--ext-path=<path> add path to search units\n"
"\t--input-encoding=<enc> set encoding of input files\n"
"\t--output-encoding=<enc> set encoding of standart output\n"
"Preprocessor params:\n"
"\t--server\n"
"\t--thin-client\n"
"\t--web-client\n"
"\t--thick-client-managed-application\n"
"\t\t--thick-managed\n"
"\t--thick-client-ordinary-application\n"
"\t\t--thick-ordinary\n"
"\t--no-script\n"
"\t--strict-syntax\n"
);
}
int maxpFill(hotCtx g) {
maxpCtx h = g->ctx.maxp;
h->tbl.version = VERSION(0, 5);
h->tbl.numGlyphs = (unsigned short)g->font.glyphs.cnt;
return 1;
}
int main(int argc, char **argv)
{
if (argc == 2 && strcmp(argv[1], "--version") == 0) {
VERSION();
return 0;
}
int r = exec_cli(argc, argv);
return r;
}
void postFree(void)
{
if (!loaded)
return;
switch (post->version)
{
case VERSION(2,0):
free2_0((Format2_0 *)post->format);
break;
case VERSION(2,5):
free2_5((Format2_5 *)post->format);
break;
case VERSION(4,0):
free4_0((Format4_0 *)post->format);
break;
}
memFree(post); post=NULL;
loaded = 0;
}
void postRead(LongN start, Card32 length)
{
if (loaded)
return;
post = (postTbl *)memNew(sizeof(postTbl));
SEEK_ABS(start);
/* Read header */
IN1(post->version);
IN1(post->italicAngle);
IN1(post->underlinePosition);
IN1(post->underlineThickness);
IN1(post->isFixedPitch);
IN1(post->minMemType42);
IN1(post->maxMemType42);
IN1(post->minMemType1);
IN1(post->maxMemType1);
switch (post->version)
{
case VERSION(1,0):
break;
case VERSION(2,0):
post->format = read2_0(length - TBL_HDR_SIZE);
break;
case VERSION(2,5):
post->format = read2_5();
break;
case VERSION(3,0):
break;
case VERSION(4,0):
post->format = read4_0(start);
break;
default:
warning(SPOT_MSG_postBADVERS, VERSION_ARG(post->version));
return;
}
loaded = 1;
}
static int ov9640_video_probe(struct i2c_client *client)
{
struct v4l2_subdev *sd = i2c_get_clientdata(client);
struct ov9640_priv *priv = to_ov9640_sensor(sd);
u8 pid, ver, midh, midl;
const char *devname;
int ret;
ret = ov9640_s_power(&priv->subdev, 1);
if (ret < 0)
return ret;
/*
* check and show product ID and manufacturer ID
*/
ret = ov9640_reg_read(client, OV9640_PID, &pid);
if (!ret)
ret = ov9640_reg_read(client, OV9640_VER, &ver);
if (!ret)
ret = ov9640_reg_read(client, OV9640_MIDH, &midh);
if (!ret)
ret = ov9640_reg_read(client, OV9640_MIDL, &midl);
if (ret)
goto done;
switch (VERSION(pid, ver)) {
case OV9640_V2:
devname = "ov9640";
priv->model = V4L2_IDENT_OV9640;
priv->revision = 2;
break;
case OV9640_V3:
devname = "ov9640";
priv->model = V4L2_IDENT_OV9640;
priv->revision = 3;
break;
default:
dev_err(&client->dev, "Product ID error %x:%x\n", pid, ver);
ret = -ENODEV;
goto done;
}
dev_info(&client->dev, "%s Product ID %0x:%0x Manufacturer ID %x:%x\n",
devname, pid, ver, midh, midl);
ret = v4l2_ctrl_handler_setup(&priv->hdl);
done:
ov9640_s_power(&priv->subdev, 0);
return ret;
}
static __init int bzimage_check(struct setup_header *hdr, unsigned long len)
{
if ( len < sizeof(struct setup_header) )
return 0;
if ( memcmp(&hdr->header, HDR_MAGIC, HDR_MAGIC_SZ) != 0 )
return 0;
if ( hdr->version < VERSION(2,8) ) {
printk("Cannot load bzImage v%d.%02d at least v2.08 is required\n",
hdr->version >> 8, hdr->version & 0xff);
return -EINVAL;
}
int hheaFill(hotCtx g)
{
hheaCtx h = g->ctx.hhea;
h->tbl.version = VERSION(1, 0);
{
if (OVERRIDE(g->font.hheaAscender))
h->tbl.ascender = g->font.hheaAscender;
else
h->tbl.ascender = g->font.TypoAscender;
if (OVERRIDE(g->font.hheaDescender))
h->tbl.descender = g->font.hheaDescender;
else
h->tbl.descender = g->font.TypoDescender;
if (OVERRIDE(g->font.hheaLineGap))
h->tbl.lineGap = g->font.hheaLineGap;
else
h->tbl.lineGap = g->font.TypoLineGap;
}
h->tbl.advanceWidthMax = g->font.maxAdv.h;
h->tbl.minLeftSideBearing = g->font.minBearing.left;
h->tbl.minRightSideBearing = g->font.minBearing.right;
h->tbl.xMaxExtent = g->font.maxExtent.h;
if (g->font.ItalicAngle == 0)
{
h->tbl.caretSlopeRise = 1;
h->tbl.caretSlopeRun = 0;
}
else
{
h->tbl.caretSlopeRise = 1000;
h->tbl.caretSlopeRun =
(short)RND(tan(FIX2DBL(-g->font.ItalicAngle) / RAD_DEG) * 1000);
}
if (h->tbl.caretOffset == SHRT_MAX)
h->tbl.caretOffset = (g->font.ItalicAngle == 0)? 0: calcCaretOffset(g);
h->tbl.reserved[0] = 0;
h->tbl.reserved[1] = 0;
h->tbl.reserved[2] = 0;
h->tbl.reserved[3] = 0;
h->tbl.metricDataFormat = 0;
h->tbl.numberOfLongHorMetrics = hmtxGetNLongHorMetrics(g);
return 1;
}
/* Initialize name fetching */
IntX postInitName(void)
{
if (!loaded)
{
if (sfntReadTable(post_))
return 0;
}
switch (post->version)
{
case VERSION(1,0):
case VERSION(2,0):
case VERSION(2,5):
case VERSION(4,0):
return 1;
case VERSION(3,0):
break;
default:
warning(SPOT_MSG_postBADVERS, VERSION_ARG(post->version));
break;
}
return 0;
}
/**
*******************************************************************************
*
* @brief
* Fills the version info in the given string
*
* @par Description:
*
*
* @param[in] pc_version_string
* Pointer to hold version info
*
* @param[in] u4_version_buffer_size
* Size of the buffer passed
*
* @returns Status
*
* @remarks
*
*
*******************************************************************************
*/
IV_API_CALL_STATUS_T ihevcd_get_version(CHAR *pc_version_string,
UWORD32 u4_version_buffer_size)
{
CHAR ac_version_tmp[512];
VERSION(ac_version_tmp, CODEC_NAME, CODEC_RELEASE_TYPE, CODEC_RELEASE_VER, CODEC_VENDOR);
if(u4_version_buffer_size >= (strlen(ac_version_tmp) + 1))
{
memcpy(pc_version_string, ac_version_tmp, (strlen(ac_version_tmp) + 1));
return IV_SUCCESS;
}
else
{
return IV_FAIL;
}
}
/**
*******************************************************************************
*
* @brief
* Fills the version info in the given char pointer
*
* @par Description:
* Fills the version info in the given char pointer
*
* @param[in] pc_version
* Pointer to hold version info
*
* @param[in] u4_version_bufsize
* Size of the buffer passed
*
* @returns error status
*
* @remarks none
*
*******************************************************************************
*/
IV_STATUS_T ih264e_get_version(CHAR *pc_version, UWORD32 u4_version_bufsize)
{
CHAR ac_version_tmp[MAX_STRLEN];
VERSION(ac_version_tmp, CODEC_NAME, CODEC_RELEASE_TYPE, CODEC_RELEASE_VER,
CODEC_VENDOR);
if (u4_version_bufsize >= (strlen(ac_version_tmp) + 1))
{
memcpy(pc_version, ac_version_tmp, (strlen(ac_version_tmp) + 1));
return IV_SUCCESS;
}
else
{
return IV_FAIL;
}
}
int postFill(hotCtx g)
{
postCtx h = g->ctx.post;
h->tbl.version = VERSION(3, 0);
h->tbl.italicAngle = g->font.ItalicAngle;
h->tbl.underlinePosition = g->font.UnderlinePosition +
g->font.UnderlineThickness / 2;
h->tbl.underlineThickness = g->font.UnderlineThickness;
h->tbl.isFixedPitch = (g->font.flags & FI_FIXED_PITCH) != 0;
h->tbl.minMemType42 = 0;
h->tbl.maxMemType42 = 0;
h->tbl.minMemType1 = 0;
h->tbl.maxMemType1 = 0;
return 1;
}
Common::String ResourceManager::getNumberedString(int value) {
if (_sliceBusy) {
fatal("Can't read from data file", "I'm already reading something");
return NULL;
}
_bigDataFile->seek((value << 2) + _startOfTextIndex, 0);
value = _bigDataFile->readUint32LE();
_bigDataFile->seek(value, 0);
Common::String s = readString(_bigDataFile);
if (gameVersion < VERSION(2, 2)) {
// This is an older game - We need to convert the string to UTF-8
s = convertString(s);
}
return s;
}
int MMFXFill(hotCtx g) {
MMFXCtx h = g->ctx.MMFX;
int i;
Offset offset;
if (!IS_MM(g)) {
return 0;
}
/* Fill header */
h->tbl.version = VERSION(1, 0);
h->tbl.nMetrics = (unsigned short)h->metrics.cnt;
h->tbl.offSize =
(HEADER_SIZE + uint16 * h->metrics.cnt +
h->metrics.array[h->metrics.cnt - 1].index > 65535) ? 4 : 2;
/* Sort metrics by id */
qsort(h->metrics.array, h->metrics.cnt, sizeof(Metric), cmpIds);
/* Check if all named metrics present */
for (i = 0; i < h->metrics.cnt; i++) {
if (h->metrics.array[i].id >= MMFXNamedMetricCnt) {
break;
}
}
if (i < MMFXNamedMetricCnt) {
hotMsg(g, hotFATAL, "Missing named metrics");
}
else if (i > MMFXNamedMetricCnt) {
hotMsg(g, hotFATAL, "Duplicate named metrics");
}
/* Allocate and fill offset array */
offset = (unsigned short)(HEADER_SIZE + h->tbl.offSize * h->metrics.cnt);
h->tbl.offset = MEM_NEW(g, sizeof(long) * h->metrics.cnt);
for (i = 0; i < h->metrics.cnt; i++) {
h->tbl.offset[i] = offset + h->metrics.array[i].index;
}
return 1;
}
static void
addrdataset(isc_assertioncallback_t callback) {
isc_result_t result;
dns_rdataset_t rdataset;
dns_fixedname_t fixed;
dns_dbnode_t *node = NULL;
dns_rdatalist_t rdatalist;
result = dns_test_begin(NULL, ISC_FALSE);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
setup_db();
dns_rdataset_init(&rdataset);
dns_rdatalist_init(&rdatalist);
dns_fixedname_init(&fixed);
rdatalist.rdclass = dns_rdataclass_in;
result = dns_rdatalist_tordataset(&rdatalist, &rdataset);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
result = dns_db_findnode(db1, dns_rootname, ISC_FALSE, &node);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
isc_assertion_setcallback(callback);
result = dns_db_addrdataset(db1, node, VERSION(callback), 0, &rdataset,
0, NULL);
if (callback != NULL)
atf_tc_fail("dns_db_adddataset did not assert");
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
dns_db_detachnode(db1, &node);
ATF_REQUIRE_EQ(node, NULL);
close_db();
dns_test_end();
}
/*
* Individual unit tests
*/
static void
attachversion(isc_assertioncallback_t callback) {
isc_result_t result;
dns_dbversion_t *v = NULL;
result = dns_test_begin(NULL, ISC_FALSE);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
setup_db();
isc_assertion_setcallback(callback);
dns_db_attachversion(db1, VERSION(callback), &v);
if (callback != NULL)
atf_tc_fail("dns_db_attachversion did not assert");
ATF_REQUIRE_EQ(v, v1);
dns_db_closeversion(db1, &v, ISC_FALSE);
ATF_REQUIRE_EQ(v, NULL);
close_db();
dns_test_end();
}
bool loadAnim (personaAnimation * p, FILE * fp) {
p -> numFrames = get2bytes (fp);
if (p -> numFrames) {
int a = get4bytes (fp);
p -> frames = new animFrame[p -> numFrames];
if (! checkNew (p -> frames)) return false;
p -> theSprites = loadBankForAnim (a);
for (a = 0; a < p -> numFrames; a ++) {
p -> frames[a].frameNum = get4bytes (fp);
p -> frames[a].howMany = get4bytes (fp);
if (ssgVersion >= VERSION(2,0)) {
p -> frames[a].noise = get4bytes (fp);
} else {
p -> frames[a].noise = 0;
}
}
} else {
p -> theSprites = NULL;
p -> frames = NULL;
}
return true;
}
VERSION getAppVersion() {
return(VERSION((int)VERSION_MAJOR, (int)VERSION_MINOR, (int)VERSION_PATCH));
}
