自学教程：C++ swap32函数代码示例

// 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(&sector_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 voidswap_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);}

static unsigned inttpm_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;}

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