void swap_JournalInfoBlock(JournalInfoBlock* record)
{
// trace("record (%p)", record);
/*
struct JournalInfoBlock {
uint32_t flags;
uint32_t device_signature[8]; // signature used to locate our device.
uint64_t offset; // byte offset to the journal on the device
uint64_t size; // size in bytes of the journal
uuid_string_t ext_jnl_uuid;
char machine_serial_num[48];
char reserved[JIB_RESERVED_SIZE];
} __attribute__((aligned(2), packed));
typedef struct JournalInfoBlock JournalInfoBlock;
*/
Swap32(record->flags);
for(unsigned i = 0; i < 8; i++)
Swap32(record->device_signature[i]);
Swap64(record->offset);
Swap64(record->size);
// noswap: uuid_string_t is a series of char
// noswap: machine_serial_num is a series of char
// noswap: reserved is reserved
}
void swap_HFSPlusExtentKey(HFSPlusExtentKey* record)
{
// trace("record (%p)", record);
// noswap: keyLength; swapped in swap_BTNode
Swap32(record->fileID);
Swap32(record->startBlock);
}
static lua_Number LoadNumber(LoadState* S)
{
lua_Number x;
LoadVar(S,x);
if (!S->flip)
return x;
#ifdef LUA_NUMBER_DOUBLE
{
union { double d; uint32_t i[2]; } u;
uint32_t temp;
u.d = x;
temp = Swap32(u.i[0]);
u.i[0] = Swap32(u.i[1]);
u.i[1] = temp;
return u.d;
}
#else
{
union { float f; uint32_t i } u;
u.f = x;
u.i = Swap32(u.i);
return u.f;
}
#endif
}
void swap_HFSPlusForkData(HFSPlusForkData* record)
{
// trace("record (%p)", record);
Swap64(record->logicalSize);
Swap32(record->totalBlocks);
Swap32(record->clumpSize);
swap_HFSPlusExtentRecord(record->extents);
}
/**
*
* Perform a destructive 32-bit wide register IO test. Each location is tested
* by sequentially writing a 32-bit wide regsiter, reading the register, and
* comparing value. This function tests three kinds of register IO functions,
* normal register IO, little-endian register IO, and big-endian register IO.
* When testing little/big-endian IO, the function perform the following
* sequence, Xil_Out32LE/Xil_Out32BE, Xil_In32, Compare,
* Xil_Out32, Xil_In32LE/Xil_In32BE, Compare. Whether to swap the read-in value
* before comparing is controlled by the 5th argument.
*
* @param Addr is a pointer to the region of memory to be tested.
* @param Length is the Length of the block.
* @param Value is the constant used for writting the memory.
* @param Kind is the test kind. Acceptable values are:
* XIL_TESTIO_DEFAULT, XIL_TESTIO_LE, XIL_TESTIO_BE.
* @param Swap indicates whether to byte swap the read-in value.
*
* @return
*
* - -1 is returned for a failure
* - 0 is returned for a pass
*
*****************************************************************************/
s32 Xil_TestIO32(u32 *Addr, s32 Length, u32 Value, s32 Kind, s32 Swap)
{
u32 *TempAddr;
u32 ValueIn = 0U;
s32 Index;
TempAddr = Addr;
Xil_AssertNonvoid(TempAddr != NULL);
for (Index = 0; Index < Length; Index++) {
switch (Kind) {
case XIL_TESTIO_LE:
Xil_Out32LE((INTPTR)TempAddr, Value);
break;
case XIL_TESTIO_BE:
Xil_Out32BE((INTPTR)TempAddr, Value);
break;
default:
Xil_Out32((INTPTR)TempAddr, Value);
break;
}
ValueIn = Xil_In32((INTPTR)TempAddr);
if ((Kind != 0) && (Swap != 0)) {
ValueIn = Swap32(ValueIn);
}
if (Value != ValueIn) {
return -1;
}
/* second round */
Xil_Out32((INTPTR)TempAddr, Value);
switch (Kind) {
case XIL_TESTIO_LE:
ValueIn = Xil_In32LE((INTPTR)TempAddr);
break;
case XIL_TESTIO_BE:
ValueIn = Xil_In32BE((INTPTR)TempAddr);
break;
default:
ValueIn = Xil_In32((INTPTR)TempAddr);
break;
}
if ((Kind != 0) && (Swap != 0)) {
ValueIn = Swap32(ValueIn);
}
if (Value != ValueIn) {
return -1;
}
TempAddr += sizeof(u32);
}
return 0;
}
void swap_HFSPlusCatalogThread(HFSPlusCatalogThread* record)
{
// trace("record (%p)", record);
// Swap16(record->recordType);
Swap32(record->reserved);
Swap32(record->parentID);
swap_HFSUniStr255(&record->nodeName);
}
void swap_HFSPlusAttrKey(HFSPlusAttrKey* record)
{
// trace("record (%p)", record);
// noswap: keyLength; swapped in swap_BTNode
Swap16(record->pad);
Swap32(record->fileID);
Swap32(record->startBlock);
Swap16(record->attrNameLen);
for(unsigned i = 0; i < record->attrNameLen; i++) Swap16(record->attrName[i]);
}
void swap_FndrFileInfo(FndrFileInfo* record)
{
// trace("record (%p)", record);
Swap32(record->fdType);
Swap32(record->fdCreator);
Swap16(record->fdFlags);
Swap16(record->fdLocation.v);
Swap16(record->fdLocation.h);
Swap16(record->opaque);
}
void swap_HFSPlusBSDInfo(HFSPlusBSDInfo* record)
{
// trace("record (%p)", record);
Swap32(record->ownerID);
Swap32(record->groupID);
// noswap: adminFlags is a byte
// noswap: ownerFlags is a byte
Swap16(record->fileMode);
Swap32(record->special.iNodeNum);
}
/**
*
* Perform a destructive 32-bit wide register IO test. Each location is tested
* by sequentially writing a 32-bit wide regsiter, reading the register, and
* comparing value. This function tests three kinds of register IO functions,
* normal register IO, little-endian register IO, and big-endian register IO.
* When testing little/big-endian IO, the function perform the following
* sequence, Xil_Out32LE/Xil_Out32BE, Xil_In32, Compare,
* Xil_Out32, Xil_In32LE/Xil_In32BE, Compare. Whether to swap the read-in value
* before comparing is controlled by the 5th argument.
*
* @param Addr is a pointer to the region of memory to be tested.
* @param Len is the length of the block.
* @param Value is the constant used for writting the memory.
* @param Kind is the test kind. Acceptable values are:
* XIL_TESTIO_DEFAULT, XIL_TESTIO_LE, XIL_TESTIO_BE.
* @param Swap indicates whether to byte swap the read-in value.
*
* @return
*
* - -1 is returned for a failure
* - 0 is returned for a pass
*
*****************************************************************************/
int Xil_TestIO32(u32 *Addr, int Len, u32 Value, int Kind, int Swap)
{
u32 ValueIn;
int Index;
for (Index = 0; Index < Len; Index++) {
switch (Kind) {
case XIL_TESTIO_LE:
Xil_Out32LE((u32)Addr, Value);
break;
case XIL_TESTIO_BE:
Xil_Out32BE((u32)Addr, Value);
break;
default:
Xil_Out32((u32)Addr, Value);
break;
}
ValueIn = Xil_In32((u32)Addr);
if (Kind && Swap)
ValueIn = Swap32(ValueIn);
if (Value != ValueIn) {
return -1;
}
/* second round */
Xil_Out32((u32)Addr, Value);
switch (Kind) {
case XIL_TESTIO_LE:
ValueIn = Xil_In32LE((u32)Addr);
break;
case XIL_TESTIO_BE:
ValueIn = Xil_In32BE((u32)Addr);
break;
default:
ValueIn = Xil_In32((u32)Addr);
break;
}
if (Kind && Swap)
ValueIn = Swap32(ValueIn);
if (Value != ValueIn) {
return -1;
}
Addr++;
}
return 0;
}
uint64_t Swap64(uint64_t x)
{
uint32_t hi, lo;
/* Separate into high and low 32-bit values and swap them */
lo = (uint32_t)(x & 0xFFFFFFFF);
x >>= 32;
hi = (uint32_t)(x & 0xFFFFFFFF);
x = Swap32(lo);
x <<= 32;
x |= Swap32(hi);
return(x);
}
/**
* Writes a 32-bit value to the stream.
*/
void IDataStream::Write32(UInt32 inData)
{
if(swapBytes)
inData = Swap32(inData);
WriteBuf(&inData, sizeof(UInt32));
}
static void FixLilEndian()
{
#if defined(ENDIAN_LITTLE)
static bool Initialized = false;
if( Initialized )
return;
Initialized = true;
for( int i = 0; i < AVPixelFormats[i].bpp; ++i )
{
AVPixelFormat_t &pf = AVPixelFormats[i];
if( !pf.bByteSwapOnLittleEndian )
continue;
for( int mask = 0; mask < 4; ++mask)
{
int m = pf.masks[mask];
switch( pf.bpp )
{
case 24: m = Swap24(m); break;
case 32: m = Swap32(m); break;
default:
FAIL_M(ssprintf("Unsupported BPP value: %i", pf.bpp));
}
pf.masks[mask] = m;
}
}
#endif
}
static void LoadDebug(LoadState* S, Proto* f)
{
int i,n;
n=LoadInt(S);
f->lineinfo=luaM_newvector(S->L,n,uint32_t);
f->sizelineinfo=n;
LoadVector(S,f->lineinfo,n,sizeof(uint32_t));
if (S->flip)
for (i=0; i<n; i++)
f->lineinfo[i] = Swap32(f->lineinfo[i]);
n=LoadInt(S);
f->locvars=luaM_newvector(S->L,n,LocVar);
f->sizelocvars=n;
for (i=0; i<n; i++) f->locvars[i].varname=NULL;
for (i=0; i<n; i++)
{
f->locvars[i].varname=LoadString(S);
f->locvars[i].startpc=LoadInt(S);
f->locvars[i].endpc=LoadInt(S);
}
n=LoadInt(S);
f->upvalues=luaM_newvector(S->L,n,TString*);
f->sizeupvalues=n;
for (i=0; i<n; i++) f->upvalues[i]=NULL;
for (i=0; i<n; i++) f->upvalues[i]=LoadString(S);
}
/*************************** ScriptMgefHandler ********************************/
ScriptMgefHandler::ScriptMgefHandler(EffectSetting& effect)
: MgefHandler(effect) , scriptFormID(0), useSEFFAlwaysApplies(false), efitAVResType(TESFileFormats::kResType_None),
customParamResType(TESFileFormats::kResType_None), customParam(0)
{
// By default, only the original SEFF effect uses the 'Always Applies' behavior
if (effect.mgefCode == Swap32('SEFF')) useSEFFAlwaysApplies = true;
}
void swap_HFSPlusCatalogKey(HFSPlusCatalogKey* record)
{
// trace("record (%p)", record);
// noswap: keyLength; swapped in swap_BTNode
Swap32(record->parentID);
swap_HFSUniStr255(&record->nodeName);
}
u32 VSpace::Read32(u32 address)
{
u32 *buf = (u32 *)buffer;
u32 idx = (address - vaddr) >> 2;
/* Return word */
return Swap32(buf[idx]);
}
void VSpace::Write32(u32 address, u32 value)
{
u32 *buf = (u32 *)buffer;
u32 idx = (address - vaddr) >> 2;
/* Write word */
buf[idx] = Swap32(value);
}
void swap_HFSPlusAttrData(HFSPlusAttrData* record)
{
// trace("record (%p)", record);
// noswap: Swap32(record->recordType); (previously swapped)
// noswap: Swap32(record->reserved[0]);
// noswap: Swap32(record->reserved[1]);
Swap32(record->attrSize);
}
static int LoadInt(LoadState* S)
{
uint32_t x;
LoadVar(S,x);
if (S->flip)
x = Swap32(x);
IF ((int32_t)x<0, "bad integer");
return x;
}
/**
* Reads and returns a 32-bit value from the stream
*/
UInt32 IDataStream::Read32(void)
{
UInt32 out;
ReadBuf(&out, sizeof(UInt32));
if(swapBytes)
out = Swap32(out);
return out;
}
static void LoadCode(LoadState* S, Proto* f)
{
int n=LoadInt(S);
int i=0;
f->code=luaM_newvector(S->L,n,Instruction);
f->sizecode=n;
LoadVector(S,f->code,n,sizeof(Instruction));
if (!S->flip)
return;
for (i=0; i<n; ++i)
f->code[i] = Swap32(f->code[i]);
}
int twi_master_read(volatile avr32_twim_t *twi, const twi_package_t *package) {
unsigned int addr = Swap32(package->addr);
// Set Register address if needed
if (package->addr_length) {
#if AVR32_TWIM_H_VERSION > 101
while(twim_write(twi, (unsigned char*)&addr, package->addr_length, package->chip,0)!=TWI_SUCCESS);
#else
twim_write(twi, (unsigned char *)&addr, package->addr_length, package->chip,0);
#endif
}
return twim_read(twi, package->buffer, package->length,package->chip, 0);
}
void swap_HFSPlusCatalogFolder(HFSPlusCatalogFolder* record)
{
// trace("record (%p)", record);
// Swap16(record->recordType);
Swap16(record->flags);
Swap32(record->valence);
Swap32(record->folderID);
Swap32(record->createDate);
Swap32(record->contentModDate);
Swap32(record->attributeModDate);
Swap32(record->accessDate);
Swap32(record->backupDate);
swap_HFSPlusBSDInfo(&record->bsdInfo);
swap_FndrDirInfo(&record->userInfo);
swap_FndrOpaqueInfo(&record->finderInfo);
Swap32(record->textEncoding);
Swap32(record->folderCount);
}
/**
* Writes a 32-bit floating point value to the stream.
*/
void IDataStream::WriteFloat(float inData)
{
if(swapBytes)
{
UInt32 temp = *((UInt32 *)&inData);
temp = Swap32(temp);
WriteBuf(&temp, sizeof(UInt32));
}
else
{
WriteBuf(&inData, sizeof(float));
}
}
void swap_HFSPlusCatalogFile(HFSPlusCatalogFile* record)
{
// trace("record (%p)", record);
// Swap16(record->recordType);
Swap16(record->flags);
Swap32(record->reserved1);
Swap32(record->fileID);
Swap32(record->createDate);
Swap32(record->contentModDate);
Swap32(record->attributeModDate);
Swap32(record->accessDate);
Swap32(record->backupDate);
swap_HFSPlusBSDInfo(&record->bsdInfo);
swap_FndrFileInfo(&record->userInfo);
swap_FndrOpaqueInfo(&record->finderInfo);
Swap32(record->textEncoding);
Swap32(record->reserved2);
swap_HFSPlusForkData(&record->dataFork);
swap_HFSPlusForkData(&record->resourceFork);
}
static void CoreOS_Unpack(u8 *buffer)
{
struct coreHdr *hdr = (struct coreHdr *)buffer;
struct coreEntry *entry = (struct coreEntry *)hdr->entries;
u32 i;
s32 ret;
/* Unpack entries */
for (i = 0; i < Swap32(hdr->files); i++, entry++) {
char *filename = entry->filename;
u64 filesize = Swap64(entry->filesize);
u64 offset = Swap64(entry->offset);
/* Entry info */
printf("File: %-32s (offset: 0x%08llX, size: %.2f MB)\n", filename, offset, filesize / MEGABYTE);
/* Write file */
ret = File_Write(filename, buffer + offset, filesize);
if (ret <= 0)
fprintf(stderr, "ERROR: Could not unpack file \"%s\"! (%d)\n", filename, ret);
}
}
/** Set the extra info (if any) */
virtual void finalizeWithExtraInfo(uint8 * outBuffer, const uint8 * extra, const uint32 extraLen)
{
uint8 hashArray[OutputSize + 64] = {0};
uint32 tmpSize = InputSize + 4 + extraLen;
uint8 hashTmpArray[InputSize + 4 + BaseHasher::DigestSize] = {0};
uint8 * hashTmp = hashTmpArray;
if ((extraLen && extra) || hasher.hashSize() > sizeof(hashTmpArray))
{
hashTmp = new uint8[max(tmpSize, hasher.hashSize())];
if (!hashTmp)
{
if (outBuffer) memset(outBuffer, 0, hashSize());
return; // Far more error to expect when stack or heap is exhausted
}
memset(hashTmp, 0, tmpSize);
}
uint32 d = (OutputSize + hasher.hashSize() - 1) / hasher.hashSize();
for (uint32 i = 0; i < d; i++)
{
// Computing the inner hash
memcpy(hashTmp, hashInput, InputSize);
uint32 swappedI = Swap32(i);
memcpy(&hashTmp[InputSize], &swappedI, sizeof(swappedI)); // Big endian
if (extra && extraLen)
memcpy(&hashTmp[InputSize + 4], extra, extraLen);
// Hash such string now
hasher.Start();
hasher.Hash(hashTmp, tmpSize);
// Overwrite the data with the hash
hasher.Finalize(hashTmp);
memcpy(&hashArray[i * hasher.hashSize()], hashTmp, hasher.hashSize());
memset(hashTmp, 0, tmpSize);
}
if ((extraLen && extra) || hasher.hashSize() > sizeof(hashTmpArray)) delete[] hashTmp;
if (outBuffer) memcpy(outBuffer, hashArray, OutputSize);
}
void LoadKTX( const char *name, byte **data, int *width, int *height,
int *numLayers, int *numMips, int *bits, byte )
{
KTX_header_t *hdr;
byte *ptr;
size_t bufLen, size;
uint32_t imageSize;
*numLayers = 0;
bufLen = ri.FS_ReadFile( name, ( void ** ) &hdr );
if( !hdr )
{
return;
}
if( bufLen < sizeof( KTX_header_t ) ||
memcmp( hdr->identifier, KTX_identifier, sizeof( KTX_identifier) ) ) {
ri.FS_FreeFile( hdr );
return;
}
switch( hdr->endianness ) {
case KTX_endianness:
break;
case KTX_endianness_reverse:
hdr->glType = Swap32( hdr->glType );
hdr->glTypeSize = Swap32( hdr->glTypeSize );
hdr->glFormat = Swap32( hdr->glFormat );
hdr->glInternalFormat = Swap32( hdr->glInternalFormat );
hdr->glBaseInternalFormat = Swap32( hdr->glBaseInternalFormat );
hdr->pixelWidth = Swap32( hdr->pixelWidth );
hdr->pixelHeight = Swap32( hdr->pixelHeight );
hdr->pixelDepth = Swap32( hdr->pixelDepth );
hdr->numberOfArrayElements = Swap32( hdr->numberOfArrayElements );
hdr->numberOfFaces = Swap32( hdr->numberOfFaces );
hdr->numberOfMipmapLevels = Swap32( hdr->numberOfMipmapLevels );
hdr->bytesOfKeyValueData = Swap32( hdr->bytesOfKeyValueData );
break;
default:
ri.FS_FreeFile( hdr );
return;
}
// Support only for RGBA8 and BCn
switch( hdr->glInternalFormat ) {
case GL_RGBA8:
break;
case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
*bits |= IF_BC1;
break;
case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
*bits |= IF_BC3;
break;
case GL_COMPRESSED_RED_RGTC1:
*bits |= IF_BC4;
break;
case GL_COMPRESSED_RG_RGTC2:
*bits |= IF_BC5;
break;
default:
ri.FS_FreeFile( hdr );
return;
}
if( hdr->numberOfArrayElements != 0 ||
(hdr->numberOfFaces != 1 && hdr->numberOfFaces != 6) ||
hdr->pixelWidth == 0 ||
hdr->pixelHeight == 0 ||
hdr->pixelDepth != 0 ) {
ri.FS_FreeFile( hdr );
return;
}
*width = hdr->pixelWidth;
*height = hdr->pixelHeight;
*numMips = hdr->numberOfMipmapLevels;
*numLayers = hdr->numberOfFaces == 6 ? 6 : 0;
ptr = (byte *)(hdr + 1);
ptr += hdr->bytesOfKeyValueData;
size = 0;
for(unsigned i = 0; i < hdr->numberOfMipmapLevels; i++ ) {
imageSize = *((uint32_t *)ptr);
if( hdr->endianness == KTX_endianness_reverse )
imageSize = Swap32( imageSize );
imageSize = PAD( imageSize, 4 );
size += imageSize * hdr->numberOfFaces;
ptr += 4 + imageSize;
}
ptr = (byte *)(hdr + 1);
ptr += hdr->bytesOfKeyValueData;
data[ 0 ] = (byte *)ri.Z_Malloc( size );
imageSize = *((uint32_t *)ptr);
if( hdr->endianness == KTX_endianness_reverse )
imageSize = Swap32( imageSize );
imageSize = PAD( imageSize, 4 );
ptr += 4;
Com_Memcpy( data[ 0 ], ptr, imageSize );
ptr += imageSize;
for(unsigned j = 1; j < hdr->numberOfFaces; j++ ) {
data[ j ] = data[ j - 1 ] + imageSize;
Com_Memcpy( data[ j ], ptr, imageSize );
ptr += imageSize;
}
for(unsigned i = 1; i <= hdr->numberOfMipmapLevels; i++ ) {
imageSize = *((uint32_t *)ptr);
if( hdr->endianness == KTX_endianness_reverse )
imageSize = Swap32( imageSize );
imageSize = PAD( imageSize, 4 );
ptr += 4;
for(unsigned j = 0; j < hdr->numberOfFaces; j++ ) {
int idx = i * hdr->numberOfFaces + j;
data[ idx ] = data[ idx - 1 ] + imageSize;
Com_Memcpy( data[ idx ], ptr, imageSize );
ptr += imageSize;
}
}
ri.FS_FreeFile( hdr );
}
void DispelMgefHandler::SaveHandlerChunk()
{
TESForm::PutFormRecordChunkData(Swap32('EHND'),&ehCode,kEHNDChunkSize);
}
