mlib_status
__mlib_VideoDCT16x16_S16_S16(
mlib_s16 *coeffs,
const mlib_s16 *block)
{
__m128i txmm0, txmm1, txmm2, txmm3, txmm4, txmm5, txmm6, txmm7;
__m128i tmp00, tmp10, tmp20, tmp30, tmp40, tmp50, tmp60, tmp70;
__m128i tmp01, tmp11, tmp21, tmp31, tmp41, tmp51, tmp61, tmp71;
__m128i tmp02, tmp12, tmp22, tmp32, tmp42, tmp52, tmp62, tmp72;
__m128i tmp03, tmp13, tmp23, tmp33, tmp43, tmp53, tmp63, tmp73;
__m128i xmmc0, xmmc1, xmmc2, xmmc3, xmmc4, xmmc5, xmmc6, xmmc7;
__m128i t0, t1, t2, t3, t4, t5, t6, t7;
mlib_s16 *pSrc = (void *)block;
/* be care: all const multiplied by 1<<16 and subed by 32768 */
__m128i COS_4 = _mm_set1_epi16(0x3504);
__m128i SIN_8 = _mm_set1_epi16(-0x1E09);
__m128i COS_8 = _mm_set1_epi16(0x6C82);
__m128i SIN_16 = _mm_set1_epi16(-0x4E0F);
__m128i COS_16 = _mm_set1_epi16(0x7B13);
__m128i COS_3_16 = _mm_set1_epi16(0x54DA);
__m128i SIN_3_16 = _mm_set1_epi16(0xE39);
__m128i SIN_32 = _mm_set1_epi16(-0x66E8);
__m128i COS_32 = _mm_set1_epi16(0x7EC3);
__m128i COS_3_32 = _mm_set1_epi16(0x74F9);
__m128i SIN_3_32 = _mm_set1_epi16(-0x35B0);
__m128i COS_5_32 = _mm_set1_epi16(0x61C5);
__m128i SIN_5_32 = _mm_set1_epi16(-0x753);
__m128i COS_7_32 = _mm_set1_epi16(0x45E3);
__m128i SIN_7_32 = _mm_set1_epi16(0x2267);
__m128i *dataptr = (__m128i *)coeffs;
LOAD_DATA(0, 0, 2);
ROW_DCT16x16(0, 2);
LOAD_DATA(8, 1, 3);
ROW_DCT16x16(1, 3);
SSE2_TRANSPOSE8x8(0);
SSE2_TRANSPOSE8x8(1);
SSE2_TRANSPOSE8x8(2);
SSE2_TRANSPOSE8x8(3);
ROW_DCT16x16(0, 1);
ROW_DCT16x16(2, 3);
SSE2_TRANSPOSE8x8(0);
SSE2_TRANSPOSE8x8(1);
SSE2_TRANSPOSE8x8(2);
SSE2_TRANSPOSE8x8(3);
STORE_ALL(0, 1);
STORE_ALL(2, 3);
return (MLIB_SUCCESS);
}
/*++
Read global game data from data files.
--*/
static VOID PAL_ReadGlobalGameData(void)
{
const GAMEDATA *p = &gpGlobals->g;
unsigned int i;
LOAD_DATA(p->lprgScriptEntry, p->nScriptEntry * sizeof(SCRIPTENTRY),
4, gpGlobals->f.fpSSS);
LOAD_DATA(p->lprgStore, p->nStore * sizeof(STORE), 0, gpGlobals->f.fpDATA);
LOAD_DATA(p->lprgEnemy, p->nEnemy * sizeof(ENEMY), 1, gpGlobals->f.fpDATA);
LOAD_DATA(p->lprgEnemyTeam, p->nEnemyTeam * sizeof(ENEMYTEAM),
2, gpGlobals->f.fpDATA);
LOAD_DATA(p->lprgMagic, p->nMagic * sizeof(MAGIC), 4, gpGlobals->f.fpDATA);
LOAD_DATA(p->lprgBattleField, p->nBattleField * sizeof(BATTLEFIELD),
5, gpGlobals->f.fpDATA);
LOAD_DATA(p->lprgLevelUpMagic, p->nLevelUpMagic * sizeof(LEVELUPMAGIC_ALL),
6, gpGlobals->f.fpDATA);
LOAD_DATA(p->rgwBattleEffectIndex, sizeof(p->rgwBattleEffectIndex),
11, gpGlobals->f.fpDATA);
PAL_MKFReadChunk((LPBYTE)&(p->EnemyPos), sizeof(p->EnemyPos),
13, gpGlobals->f.fpDATA);
DO_BYTESWAP(&(p->EnemyPos), sizeof(p->EnemyPos));
PAL_MKFReadChunk((LPBYTE)(p->rgLevelUpExp), sizeof(p->rgLevelUpExp),
14, gpGlobals->f.fpDATA);
DO_BYTESWAP(p->rgLevelUpExp, sizeof(p->rgLevelUpExp));
}
/*++
Load the default game data.
--*/
static VOID PAL_LoadDefaultGame(void)
{
const GAMEDATA *p = &gpGlobals->g;
UINT32 i;
//
// Load the default data from the game data files.
//
LOAD_DATA(p->lprgEventObject, p->nEventObject * sizeof(EVENTOBJECT),
0, gpGlobals->f.fpSSS);
PAL_MKFReadChunk((LPBYTE)(p->rgScene), sizeof(p->rgScene), 1, gpGlobals->f.fpSSS);
DO_BYTESWAP(p->rgScene, sizeof(p->rgScene));
PAL_MKFReadChunk((LPBYTE)(p->rgObject), sizeof(p->rgObject), 2, gpGlobals->f.fpSSS);
DO_BYTESWAP(p->rgObject, sizeof(p->rgObject));
PAL_MKFReadChunk((LPBYTE)(&(p->PlayerRoles)), sizeof(PLAYERROLES),
3, gpGlobals->f.fpDATA);
DO_BYTESWAP(&(p->PlayerRoles), sizeof(PLAYERROLES));
//
// Set some other default data.
//
gpGlobals->dwCash = 0;
gpGlobals->wNumMusic = 0;
gpGlobals->wNumPalette = 0;
gpGlobals->wNumScene = 1;
gpGlobals->wCollectValue = 0;
gpGlobals->fNightPalette = FALSE;
gpGlobals->wMaxPartyMemberIndex = 0;
gpGlobals->viewport = PAL_XY(0, 0);
gpGlobals->wLayer = 0;
gpGlobals->wChaseRange = 1;
#ifndef PAL_CLASSIC
gpGlobals->bBattleSpeed = 2;
#endif
memset(gpGlobals->rgInventory, 0, sizeof(gpGlobals->rgInventory));
memset(gpGlobals->rgPoisonStatus, 0, sizeof(gpGlobals->rgPoisonStatus));
memset(gpGlobals->rgParty, 0, sizeof(gpGlobals->rgParty));
memset(gpGlobals->rgTrail, 0, sizeof(gpGlobals->rgTrail));
memset(&(gpGlobals->Exp), 0, sizeof(gpGlobals->Exp));
for (i = 0; i < MAX_PLAYER_ROLES; i++)
{
gpGlobals->Exp.rgPrimaryExp[i].wLevel = p->PlayerRoles.rgwLevel[i];
gpGlobals->Exp.rgHealthExp[i].wLevel = p->PlayerRoles.rgwLevel[i];
gpGlobals->Exp.rgMagicExp[i].wLevel = p->PlayerRoles.rgwLevel[i];
gpGlobals->Exp.rgAttackExp[i].wLevel = p->PlayerRoles.rgwLevel[i];
gpGlobals->Exp.rgMagicPowerExp[i].wLevel = p->PlayerRoles.rgwLevel[i];
gpGlobals->Exp.rgDefenseExp[i].wLevel = p->PlayerRoles.rgwLevel[i];
gpGlobals->Exp.rgDexterityExp[i].wLevel = p->PlayerRoles.rgwLevel[i];
gpGlobals->Exp.rgFleeExp[i].wLevel = p->PlayerRoles.rgwLevel[i];
}
gpGlobals->fEnteringScene = TRUE;
}
int AvHParticleTemplateListClient::InitializeDemoPlayback(int inSize, unsigned char* inBuffer, int index)
{
// Read one particle template and add it to the list
int theBytesRead = 0;
AvHParticleTemplate theTemplate;
// Read all fields
string theTemplateName;
LoadStringData(theTemplateName, inBuffer, theBytesRead);
theTemplate.SetName(theTemplateName);
uint32 theMaxParticles;
LOAD_DATA(theMaxParticles);
theTemplate.SetMaxParticles(theMaxParticles);
float theParticleSize;
LOAD_DATA(theParticleSize);
theTemplate.SetParticleSize(theParticleSize);
float theParticleSystemLifetime;
LOAD_DATA(theParticleSystemLifetime);
theTemplate.SetParticleSystemLifetime(theParticleSystemLifetime);
float theParticleLifetime;
LOAD_DATA(theParticleLifetime);
theTemplate.SetParticleLifetime(theParticleLifetime);
string theSpriteName;
LoadStringData(theSpriteName, inBuffer, theBytesRead);
theTemplate.SetSprite(theSpriteName);
ShapeType theGenerationShape;
LOAD_DATA(theGenerationShape);
theTemplate.SetGenerationShape(theGenerationShape);
string theGenerationEntityName;
LoadStringData(theGenerationEntityName, inBuffer, theBytesRead);
theTemplate.SetGenerationEntityName(theGenerationEntityName);
string theParticleSystemToGenerate;
LoadStringData(theParticleSystemToGenerate, inBuffer, theBytesRead);
theTemplate.SetParticleSystemToGenerate(theParticleSystemToGenerate);
int theParticleSystemIndexToGenerate;
LOAD_DATA(theParticleSystemIndexToGenerate);
theTemplate.SetParticleSystemIndexToGenerate(theParticleSystemIndexToGenerate);
int theGenerationEntityIndex;
LOAD_DATA(theGenerationEntityIndex);
theTemplate.SetGenerationEntityIndex(theGenerationEntityIndex);
float theGenerationEntityParameter;
LOAD_DATA(theGenerationEntityParameter);
theTemplate.SetGenerationEntityParameter(theGenerationEntityParameter);
ShapeType theStartingVelocityShape;
LOAD_DATA(theStartingVelocityShape);
theTemplate.SetStartingVelocityShape(theStartingVelocityShape);
ParticleParams theGenerationParams;
LOAD_DATA(theGenerationParams);
theTemplate.SetGenerationParams(theGenerationParams);
ParticleParams theStartingVelocityParams;
LOAD_DATA(theStartingVelocityParams);
theTemplate.SetStartingVelocityParams(theStartingVelocityParams);
uint32 theGenerationRate;
LOAD_DATA(theGenerationRate);
theTemplate.SetGenerationRate(theGenerationRate);
int theParticleFlags;
LOAD_DATA(theParticleFlags);
theTemplate.SetFlags(theParticleFlags);
PSVector theGravity;
LOAD_DATA(theGravity);
theTemplate.SetGravity(theGravity);
float theAnimationSpeed;
LOAD_DATA(theAnimationSpeed);
theTemplate.SetAnimationSpeed(theAnimationSpeed);
int theNumSpriteFrames;
LOAD_DATA(theNumSpriteFrames);
theTemplate.SetNumSpriteFrames(theNumSpriteFrames);
float theParticleScaling;
LOAD_DATA(theParticleScaling);
theTemplate.SetParticleScaling(theParticleScaling);
int theRenderMode;
LOAD_DATA(theRenderMode);
theTemplate.SetRenderMode(theRenderMode);
float theMaxAlpha;
LOAD_DATA(theMaxAlpha);
theTemplate.SetMaxAlpha(theMaxAlpha);
// Save the template
this->mTemplateList[index]=theTemplate;
return theBytesRead;
}
metadata(std::ifstream& global_metdata)
{
global_metdata.read(reinterpret_cast<char *>(&header), sizeof(Il2CppGlobalMetadataHeader));
if (header.sanity != 0xfab11baf)
{
throw std::exception("File does not have valid header");
}
if (header.version != 21)
{
throw std::exception("Metadata is described by unsupported version");
}
// Read the file binary into corresponding arrays of structs
#define LOAD_DATA(type_name, container_name) \
do { \
container_name = new type_name[header.container_name##Count / sizeof(type_name)]; \
global_metdata.seekg(header.container_name##Offset, std::ios::beg); \
global_metdata.read(reinterpret_cast<char *>(container_name), header.container_name##Count); \
} while (0)
LOAD_DATA(char, stringLiteral);
LOAD_DATA(char, stringLiteralData);
LOAD_DATA(char, string);
LOAD_DATA(Il2CppEventDefinition, events);
LOAD_DATA(Il2CppPropertyDefinition, properties);
LOAD_DATA(Il2CppMethodDefinition, methods);
LOAD_DATA(Il2CppParameterDefaultValue, parameterDefaultValues);
LOAD_DATA(Il2CppFieldDefaultValue, fieldDefaultValues);
LOAD_DATA(uint8_t, fieldAndParameterDefaultValueData);
LOAD_DATA(Il2CppFieldMarshaledSize, fieldMarshaledSizes);
LOAD_DATA(Il2CppParameterDefinition, parameters);
LOAD_DATA(Il2CppFieldDefinition, fields);
LOAD_DATA(Il2CppGenericParameter, genericParameters);
LOAD_DATA(TypeIndex, genericParameterConstraints);
LOAD_DATA(Il2CppGenericContainer, genericContainers);
LOAD_DATA(TypeDefinitionIndex, nestedTypes);
LOAD_DATA(TypeIndex, interfaces);
LOAD_DATA(EncodedMethodIndex, vtableMethods);
LOAD_DATA(Il2CppInterfaceOffsetPair, interfaceOffsets);
LOAD_DATA(Il2CppTypeDefinition, typeDefinitions);
LOAD_DATA(Il2CppRGCTXDefinition, rgctxEntries);
LOAD_DATA(Il2CppImageDefinition, images);
LOAD_DATA(Il2CppAssemblyDefinition, assemblies);
LOAD_DATA(Il2CppMetadataUsageList, metadataUsageLists);
LOAD_DATA(Il2CppMetadataUsagePair, metadataUsagePairs);
LOAD_DATA(Il2CppFieldRef, fieldRefs);
LOAD_DATA(int32_t, referencedAssemblies);
LOAD_DATA(Il2CppCustomAttributeTypeRange, attributesInfo);
LOAD_DATA(TypeIndex, attributeTypes);
#undef LOAD_DATA
}
mlib_status
__mlib_SignalMulSShiftAdd_S16S_S16S_Sat(
mlib_s16 *dst,
const mlib_s16 *src1,
const mlib_s16 *src2,
const mlib_s16 *c,
mlib_s32 shift,
mlib_s32 n)
{
__m128i *dpx, *dpy, *dpz;
__m128i dx, dy, dz, dc;
__m128i dupper, dlower;
__m128i dupper_lower, dupper_upper;
__m128i dlower_upper, dlower_lower;
__m128i dsign;
mlib_s32 ncurrent, nlen;
mlib_s32 i;
mlib_s32 sh1 = 0;
dpx = (__m128i *) src1;
dpy = (__m128i *) src2;
dpz = (__m128i *) dst;
nlen = n >> 2;
dc = _mm_set_epi16(c[1], c[0], c[1], c[0],
c[1], c[0], c[1], c[0]);
if (shift <= -1) {
if (shift < -16) {
shift = -16;
}
sh1 = -shift + 15;
#ifdef __SUNPRO_C
#pragma pipeloop(0)
#endif
for (i = 0; i < nlen; i++) {
LOAD_DATA(src1, dpx, dx);
LOAD_DATA(src2, dpy, dy);
MUL_2S16_2S32;
dlower = _mm_srai_epi32(dlower, sh1);
dupper = _mm_srai_epi32(dupper, sh1);
dz = _mm_packs_epi32(dlower, dupper);
dz = _mm_adds_epi16(dz, dx);
STORE_Z;
dpx++;
dpy++;
dpz++;
}
} else {
if (shift > 31) {
shift = 31;
}
sh1 = shift + 1;
__m128i mask0;
__m128i df_zero = _mm_set_epi32(0xffffffff,
0xffffffff, 0, 0);
__m128i dzero_f = _mm_set_epi32(0, 0,
0xffffffff, 0xffffffff);
__m128i dupper_max = _mm_set_epi32(0,
MLIB_S32_MAX, 0, 0);
__m128i dupper_min = _mm_set_epi32(
0xffffffff, MLIB_S32_MIN, 0, 0);
__m128i dlower_min = _mm_set_epi32(0, 0,
0xffffffff, MLIB_S32_MIN);
__m128i dlower_max = _mm_set_epi32(0, 0,
0, MLIB_S32_MAX);
__m128i dx1, dx2, dx3, dx4;
mlib_s32 imm1, imm2;
#ifdef __SUNPRO_C
#pragma pipeloop(0)
#endif
for (i = 0; i < nlen; i++) {
LOAD_DATA(src1, dpx, dx);
LOAD_DATA(src2, dpy, dy);
MUL_2S16_2S32;
dsign = _mm_srai_epi32(dlower, 31);
dlower_lower = _mm_unpacklo_epi32(dlower, dsign);
dlower_upper = _mm_unpackhi_epi32(dlower, dsign);
dsign = _mm_srai_epi32(dupper, 31);
dupper_lower = _mm_unpacklo_epi32(dupper, dsign);
dupper_upper = _mm_unpackhi_epi32(dupper, dsign);
dlower_lower = _mm_slli_epi64(dlower_lower, sh1);
dlower_upper = _mm_slli_epi64(dlower_upper, sh1);
dupper_lower = _mm_slli_epi64(dupper_lower, sh1);
dupper_upper = _mm_slli_epi64(dupper_upper, sh1);
/* divide 8-16-bits dx into 4 64-2-bits dx1, dx2, dx3, dx4 */
DIVIDE_DX;
dlower_lower = _mm_add_epi64(dlower_lower, dx1);
dlower_upper = _mm_add_epi64(dlower_upper, dx2);
dupper_lower = _mm_add_epi64(dupper_lower, dx3);
dupper_upper = _mm_add_epi64(dupper_upper, dx4);
/* Saturation */
SAT_S32_UPPER(dlower_lower);
SAT_S32_LOWER(dlower_lower);
SAT_S32_UPPER(dlower_upper);
SAT_S32_LOWER(dlower_upper);
SAT_S32_UPPER(dupper_lower);
SAT_S32_LOWER(dupper_lower);
SAT_S32_UPPER(dupper_upper);
SAT_S32_LOWER(dupper_upper);
/* merge all data */
dlower_lower = _mm_srai_epi32(dlower_lower, 16);
dlower_upper = _mm_srai_epi32(dlower_upper, 16);
dupper_lower = _mm_srai_epi32(dupper_lower, 16);
dupper_upper = _mm_srai_epi32(dupper_upper, 16);
dlower_lower = _mm_packs_epi32(dlower_lower,
dlower_upper);
dupper_upper = _mm_packs_epi32(dupper_lower,
dupper_upper);
dz = _mm_packs_epi32(dlower_lower, dupper_upper);
STORE_Z;
dpx++;
dpy++;
dpz++;
}
}
if ((nlen << 2) != n) {
ncurrent = nlen << 2;
mlib_d64 d_val;
if (shift >= 0) {
d_val = 2. * ((mlib_u32)1 << (shift));
} else {
d_val = 2. / ((mlib_u32)1 << (-shift));
}
#ifdef __SUNPRO_C
#pragma pipeloop(0)
#endif
for (i = ncurrent; i < n; i++) {
FLOAT2INT_CLAMP(dst[2 * i], ((mlib_s32) src1[2 * i]
<< 16) + d_val * src2[2 * i] * c[0]);
FLOAT2INT_CLAMP(dst[2 * i + 1],
((mlib_s32) src1[2 * i + 1] << 16)
+ d_val * src2[2 * i + 1] * c[1]);
}
}
return ((n > 0) ? MLIB_SUCCESS : MLIB_FAILURE);
}
