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); }