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