// EDAT/SDAT functions.
std::tuple<u64, s32, s32> dec_section(unsigned char* metadata)
{
std::array<u8, 0x10> dec;
dec[0x00] = (metadata[0xC] ^ metadata[0x8] ^ metadata[0x10]);
dec[0x01] = (metadata[0xD] ^ metadata[0x9] ^ metadata[0x11]);
dec[0x02] = (metadata[0xE] ^ metadata[0xA] ^ metadata[0x12]);
dec[0x03] = (metadata[0xF] ^ metadata[0xB] ^ metadata[0x13]);
dec[0x04] = (metadata[0x4] ^ metadata[0x8] ^ metadata[0x14]);
dec[0x05] = (metadata[0x5] ^ metadata[0x9] ^ metadata[0x15]);
dec[0x06] = (metadata[0x6] ^ metadata[0xA] ^ metadata[0x16]);
dec[0x07] = (metadata[0x7] ^ metadata[0xB] ^ metadata[0x17]);
dec[0x08] = (metadata[0xC] ^ metadata[0x0] ^ metadata[0x18]);
dec[0x09] = (metadata[0xD] ^ metadata[0x1] ^ metadata[0x19]);
dec[0x0A] = (metadata[0xE] ^ metadata[0x2] ^ metadata[0x1A]);
dec[0x0B] = (metadata[0xF] ^ metadata[0x3] ^ metadata[0x1B]);
dec[0x0C] = (metadata[0x4] ^ metadata[0x0] ^ metadata[0x1C]);
dec[0x0D] = (metadata[0x5] ^ metadata[0x1] ^ metadata[0x1D]);
dec[0x0E] = (metadata[0x6] ^ metadata[0x2] ^ metadata[0x1E]);
dec[0x0F] = (metadata[0x7] ^ metadata[0x3] ^ metadata[0x1F]);
u64 offset = swap64(*(u64*)&dec[0]);
s32 length = swap32(*(s32*)&dec[8]);
s32 compression_end = swap32(*(s32*)&dec[12]);
return std::make_tuple(offset, length, compression_end);
}
int sys_psp_prx_patch(uint32_t *unk, uint8_t *elf_buf, void *link_register)
{
unk = get_secure_user_ptr(unk);
elf_buf = get_secure_user_ptr(elf_buf);
#ifdef DEBUG
//DPRINTF("link_register = %p\n", link_register);
if (link_register == (void *)(pemucorelib_base+prx_patch_call_lr))
{
if (*(uint32_t *)&elf_buf[0] == 0x7F454C46)
{
Elf32_Ehdr *ehdr;
Elf32_Phdr *phdr;
PspModuleInfo *modinfo;
ehdr = (Elf32_Ehdr *)elf_buf;
phdr = (Elf32_Phdr *)(elf_buf+swap32(ehdr->e_phoff));
modinfo = (PspModuleInfo *)(elf_buf+swap32(phdr[0].p_paddr));
DPRINTF("Module %s (elf_buf=%p)\n", modinfo->modname, elf_buf);
}
}
#endif
psp_func1(unk, elf_buf);
return 0;
}
Psmf::Psmf(u32 data) {
headerOffset = data;
magic = Memory::Read_U32(data);
version = Memory::Read_U32(data + 4);
streamOffset = swap32(Memory::Read_U32(data + 8));
streamSize = swap32(Memory::Read_U32(data + 12));
streamDataTotalSize = swap32(Memory::Read_U32(data + 0x50));
presentationStartTime = getMpegTimeStamp(Memory::GetPointer(data + PSMF_FIRST_TIMESTAMP_OFFSET));
presentationEndTime = getMpegTimeStamp(Memory::GetPointer(data + PSMF_LAST_TIMESTAMP_OFFSET));
streamDataNextBlockSize = swap32(Memory::Read_U32(data + 0x6A));
streamDataNextInnerBlockSize = swap32(Memory::Read_U32(data + 0x7C));
numStreams = swap16(Memory::Read_U16(data + 0x80));
currentStreamNum = -1;
currentAudioStreamNum = -1;
currentVideoStreamNum = -1;
for (int i = 0; i < numStreams; i++) {
PsmfStream *stream = 0;
u32 currentStreamAddr = data + 0x82 + i * 16;
int streamId = Memory::Read_U8(currentStreamAddr);
if ((streamId & PSMF_VIDEO_STREAM_ID) == PSMF_VIDEO_STREAM_ID) {
stream = new PsmfStream(PSMF_AVC_STREAM, ++currentVideoStreamNum);
stream->readMPEGVideoStreamParams(currentStreamAddr, this);
} else if ((streamId & PSMF_AUDIO_STREAM_ID) == PSMF_AUDIO_STREAM_ID) {
stream = new PsmfStream(PSMF_ATRAC_STREAM, ++currentAudioStreamNum);
stream->readPrivateAudioStreamParams(currentStreamAddr, this);
}
if (stream) {
currentStreamNum++;
streamMap[currentStreamNum] = stream;
}
}
}
void WvOut :: closeWavFile( void )
{
int bytes_per_sample = 1;
if ( dataType == STK_SINT16 )
bytes_per_sample = 2;
else if ( dataType == STK_SINT32 || dataType == MY_FLOAT32 )
bytes_per_sample = 4;
else if ( dataType == MY_FLOAT64 )
bytes_per_sample = 8;
SINT32 bytes = totalCount * channels * bytes_per_sample;
#ifndef __LITTLE_ENDIAN__
swap32((unsigned char *)&bytes);
#endif
fseek(fd, 40, SEEK_SET); // jump to data length
fwrite(&bytes, 4, 1, fd);
bytes = totalCount * channels * bytes_per_sample + 44;
#ifndef __LITTLE_ENDIAN__
swap32((unsigned char *)&bytes);
#endif
fseek(fd, 4, SEEK_SET); // jump to file size
fwrite(&bytes, 4, 1, fd);
fclose( fd );
}
void WorldSession::HandleSetTradeGold(WorldPacket & recv_data)
{
if(_player->mTradeTarget == 0)
return;
// cebernic: TradeGold sameway.
uint32 TradeStatus = TRADE_STATUS_STATE_CHANGED;
Player * plr = _player->GetTradeTarget();
if(!plr) return;
#ifdef USING_BIG_ENDIAN
swap32(&TradeStatus);
OutPacket(SMSG_TRADE_STATUS, 4, &TradeStatus);
plr->m_session->OutPacket(SMSG_TRADE_STATUS, 4, &TradeStatus);
swap32(&TradeStatus);
#else
OutPacket(SMSG_TRADE_STATUS, 4, &TradeStatus);
plr->m_session->OutPacket(SMSG_TRADE_STATUS, 4, &TradeStatus);
#endif
plr->mTradeStatus = TradeStatus;
_player->mTradeStatus = TradeStatus;
uint32 Gold;
recv_data >> Gold;
if(_player->mTradeGold != Gold)
{
_player->mTradeGold = (Gold > _player->GetUInt32Value(PLAYER_FIELD_COINAGE) ? _player->GetUInt32Value(PLAYER_FIELD_COINAGE) : Gold);
_player->SendTradeUpdate();
}
}
void WorldSession::HandleIgnoreTrade(WorldPacket & recv_data)
{
if(!_player->IsInWorld()) return;
uint32 TradeStatus = TRADE_STATUS_PLAYER_IGNORED;
Player * plr = _player->GetTradeTarget();
if(_player->mTradeTarget == 0 || plr == 0)
{
#ifdef USING_BIG_ENDIAN
TradeStatus = swap32(uint32(TRADE_STATUS_PLAYER_NOT_FOUND));
#else
TradeStatus = TRADE_STATUS_PLAYER_NOT_FOUND;
#endif
OutPacket(TRADE_STATUS_PLAYER_NOT_FOUND, 4, &TradeStatus);
return;
}
#ifdef USING_BIG_ENDIAN
swap32(&TradeStatus);
OutPacket(SMSG_TRADE_STATUS, 4, &TradeStatus);
plr->m_session->OutPacket(SMSG_TRADE_STATUS, 4, &TradeStatus);
swap32(&TradeStatus);
#else
OutPacket(SMSG_TRADE_STATUS, 4, &TradeStatus);
plr->m_session->OutPacket(SMSG_TRADE_STATUS, 4, &TradeStatus);
#endif
plr->mTradeStatus = TradeStatus;
_player->mTradeStatus = TradeStatus;
plr->mTradeTarget = 0;
_player->mTradeTarget = 0;
}
static bool mon17_iter(const ipdb *ctx, ipdb_item *item, uint32_t index)
{
char *parting;
static char buf[256];
if(index<ctx->count)
{
mon17_item *ptr = (mon17_item*)(ctx->buffer + 4 + 256*4);
const char *text = (const char*)ctx->buffer + 4 + 256*4 + ctx->count*8 + ptr[index].offset;
item->lower = index==0?0:(swap32(ptr[index-1].upper)+1);
item->upper = swap32(ptr[index].upper);
memcpy(buf, text, ptr[index].length);
buf[ptr[index].length] = 0;
parting = strchr(buf, '\t');
*parting = 0;
item->zone = buf;
item->area = parting + 1;
return true;
}
return false;
}
void WorldSession::SendChatPacket(WorldPacket * data, uint32 langpos, int32 lang, WorldSession * originator)
{
#ifndef USING_BIG_ENDIAN
if(lang == -1)
*(uint32*)&data->contents()[langpos] = lang;
else
{
if(CanUseCommand('c') || (originator && originator->CanUseCommand('c')))
*(uint32*)&data->contents()[langpos] = LANG_UNIVERSAL;
else
*(uint32*)&data->contents()[langpos] = lang;
}
#else
if(lang == -1)
*(uint32*)&data->contents()[langpos] = swap32(lang);
else
{
if(CanUseCommand('c') || (originator && originator->CanUseCommand('c')))
*(uint32*)&data->contents()[langpos] = swap32(uint32(LANG_UNIVERSAL));
else
*(uint32*)&data->contents()[langpos] = swap32(lang);
}
#endif
SendPacket(data);
}
void WorldSession::HandleClearTradeItem(WorldPacket & recv_data)
{
CHECK_PACKET_SIZE(recv_data, 1);
if(_player->mTradeTarget == 0)
return;
uint8 TradeSlot = recv_data.contents()[0];
if(TradeSlot > 6)
return;
// clean status
Player * plr = _player->GetTradeTarget();
if ( !plr ) return;
uint32 TradeStatus = TRADE_STATUS_STATE_CHANGED;
#ifdef USING_BIG_ENDIAN
swap32(&TradeStatus);
OutPacket(SMSG_TRADE_STATUS, 4, &TradeStatus);
plr->m_session->OutPacket(SMSG_TRADE_STATUS, 4, &TradeStatus);
swap32(&TradeStatus);
#else
OutPacket(SMSG_TRADE_STATUS, 4, &TradeStatus);
plr->m_session->OutPacket(SMSG_TRADE_STATUS, 4, &TradeStatus);
#endif
plr->mTradeStatus = TradeStatus;
_player->mTradeStatus = TradeStatus;
_player->mTradeItems[TradeSlot] = 0;
_player->SendTradeUpdate();
}
void WvOut :: writeData( unsigned long frames )
{
if ( dataType == STK_SINT8 ) {
if ( fileType == WVOUT_WAV ) { // 8-bit WAV data is unsigned!
unsigned char sample;
for ( unsigned long k=0; k<frames*channels; k++ ) {
sample = (unsigned char) (data[k] * 127.0 + 128.0);
if ( fwrite(&sample, 1, 1, fd) != 1 ) goto error;
}
}
else {
signed char sample;
for ( unsigned long k=0; k<frames*channels; k++ ) {
sample = (signed char) (data[k] * 127.0);
//sample = ((signed char) (( data[k] + 1.0 ) * 127.5 + 0.5)) - 128;
if ( fwrite(&sample, 1, 1, fd) != 1 ) goto error;
}
}
}
else if ( dataType == STK_SINT16 ) {
SINT16 sample;
for ( unsigned long k=0; k<frames*channels; k++ ) {
sample = (SINT16) (data[k] * 32767.0);
//sample = ((SINT16) (( data[k] + 1.0 ) * 32767.5 + 0.5)) - 32768;
if ( byteswap ) swap16( (unsigned char *)&sample );
if ( fwrite(&sample, 2, 1, fd) != 1 ) goto error;
}
}
else if ( dataType == STK_SINT32 ) {
SINT32 sample;
for ( unsigned long k=0; k<frames*channels; k++ ) {
sample = (SINT32) (data[k] * 2147483647.0);
//sample = ((SINT32) (( data[k] + 1.0 ) * 2147483647.5 + 0.5)) - 2147483648;
if ( byteswap ) swap32( (unsigned char *)&sample );
if ( fwrite(&sample, 4, 1, fd) != 1 ) goto error;
}
}
else if ( dataType == MY_FLOAT32 ) {
FLOAT32 sample;
for ( unsigned long k=0; k<frames*channels; k++ ) {
sample = (FLOAT32) (data[k]);
if ( byteswap ) swap32( (unsigned char *)&sample );
if ( fwrite(&sample, 4, 1, fd) != 1 ) goto error;
}
}
else if ( dataType == MY_FLOAT64 ) {
FLOAT64 sample;
for ( unsigned long k=0; k<frames*channels; k++ ) {
sample = (FLOAT64) (data[k]);
if ( byteswap ) swap64( (unsigned char *)&sample );
if ( fwrite(&sample, 8, 1, fd) != 1 ) goto error;
}
}
return;
error:
sprintf(msg, "WvOut: Error writing data to file.");
handleError(msg, StkError::FILE_ERROR);
}
s32 Partition_GetEntries(u32 device, partitionEntry *outbuf, u32 *outval)
{
static partitionTable table ATTRIBUTE_ALIGN(32);
u32 cnt, sector_size;
s32 ret;
/* Read from specified device */
switch (device) {
case WBFS_DEVICE_USB: {
/* Get sector size */
ret = USBStorage_GetCapacity(§or_size);
if (ret == 0)
return -1;
/* Read partition table */
u8* table_buf = memalign(32, sector_size);
ret = USBStorage_ReadSectors(0, 1, table_buf);
memcpy(&table, table_buf, sizeof(table));
SAFE_FREE(table_buf);
if (ret < 0)
return ret;
break;
}
case WBFS_DEVICE_SDHC: {
/* SDHC sector size */
sector_size = SDHC_SECTOR_SIZE;
/* Read partition table */
ret = SDHC_ReadSectors(0, 1, &table);
if (!ret)
return -1;
break;
}
default:
return -1;
}
/* Swap endianess */
for (cnt = 0; cnt < 4; cnt++) {
partitionEntry *entry = &table.entries[cnt];
entry->sector = swap32(entry->sector);
entry->size = swap32(entry->size);
}
/* Set partition entries */
memcpy(outbuf, table.entries, sizeof(table.entries));
/* Set sector size */
*outval = sector_size;
return 0;
}
//--------------------------------------------------------------------------
local void swap_fat_arch(fat_arch *fa)
{
fa->cputype = swap32(fa->cputype);
fa->cpusubtype = swap32(fa->cpusubtype);
fa->offset = swap32(fa->offset);
fa->size = swap32(fa->size);
fa->align = swap32(fa->align);
}
bool WvOut :: setWavFile( const char *fileName )
{
char name[128];
strncpy(name, fileName, 128);
if ( strstr(name, ".wav") == NULL) strcat(name, ".wav");
fd = fopen(name, "wb");
if ( !fd ) {
sprintf(msg, "WvOut: Could not create WAV file: %s", name);
return false;
}
struct wavhdr hdr = {"RIF", 44, "WAV", "fmt", 16, 1, 1,
(SINT32) Stk::sampleRate(), 0, 2, 16, "dat", 0};
hdr.riff[3] = 'F';
hdr.wave[3] = 'E';
hdr.fmt[3] = ' ';
hdr.data[3] = 'a';
hdr.num_chans = (SINT16) channels;
if ( dataType == STK_SINT8 )
hdr.bits_per_samp = 8;
else if ( dataType == STK_SINT16 )
hdr.bits_per_samp = 16;
else if ( dataType == STK_SINT32 )
hdr.bits_per_samp = 32;
else if ( dataType == MY_FLOAT32 ) {
hdr.format_tag = 3;
hdr.bits_per_samp = 32;
}
else if ( dataType == MY_FLOAT64 ) {
hdr.format_tag = 3;
hdr.bits_per_samp = 64;
}
hdr.bytes_per_samp = (SINT16) (channels * hdr.bits_per_samp / 8);
hdr.bytes_per_sec = (SINT32) (hdr.sample_rate * hdr.bytes_per_samp);
byteswap = false;
#ifndef __LITTLE_ENDIAN__
byteswap = true;
swap32((unsigned char *)&hdr.file_size);
swap32((unsigned char *)&hdr.chunk_size);
swap16((unsigned char *)&hdr.format_tag);
swap16((unsigned char *)&hdr.num_chans);
swap32((unsigned char *)&hdr.sample_rate);
swap32((unsigned char *)&hdr.bytes_per_sec);
swap16((unsigned char *)&hdr.bytes_per_samp);
swap16((unsigned char *)&hdr.bits_per_samp);
#endif
if ( fwrite(&hdr, 4, 11, fd) != 11 ) {
sprintf(msg, "WvOut: Could not write WAV header for file %s", name);
return false;
}
printf("\nCreating WAV file: %s\n", name);
return true;
}
bool WvOut :: setWavFile( const char *fileName )
{
char name[8192];
strncpy(name, fileName, 8192);
if ( strstr(name, ".wav") == NULL) strcat(name, ".wav");
fd_ = fopen(name, "wb");
if ( !fd_ ) {
errorString_ << "WvOut: could not create WAV file: " << name;
return false;
}
struct wavhdr hdr = {"RIF", 44, "WAV", "fmt", 16, 1, 1,
(SINT32) Stk::sampleRate(), 0, 2, 16, "dat", 0};
hdr.riff[3] = 'F';
hdr.wave[3] = 'E';
hdr.fmt[3] = ' ';
hdr.data[3] = 'a';
hdr.num_chans = (SINT16) channels_;
if ( dataType_ == STK_SINT8 )
hdr.bits_per_samp = 8;
else if ( dataType_ == STK_SINT16 )
hdr.bits_per_samp = 16;
else if ( dataType_ == STK_SINT32 )
hdr.bits_per_samp = 32;
else if ( dataType_ == STK_FLOAT32 ) {
hdr.format_tag = 3;
hdr.bits_per_samp = 32;
}
else if ( dataType_ == STK_FLOAT64 ) {
hdr.format_tag = 3;
hdr.bits_per_samp = 64;
}
hdr.bytes_per_samp = (SINT16) (channels_ * hdr.bits_per_samp / 8);
hdr.bytes_per_sec = (SINT32) (hdr.sample_rate * hdr.bytes_per_samp);
byteswap_ = false;
#ifndef __LITTLE_ENDIAN__
byteswap_ = true;
swap32((unsigned char *)&hdr.file_size);
swap32((unsigned char *)&hdr.chunk_size);
swap16((unsigned char *)&hdr.format_tag);
swap16((unsigned char *)&hdr.num_chans);
swap32((unsigned char *)&hdr.sample_rate);
swap32((unsigned char *)&hdr.bytes_per_sec);
swap16((unsigned char *)&hdr.bytes_per_samp);
swap16((unsigned char *)&hdr.bits_per_samp);
#endif
if ( fwrite(&hdr, 4, 11, fd_) != 11 ) {
errorString_ << "WvOut: could not write WAV header for file " << name << '.';
return false;
}
errorString_ << "WvOut: creating WAV file: " << name;
handleError( StkError::WARNING );
return true;
}
void test_macros()
{
assert(swap16(0) == 0);
assert(swap16(0x0102) == 0x0201);
assert(swap32(0) == 0);
assert(swap32(0x01020304) == 0x04030201);
assert(swap64(0) == 0);
assert(swap64(0x0102030405060708ULL) == 0x0807060504030201ULL);
}
//----------------------------------------------------------------------
static void swap_pef_export(pef_export_t &pe)
{
#if __MF__
qnotused(pe);
#else
pe.classAndName = swap32(pe.classAndName);
pe.symbolValue = swap32(pe.symbolValue);
pe.sectionIndex = swap16(pe.sectionIndex);
#endif
}
/*
* reimplement pcap_open_offline with privsep, this is the
* unprivileged part.
* XXX merge with above?
*/
static void
swap_hdr(struct pcap_file_header *hp)
{
hp->version_major = swap16(hp->version_major);
hp->version_minor = swap16(hp->version_minor);
hp->thiszone = swap32(hp->thiszone);
hp->sigfigs = swap32(hp->sigfigs);
hp->snaplen = swap32(hp->snaplen);
hp->linktype = swap32(hp->linktype);
}
void
ar9380_swap_rom(struct athn_softc *sc)
{
#if BYTE_ORDER == BIG_ENDIAN
struct ar9380_eeprom *eep = sc->eep;
struct ar9380_base_eep_hdr *base = &eep->baseEepHeader;
struct ar9380_modal_eep_header *modal;
int i;
base->regDmn[0] = swap16(base->regDmn[0]);
base->regDmn[1] = swap16(base->regDmn[1]);
base->swreg = swap32(base->swreg);
modal = &eep->modalHeader2G;
modal->antCtrlCommon = swap32(modal->antCtrlCommon);
modal->antCtrlCommon2 = swap32(modal->antCtrlCommon2);
modal->papdRateMaskHt20 = swap32(modal->papdRateMaskHt20);
modal->papdRateMaskHt40 = swap32(modal->papdRateMaskHt40);
for (i = 0; i < AR9380_MAX_CHAINS; i++)
modal->antCtrlChain[i] = swap16(modal->antCtrlChain[i]);
modal = &eep->modalHeader5G;
modal->antCtrlCommon = swap32(modal->antCtrlCommon);
modal->antCtrlCommon2 = swap32(modal->antCtrlCommon2);
modal->papdRateMaskHt20 = swap32(modal->papdRateMaskHt20);
modal->papdRateMaskHt40 = swap32(modal->papdRateMaskHt40);
for (i = 0; i < AR9380_MAX_CHAINS; i++)
modal->antCtrlChain[i] = swap16(modal->antCtrlChain[i]);
#endif
}
static unsigned int
tpm_getrandom (void *buf, unsigned int size)
{
#ifdef TCG_BIOS
struct {
u16 tag;
u32 len;
u32 command;
u32 bytessize;
} __attribute__ ((packed)) *tpminput;
struct {
u16 tag;
u32 len;
u32 result;
u32 bytessize;
u8 bytes[1];
} __attribute__ ((packed)) *tpmoutput;
struct TCG_PassThroughToTPM_input_param_blk *input;
struct TCG_PassThroughToTPM_output_param_blk *output;
u32 ret;
unsigned int inputlen, outputlen;
static const u16 TPM_TAG_RQU_COMMAND = 193;
static const u32 TPM_ORD_GetRandom = 0x46;
inputlen = sizeof *input - sizeof input->TPMOperandIn
+ sizeof *tpminput;
outputlen = sizeof *output - sizeof output->TPMOperandOut
+ sizeof *tpmoutput - sizeof tpmoutput->bytes + size;
input = alloc (inputlen);
output = alloc (outputlen);
memset (input, 0, inputlen);
input->IPBLength = inputlen;
input->OPBLength = outputlen;
tpminput = (void *)input->TPMOperandIn;
tpminput->tag = swap16 (TPM_TAG_RQU_COMMAND);
tpminput->len = swap32 (sizeof *tpminput);
tpminput->command = swap32 (TPM_ORD_GetRandom);
tpminput->bytessize = swap32 (size);
memset (output, 0, outputlen);
if (!int1a_TCG_PassThroughToTPM (input, output, outputlen, &ret))
return 0;
tpmoutput = (void *)output->TPMOperandOut;
if (tpmoutput->result != TCG_PC_OK)
return 0;
if (size > tpmoutput->bytessize)
size = tpmoutput->bytessize;
memcpy (buf, tpmoutput->bytes, size);
free (input);
free (output);
return size;
#else
return 0;
#endif
}
//----------------------------------------------------------------------
static void swap_pef_reloc_header(pef_reloc_header_t &prh)
{
#if __MF__
qnotused(prh);
#else
prh.sectionIndex = swap16(prh.sectionIndex);
prh.reservedA = swap16(prh.reservedA);
prh.relocCount = swap32(prh.relocCount);
prh.firstRelocOffset = swap32(prh.firstRelocOffset);
#endif
}
void readff(const char * filename)
{
std::string temp(filename);
if(temp.size() <= 3)
{
puts("fixing filename");
temp += ".ff";
filename = temp.data();
} // Unfortunately I have to duplicate code or else use gotos or logic variables.
else if(temp.substr(temp.length()-3) != ".ff")
{
puts("fixing filename");
temp += ".ff";
filename = temp.data();
}
FILE* file = fopen(filename, "rb");
printf("reading file %s\n", filename);
if(file != NULL)
{
char name[8];
fread(name, 1, 8, file);
printf("%.8s -- header magic\n", name);
if(memcmp(name, "farbfeld", 8) == 0)
{
{
unsigned int scratch[2];
fread(scratch, 4, 2, file);
width = swap32(scratch[0]);
height = swap32(scratch[1]);
std::cout << width << " " << height << " -- dimensions\n";
dimensions(width, height);
}
for(auto& t : data)
{
unsigned short scratch[4];
fread(scratch, 2, 4, file);
t.r = swap16(scratch[0])*1.0/0xFFFF;
t.g = swap16(scratch[1])*1.0/0xFFFF;
t.b = swap16(scratch[2])*1.0/0xFFFF;
}
}
else
puts("Not a valid farbfeld file.");
fclose(file);
std::cout << data.size() << " -- number of pixels in farbfeld\n";
}
else
puts("Error opening file.");
}
void readMPEGVideoStreamParams(u32 addr, Psmf *psmf) {
int streamId = Memory::Read_U8(addr);
int privateStreamId = Memory::Read_U8(addr + 1);
// two unknowns here
psmf->EPMapOffset = swap32(Memory::Read_U32(addr + 4));
psmf->EPMapEntriesNum = swap32(Memory::Read_U32(addr + 8));
psmf->videoWidth = Memory::Read_U8(addr + 12) * 16;
psmf->videoHeight = Memory::Read_U8(addr + 13) * 16;
INFO_LOG(ME, "PSMF MPEG data found: id=%02x, privid=%02x, epmoff=%08x, epmnum=%08x, width=%i, height=%i", streamId, privateStreamId, psmf->EPMapOffset, psmf->EPMapEntriesNum, psmf->videoWidth, psmf->videoHeight);
}
uint64_t swap64(uint64_t in)
{
uint32_t low,high;
uint64_t out;
high=in>>32;
low=in&0xffffffff;
high=swap32(high);
low=swap32(low);
out=low;
out=(out<<32)+high;
return out;
}
static void endianadjust_phdr64(Elf64_Phdr *ph)
{
if ( !big_endian )
return;
ph->p_type = swap32(ph->p_type);
ph->p_flags = swap32(ph->p_flags);
ph->p_offset = swap64(ph->p_offset);
ph->p_vaddr = swap64(ph->p_vaddr);
ph->p_paddr = swap64(ph->p_paddr);
ph->p_filesz = swap64(ph->p_filesz);
ph->p_memsz = swap64(ph->p_memsz);
ph->p_align = swap64(ph->p_align);
}
//----------------------------------------------------------------------
static void swap_pef_library(pef_library_t &pil)
{
#if __MF__
qnotused(pil);
#else
pil.nameOffset = swap32(pil.nameOffset );
pil.oldImpVersion = swap32(pil.oldImpVersion );
pil.currentVersion = swap32(pil.currentVersion );
pil.importedSymbolCount = swap32(pil.importedSymbolCount);
pil.firstImportedSymbol = swap32(pil.firstImportedSymbol);
pil.reservedB = swap16(pil.reservedB );
#endif
}
char *devprop_generate_string(struct DevPropString *string)
{
char *buffer = (char*)MALLOC(string->length * 2);
char *ptr = buffer;
if(!buffer)
return NULL;
sprintf(buffer, "%08x%08x%04x%04x", swap32(string->length), string->WHAT2,
swap16(string->numentries), string->WHAT3);
buffer += 24;
int i = 0, x = 0;
while(i < string->numentries)
{
sprintf(buffer, "%08x%04x%04x", swap32(string->entries[i]->length),
swap16(string->entries[i]->numentries), string->entries[i]->WHAT2);
buffer += 16;
sprintf(buffer, "%02x%02x%04x%08x%08x", string->entries[i]->acpi_dev_path.type,
string->entries[i]->acpi_dev_path.subtype,
swap16(string->entries[i]->acpi_dev_path.length),
string->entries[i]->acpi_dev_path._HID,
swap32(string->entries[i]->acpi_dev_path._UID));
buffer += 24;
for(x=0; x < string->entries[i]->num_pci_devpaths; x++)
{
sprintf(buffer, "%02x%02x%04x%02x%02x", string->entries[i]->pci_dev_path[x].type,
string->entries[i]->pci_dev_path[x].subtype,
swap16(string->entries[i]->pci_dev_path[x].length),
string->entries[i]->pci_dev_path[x].function,
string->entries[i]->pci_dev_path[x].device);
buffer += 12;
}
sprintf(buffer, "%02x%02x%04x", string->entries[i]->path_end.type,
string->entries[i]->path_end.subtype,
swap16(string->entries[i]->path_end.length));
buffer += 8;
uint8_t *dataptr = string->entries[i]->data;
for(x = 0; x < (string->entries[i]->length) - (24 + (6 * string->entries[i]->num_pci_devpaths)) ; x++)
{
sprintf(buffer, "%02x", *dataptr++);
buffer += 2;
}
i++;
}
return ptr;
}
int
elf_fix_phdr(Elf_Phdr *ph, void *v)
{
ph->p_type = swap32(ph->p_type);
ph->p_flags = swap32(ph->p_flags);
ph->p_offset = swap_off(ph->p_offset);
ph->p_vaddr = swap_addr(ph->p_vaddr);
ph->p_paddr = swap_addr(ph->p_paddr);
ph->p_filesz = swap_xword(ph->p_filesz);
ph->p_memsz = swap_xword(ph->p_memsz);
ph->p_align = swap_xword(ph->p_align);
return 1;
}
void MetadataSectionHeader::Load(u8* in)
{
memcpy(&data_offset, in, 8);
memcpy(&data_size, in + 8, 8);
memcpy(&type, in + 16, 4);
memcpy(&program_idx, in + 20, 4);
memcpy(&hashed, in + 24, 4);
memcpy(&sha1_idx, in + 28, 4);
memcpy(&encrypted, in + 32, 4);
memcpy(&key_idx, in + 36, 4);
memcpy(&iv_idx, in + 40, 4);
memcpy(&compressed, in + 44, 4);
// Endian swap.
data_offset = swap64(data_offset);
data_size = swap64(data_size);
type = swap32(type);
program_idx = swap32(program_idx);
hashed = swap32(hashed);
sha1_idx = swap32(sha1_idx);
encrypted = swap32(encrypted);
key_idx = swap32(key_idx);
iv_idx = swap32(iv_idx);
compressed = swap32(compressed);
}
void FileWrite ::closeWavFile(void) {
int bytesPerSample = 1;
if (dataType_ == STK_SINT16)
bytesPerSample = 2;
else if (dataType_ == STK_SINT24)
bytesPerSample = 3;
else if (dataType_ == STK_SINT32 || dataType_ == STK_FLOAT32)
bytesPerSample = 4;
else if (dataType_ == STK_FLOAT64)
bytesPerSample = 8;
bool useExtensible = false;
int dataLocation = 40;
if (bytesPerSample > 2 || channels_ > 2) {
useExtensible = true;
dataLocation = 76;
}
SINT32 bytes = (SINT32)(frameCounter_ * channels_ * bytesPerSample);
if (bytes % 2) { // pad extra byte if odd
signed char sample = 0;
fwrite(&sample, 1, 1, fd_);
}
#ifndef __LITTLE_ENDIAN__
swap32((unsigned char *)&bytes);
#endif
fseek(fd_, dataLocation, SEEK_SET); // jump to data length
fwrite(&bytes, 4, 1, fd_);
bytes = (SINT32)(frameCounter_ * channels_ * bytesPerSample + 44);
if (useExtensible)
bytes += 36;
#ifndef __LITTLE_ENDIAN__
swap32((unsigned char *)&bytes);
#endif
fseek(fd_, 4, SEEK_SET); // jump to file size
fwrite(&bytes, 4, 1, fd_);
if (useExtensible) { // fill in the "fact" chunk frames value
bytes = (SINT32)frameCounter_;
#ifndef __LITTLE_ENDIAN__
swap32((unsigned char *)&bytes);
#endif
fseek(fd_, 68, SEEK_SET);
fwrite(&bytes, 4, 1, fd_);
}
fclose(fd_);
}
static void endianadjust_shdr32(Elf32_Shdr *sh)
{
if ( !big_endian )
return;
sh->sh_name = swap32(sh->sh_name);
sh->sh_type = swap32(sh->sh_type);
sh->sh_flags = swap32(sh->sh_flags);
sh->sh_addr = swap32(sh->sh_addr);
sh->sh_offset = swap32(sh->sh_offset);
sh->sh_size = swap32(sh->sh_size);
sh->sh_link = swap32(sh->sh_link);
sh->sh_info = swap32(sh->sh_info);
sh->sh_addralign = swap32(sh->sh_addralign);
sh->sh_entsize = swap32(sh->sh_entsize);
}
