static void CopyLineQwordsSwap(void * dst, const void * src, u32 qwords) { #ifdef FAST_TMEM_COPY u32* src32 = (u32*)src; u32* dst32 = (u32*)dst; DAEDALUS_ASSERT( ((uintptr_t)src32&0x3 )==0, "src is not aligned!"); while(qwords--) { dst32[1] = BSWAP32(src32[0]); dst32[0] = BSWAP32(src32[1]); dst32 += 2; src32 += 2; } #else u8* src8 = (u8*)src; u8* dst8 = (u8*)dst; u32 bytes = qwords * 8; while(bytes--) { *(u8*)((uintptr_t)dst8++ ^ 0x4) = *(u8*)((uintptr_t)src8++ ^ U8_TWIDDLE); } #endif }
int i4btrace_open(wtap *wth, int *err, gchar **err_info) { int bytes_read; i4b_trace_hdr_t hdr; gboolean byte_swapped = FALSE; i4btrace_t *i4btrace; /* I4B trace files have no magic in the header... Sigh */ errno = WTAP_ERR_CANT_READ; bytes_read = file_read(&hdr, sizeof(hdr), wth->fh); if (bytes_read != sizeof(hdr)) { *err = file_error(wth->fh, err_info); if (*err != 0 && *err != WTAP_ERR_SHORT_READ) return -1; return 0; } /* Silly heuristic... */ if (!I4B_HDR_IS_OK(hdr)) { /* * OK, try byte-swapping the header fields. */ hdr.length = BSWAP32(hdr.length); hdr.unit = BSWAP32(hdr.unit); hdr.type = BSWAP32(hdr.type); hdr.dir = BSWAP32(hdr.dir); hdr.trunc = BSWAP32(hdr.trunc); if (!I4B_HDR_IS_OK(hdr)) { /* * It doesn't look valid in either byte order. */ return 0; } /* * It looks valid byte-swapped, so assume it's a * trace written in the opposite byte order. */ byte_swapped = TRUE; } if (file_seek(wth->fh, 0, SEEK_SET, err) == -1) return -1; /* Get capture start time */ wth->file_type = WTAP_FILE_I4BTRACE; i4btrace = (i4btrace_t *)g_malloc(sizeof(i4btrace_t)); wth->priv = (void *)i4btrace; wth->subtype_read = i4btrace_read; wth->subtype_seek_read = i4btrace_seek_read; wth->snapshot_length = 0; /* not known */ i4btrace->byte_swapped = byte_swapped; wth->file_encap = WTAP_ENCAP_ISDN; wth->tsprecision = WTAP_FILE_TSPREC_USEC; return 1; }
/** Check if all GRFs in the GRF config from a savegame can be loaded. * @param grfconfig GrfConfig to check * @return will return any of the following 3 values:<br> * <ul> * <li> GLC_ALL_GOOD: No problems occured, all GRF files were found and loaded * <li> GLC_COMPATIBLE: For one or more GRF's no exact match was found, but a * compatible GRF with the same grfid was found and used instead * <li> GLC_NOT_FOUND: For one or more GRF's no match was found at all * </ul> */ GRFListCompatibility IsGoodGRFConfigList(GRFConfig *grfconfig) { GRFListCompatibility res = GLC_ALL_GOOD; for (GRFConfig *c = grfconfig; c != NULL; c = c->next) { const GRFConfig *f = FindGRFConfig(c->ident.grfid, c->ident.md5sum); if (f == NULL) { char buf[256]; /* If we have not found the exactly matching GRF try to find one with the * same grfid, as it most likely is compatible */ f = FindGRFConfig(c->ident.grfid); if (f != NULL) { md5sumToString(buf, lastof(buf), c->ident.md5sum); DEBUG(grf, 1, "NewGRF %08X (%s) not found; checksum %s. Compatibility mode on", BSWAP32(c->ident.grfid), c->filename, buf); if (!HasBit(c->flags, GCF_COMPATIBLE)) { /* Preserve original_md5sum after it has been assigned */ SetBit(c->flags, GCF_COMPATIBLE); memcpy(c->original_md5sum, c->ident.md5sum, sizeof(c->original_md5sum)); } /* Non-found has precedence over compatibility load */ if (res != GLC_NOT_FOUND) res = GLC_COMPATIBLE; goto compatible_grf; } /* No compatible grf was found, mark it as disabled */ md5sumToString(buf, lastof(buf), c->ident.md5sum); DEBUG(grf, 0, "NewGRF %08X (%s) not found; checksum %s", BSWAP32(c->ident.grfid), c->filename, buf); c->status = GCS_NOT_FOUND; res = GLC_NOT_FOUND; } else { compatible_grf: DEBUG(grf, 1, "Loading GRF %08X from %s", BSWAP32(f->ident.grfid), f->filename); /* The filename could be the filename as in the savegame. As we need * to load the GRF here, we need the correct filename, so overwrite that * in any case and set the name and info when it is not set already. * When the GCF_COPY flag is set, it is certain that the filename is * already a local one, so there is no need to replace it. */ if (!HasBit(c->flags, GCF_COPY)) { free(c->filename); c->filename = strdup(f->filename); memcpy(c->ident.md5sum, f->ident.md5sum, sizeof(c->ident.md5sum)); if (c->name == NULL && f->name != NULL) c->name = strdup(f->name); if (c->info == NULL && f->info != NULL) c->info = strdup(f->info); c->error = NULL; } } } return res; }
static inline void CopyLine(void * dst, const void * src, u32 bytes) { #ifdef FAST_TMEM_COPY u32* src32 = (u32*)src; u32* dst32 = (u32*)dst; DAEDALUS_ASSERT((bytes&0x3)==0, "CopyLine: Remaning bytes! (%d)",bytes); u32 size32 = bytes >> 2; u32 src_alignment = (uintptr_t)src32&0x3; if(src_alignment == 0) { while (size32--) { *dst32++ = BSWAP32(src32[0]); src32++; } } else { // Zelda and DK64 have unaligned copies. so let's optimize 'em src32 = (u32*)((uintptr_t)src & ~0x3); u32 src_tmp = *src32++; u32 dst_tmp = 0; // calculate offset 3..1..2 u32 offset = 4-src_alignment; u32 lshift = src_alignment<<3; u32 rshift = offset<<3; while(size32--) { dst_tmp = src_tmp << lshift; src_tmp = *src32++; dst_tmp|= src_tmp >> rshift; *dst32++ = BSWAP32(dst_tmp); } src32 -= offset; } #else u8* src8 = (u8*)src; u8* dst8 = (u8*)dst; while(bytes--) { *dst8++ = *(u8*)((uintptr_t)src8++ ^ U8_TWIDDLE); } #endif }
void EditorExportPlatformOSX::_make_icon(const Image& p_icon,Vector<uint8_t>& icon) { Ref<ImageTexture> it = memnew( ImageTexture ); int size=512; Vector<uint8_t> data; data.resize(8); data[0]='i'; data[1]='c'; data[2]='n'; data[3]='s'; const char *name[]={"ic09","ic08","ic07","icp6","icp5","icp4"}; int index=0; while(size>=16) { Image copy = p_icon; copy.convert(Image::FORMAT_RGBA); copy.resize(size,size); it->create_from_image(copy); String path = EditorSettings::get_singleton()->get_settings_path()+"/tmp/icon.png"; ResourceSaver::save(path,it); FileAccess *f = FileAccess::open(path,FileAccess::READ); ERR_FAIL_COND(!f); int ofs = data.size(); uint32_t len = f->get_len(); data.resize(data.size()+len+8); f->get_buffer(&data[ofs+8],len); memdelete(f); len+=8; len=BSWAP32(len); copymem(&data[ofs],name[index],4); encode_uint32(len,&data[ofs+4]); index++; size/=2; } uint32_t total_len = data.size(); total_len = BSWAP32(total_len); encode_uint32(total_len,&data[4]); icon=data; }
DEF_GAME_RECEIVE_COMMAND(Client, PACKET_SERVER_CHECK_NEWGRFS) { if (this->status != STATUS_JOIN) return NETWORK_RECV_STATUS_MALFORMED_PACKET; uint grf_count = p->Recv_uint8(); NetworkRecvStatus ret = NETWORK_RECV_STATUS_OKAY; /* Check all GRFs */ for (; grf_count > 0; grf_count--) { GRFIdentifier c; this->ReceiveGRFIdentifier(p, &c); /* Check whether we know this GRF */ const GRFConfig *f = FindGRFConfig(c.grfid, FGCM_EXACT, c.md5sum); if (f == NULL) { /* We do not know this GRF, bail out of initialization */ char buf[sizeof(c.md5sum) * 2 + 1]; md5sumToString(buf, lastof(buf), c.md5sum); DEBUG(grf, 0, "NewGRF %08X not found; checksum %s", BSWAP32(c.grfid), buf); ret = NETWORK_RECV_STATUS_NEWGRF_MISMATCH; } } if (ret == NETWORK_RECV_STATUS_OKAY) { /* Start receiving the map */ return SendNewGRFsOk(); } /* NewGRF mismatch, bail out */ _switch_mode_errorstr = STR_NETWORK_ERROR_NEWGRF_MISMATCH; return ret; }
static void global_user_list_cb (USER * user, struct guldata *data) { ASSERT (validate_user (user)); ASSERT (data != 0); if (data->flags) { /* selectively display users based on user level/muzzle/cloak */ if (! (((data->flags & ON_GFLAG_ADMIN) && user->level == LEVEL_ADMIN) || ((data->flags & ON_GFLAG_ELITE) && user->level == LEVEL_ELITE) || ((data->flags & ON_GFLAG_MODERATOR) && user->level == LEVEL_MODERATOR) || ((data->flags & ON_GFLAG_USERS) && user->level == LEVEL_USER) || ((data->flags & ON_GFLAG_LEECH) && user->level == LEVEL_LEECH) || ((data->flags & ON_GFLAG_MUZZLED) && user->muzzled) || ((data->flags & ON_GFLAG_CLOAKED) && user->cloaked) || ((data->flags & ON_GFLAG_USERIP) && (user->ip & data->mask) == (data->ip & data->mask)))) return; } if (data->server && *data->server != '*' && strcasecmp (data->server, user->server) != 0) return; /* no match */ send_cmd (data->con, MSG_SERVER_GLOBAL_USER_LIST, "%s %s", user->nick, my_ntoa (BSWAP32 (user->ip))); }
int DumpScan::process(DumpDataList::iterator startDump, unsigned long startByte) { unsigned long min = m_address - m_maxOffset; unsigned long max = m_address; if (m_maxOffset > m_address) min = 0; m_counter = 0; for (DumpDataList::iterator it = startDump; it!= m_dumps.end(); ++it) { char *data = (*it)->data; CHECK_CANCEL; for (unsigned long i=startByte; i<((*it)->header.end - (*it)->header.begin)-3; ++i) { unsigned long currentAddress = BSWAP32(*(unsigned long*)(&data[i])); CHECK_CANCEL; if ( currentAddress >= min && currentAddress <= max) //we want this { PointerOffsets po = m_offsets; po.push_front(m_address - currentAddress); m_results.push_back(ScanResult(i+(*it)->header.begin, po)); if (++m_counter >= m_maxResults) { m_counter = 0; m_currentDump = it; m_currentByte = i+1; return DUMP_SCAN_STATUS_CONTINUE; } } } } return DUMP_SCAN_STATUS_DONE; }
void cmd_page_erase() { int adrs=BSWAP32(PacketFromPC.adrs); if( check_flash_adrs(adrs)) { FLASH_ErasePage(adrs); } }
/******************************************************************** * FLASHのページ単位書き込み. (引数は書き込みadrsとsize) ******************************************************************** STM32では、word単位で書き込みが可能. (flush動作不要) 他のマイコン(LPCなど)では、 実際にはRAM上のページバッファにword単位でためておいて、 最後にsize=0を指定してページバッファを一発書き込みする実装になることもある. */ void cmd_page_write() { int *p = PacketFromPC.data; int i; int size = BSWAP16(PacketFromPC.size); int adr = BSWAP32(PacketFromPC.adrs); // ここでbyte数をword数に変換している. size = (size+3) >> 2; // size は4byte単位に限る. //#if defined(LPC1343)||defined(LPC2388) if(size==0) { // size が 0 のときは書き込みflush動作をする. FLASH_ProgramPage(adr); // これはSTM32に限り不要(ダミー関数) return ; } //#endif for(i=0; i<size; i++) { if( check_flash_adrs(adr) ) { FLASH_ProgramWord(adr, *p); // STM32では直接FLUSHに書く. } // 他のマイコンでは、ページバッファに記録. p++; adr+=4; } }
/******************************************************************** * 接続テストの返答 ******************************************************************** */ void cmd_echo(void) { int *fl_stat = (int*) &PacketToPC.rawint[2]; PacketToPC.raw[1]=DEVID; // PIC25/14K PacketToPC.raw[2]=VER_L; // version.L PacketToPC.raw[3]=VER_H; // version.H PacketToPC.raw[4]=DEV_LOADER; // bootloader PacketToPC.raw[5]=PacketFromPC.raw[1]; // ECHOBACK fl_stat[0] = BSWAP32(FLASH_END_ADR); fl_stat[1] = BSWAP32(search_flash_end(FLASH_END_ADR)); fl_stat[2] = BSWAP32(total_errs); total_errs=0; ToPcRdy = 1; }
void cmd_page_write() { int i; int size = BSWAP16(PacketFromPC.size); int adr = BSWAP32(PacketFromPC.adrs); int *p = PacketFromPC.data; size = (size+3) >> 2; #if defined(LPC1343)||defined(LPC2388) if(size==0) { FLASH_ProgramPage(adr); return ; } #endif if( size <= (48) ) { total_errs += flash_write(adr,size,p); return; } while(size>0) { int buf[64/4]; int len = size; if( len >= BLK_SIZE ) {len = BLK_SIZE;} USBgetpacket((uchar*)buf,len); total_errs += flash_write(adr, len ,buf); size -= len; adr += len; } }
void EditorExportPlatformOSX::_make_icon(const Ref<Image> &p_icon, Vector<uint8_t> &p_data) { Ref<ImageTexture> it = memnew(ImageTexture); int size = 512; Vector<uint8_t> data; data.resize(8); data[0] = 'i'; data[1] = 'c'; data[2] = 'n'; data[3] = 's'; const char *name[] = { "ic09", "ic08", "ic07", "icp6", "icp5", "icp4" }; int index = 0; while (size >= 16) { Ref<Image> copy = p_icon; // does this make sense? doesn't this just increase the reference count instead of making a copy? Do we even need a copy? copy->convert(Image::FORMAT_RGBA8); copy->resize(size, size); it->create_from_image(copy); String path = EditorSettings::get_singleton()->get_cache_dir().plus_file("icon.png"); ResourceSaver::save(path, it); FileAccess *f = FileAccess::open(path, FileAccess::READ); ERR_FAIL_COND(!f); int ofs = data.size(); uint32_t len = f->get_len(); data.resize(data.size() + len + 8); f->get_buffer(&data[ofs + 8], len); memdelete(f); len += 8; len = BSWAP32(len); copymem(&data[ofs], name[index], 4); encode_uint32(len, &data[ofs + 4]); index++; size /= 2; } uint32_t total_len = data.size(); total_len = BSWAP32(total_len); encode_uint32(total_len, &data[4]); p_data = data; }
static void byteswap_msg (ossmix_commad_packet_t * msg) { BSWAP32 (msg->cmd); BSWAP32 (msg->p1); BSWAP32 (msg->p2); BSWAP32 (msg->p3); BSWAP32 (msg->p4); BSWAP32 (msg->p5); BSWAP32 (msg->ack_rq); BSWAP32 (msg->unsolicited); BSWAP32 (msg->payload_size); }
static void try_connect (server_auth_t * auth) { int f; CONNECTION *cli; unsigned int ip; /* attempt a connection. we do this nonblocking so that the server doesn't halt if it takes a long time to connect */ f = make_tcp_connection (auth->name, auth->port, &ip); if (f == -1) return; cli = new_connection (); if (!cli) goto error; cli->fd = f; cli->host = STRDUP (auth->alias ? auth->alias : auth->name); if (!cli->host) { OUTOFMEMORY ("try_connect"); goto error; } cli->server_login = 1; if ((cli->opt.auth = CALLOC (1, sizeof (AUTH))) == 0) { OUTOFMEMORY ("try_connect"); goto error; } cli->opt.auth->nonce = generate_nonce (); if (!cli->opt.auth->nonce) { log_message ("try_connect: could not generate nonce, closing connection"); goto error; } cli->ip = BSWAP32 (ip); cli->port = auth->port; if (add_client (cli, 1/* server connection */)) goto error; return; error: log_message ("try_connect: closing connection"); if (cli) { CLOSE (cli->fd); if (cli->host) FREE (cli->host); if (cli->opt.auth) { if (cli->opt.auth->nonce) FREE (cli->opt.auth->nonce); FREE (cli->opt.auth); } FREE (cli); } }
void StreamPeer::put_32(int32_t p_val) { if (big_endian) { p_val = BSWAP32(p_val); } uint8_t buf[4]; encode_uint32(p_val, buf); put_data(buf, 4); }
int32_t StreamPeer::get_32() { uint8_t buf[4]; get_data(buf, 4); uint32_t r = decode_uint32(buf); if (big_endian) { r = BSWAP32(r); } return r; }
static inline void CopyLineSwap(void * dst, const void * src, u32 bytes) { u32* src32 = (u32*)src; u32* dst32 = (u32*)dst; #ifdef FAST_TMEM_COPY DAEDALUS_ASSERT((bytes&0x7)==0, "CopyLineSwap: Remaning bytes! (%d)",bytes); if( ((uintptr_t)src32&0x3 )==0) { u32 size64 = bytes >> 3; while (size64--) { dst32[0] = BSWAP32(src32[1]); dst32[1] = BSWAP32(src32[0]); dst32 += 2; src32 += 2; } }
float StreamPeer::get_float() { uint8_t buf[4]; get_data(buf, 4); if (big_endian) { uint32_t *p32 = (uint32_t *)buf; *p32 = BSWAP32(*p32); } return decode_float(buf); }
/******************************************************************** * データ引取りモードの設定 ******************************************************************** */ void cmd_set_mode(void) { poll_mode = BSWAP16( PacketFromPC.size ); poll_addr = (uchar *) BSWAP32( PacketFromPC.adrs ); if( poll_mode == POLL_ANALOG) { // mInitPOT(); // ADCON0bits.GO = 1; // Start AD conversion } make_report(); }
void StreamPeer::put_float(float p_val) { uint8_t buf[4]; encode_float(p_val, buf); if (big_endian) { uint32_t *p32 = (uint32_t *)buf; *p32 = BSWAP32(*p32); } put_data(buf, 4); }
/******************************************************************** * モニタコマンド受信と実行. ******************************************************************** */ void ProcessIO(void) { // 返答パケットが空であること、かつ、 // 処理対象の受信データがある. { //if((ToPcRdy == 0)) { //受信データがあれば、受信データを受け取る. PacketToPC.raw[0]=Cmd0; // CMD ECHOBACK #if APPLICATION_MODE #if PICAVR_WRITER //コマンドに対応する処理を呼び出す. if(Cmd0 >= HIDASP_PAGE_TX) {cmd_avrspx();} // AVRライターコマンド. else #endif if(Cmd0 >= PICSPX_SETADRS24){cmd_picspx();} // PICライターコマンド. else #endif switch(Cmd0) { case HIDASP_PEEK: {cmd_peek();break;} // メモリー読み出し. case HIDASP_POKE: {cmd_poke();break;} // メモリー書き込み. case HIDASP_JMP: {cmd_exec( BSWAP32(PacketFromPC.adrs),BSWAP16(PacketFromPC.size) ); break;} // 実行. case HIDASP_PAGE_ERASE:{cmd_page_erase();break;} //Flash消去. case HIDASP_PAGE_WRITE:{cmd_page_write();break;} //Flash書込. case HIDASP_FLASH_LOCK:{cmd_flash_lock();break;} //FlashLock. case HIDASP_SET_MODE: {cmd_set_mode();break;} case HIDASP_SAMPLING: {cmd_sampling();break;} case HIDASP_TEST: {cmd_echo();break;} // 接続テスト. #if APPLICATION_MODE case HIDASP_GET_STRING:{cmd_get_string();break;} case HIDASP_USER_CMD: {cmd_user_cmd();break;} #endif default: break; } } // 必要なら、返答パケットをインタラプト転送(EP1)でホストPCに返却する. if( ToPcRdy ) { USBputpacket(PacketToPC.raw,PACKET_SIZE); ToPcRdy = 0; if(poll_mode!=0) { if(mHIDRxIsBusy()) { //コマンドが来ない限り送り続ける. make_report(); } } } }
static void bswap_enuminfo (void *data, int len) { oss_mixer_enuminfo *ei = (oss_mixer_enuminfo *) data; int i; if (len != sizeof (*ei)) { fprintf (stderr, "bswap_enuminfo: Bad size (%d/%lu)\n", len, (unsigned long)sizeof (*ei)); exit (EXIT_FAILURE); } BSWAP32 (ei->dev); BSWAP32 (ei->ctrl); BSWAP32 (ei->nvalues); BSWAP32 (ei->version); for (i = 0; i < OSS_ENUM_MAXVALUE; i++) BSWAP32 (ei->strindex[i]); }
static void adjust_header(wtap *wth, struct pcaprec_hdr *hdr) { guint32 temp; libpcap_t *libpcap; libpcap = (libpcap_t *)wth->priv; if (libpcap->byte_swapped) { /* Byte-swap the record header fields. */ hdr->ts_sec = BSWAP32(hdr->ts_sec); hdr->ts_usec = BSWAP32(hdr->ts_usec); hdr->incl_len = BSWAP32(hdr->incl_len); hdr->orig_len = BSWAP32(hdr->orig_len); } /* Swap the "incl_len" and "orig_len" fields, if necessary. */ switch (libpcap->lengths_swapped) { case NOT_SWAPPED: break; case MAYBE_SWAPPED: if (hdr->incl_len <= hdr->orig_len) { /* * The captured length is <= the actual length, * so presumably they weren't swapped. */ break; } /* FALLTHROUGH */ case SWAPPED: temp = hdr->orig_len; hdr->orig_len = hdr->incl_len; hdr->incl_len = temp; break; } }
static int ieee1394_GetFetchAgentState(struct SBP2Device *dev){ unsigned long int FetchAgentState; int result; if((result=iLinkTrRead(dev->trContext, dev->CommandBlockAgent_high, dev->CommandBlockAgent_low, &FetchAgentState, 4))<0){ XPRINTF("Error reading the Fetch Agent's AGENT_STATE register @ 0x%08lx %08lx. Code: %d.\n", dev->CommandBlockAgent_high, dev->CommandBlockAgent_low, result); return -1; } else{ FetchAgentState=BSWAP32(FetchAgentState); XPRINTF("Fetch Agent state: %lu.\n", FetchAgentState); return FetchAgentState; } }
/******************************************************************** * メモリー読み出し ******************************************************************** */ void cmd_peek(void) { Packet *t = &PacketFromPC; int size = BSWAP16(t->size); int adrs = BSWAP32(t->adrs); int i,subcmd; uchar *pb; ushort *ph; uint *pw; uchar *tb; ushort *th; uint *tw; subcmd = t->subcmd; if(size > PACKET_SIZE) { cmd_peek_large_block(adrs,size); return; } switch(subcmd) { default: case MEM_BYTE: pb = (uchar *)adrs; tb = (uchar *)PacketToPC.raw; for(i=0; i<size; i++) { *tb++ = *pb++; } break; case MEM_HALF: ph = (ushort *)adrs; th = (ushort *)PacketToPC.rawint; for(i=0; i<size; i+=2) { *th++ = *ph++; } break; case MEM_WORD: pw = (uint *)adrs; tw = (uint *)PacketToPC.rawint; for(i=0; i<size; i+=4) { *tw++ = *pw++; } break; } USBputpacket(PacketToPC.raw,PACKET_SIZE); // ToPcRdy = 1; }
static void bswap_int_array (void *data, int len) { int *arr = (int *) data; int i; if (len % sizeof (int) != 0) { fprintf (stderr, "bswap_int_array: Bad size %d\n", len); exit (EXIT_FAILURE); } for (i = 0; i < len / sizeof (int); i++) BSWAP32 (arr[i]); }
static void i4b_byte_swap_header(wtap *wth, i4b_trace_hdr_t *hdr) { i4btrace_t *i4btrace = (i4btrace_t *)wth->priv; if (i4btrace->byte_swapped) { /* * Byte-swap the header. */ hdr->length = BSWAP32(hdr->length); hdr->unit = BSWAP32(hdr->unit); hdr->type = BSWAP32(hdr->type); hdr->dir = BSWAP32(hdr->dir); hdr->trunc = BSWAP32(hdr->trunc); hdr->count = BSWAP32(hdr->count); hdr->ts_sec = BSWAP32(hdr->ts_sec); hdr->ts_usec = BSWAP32(hdr->ts_usec); } }
void EMU_FASTCALL GX_Fifo_Write32(u32 addr, u32 data) { static u8 cmd = FIFO_GET8(0); *(u32*)(gp::g_fifo_buffer + gp::g_fifo_write_ptr) = BSWAP32(data); gp::g_fifo_write_ptr += 4; /*if ((data == 0x45000002) && ((cmd & 0xf8) == 0x60)) { while (!gp::g_frame_finished) { } gp::g_frame_finished = 0; GX_PE_FINISH = 1; PE_Update(); }*/ if (!common::g_config->enable_multicore()) { gp::Fifo_DecodeCommand(); } }
/******************************************************************** * メモリー書き込み ******************************************************************** */ void cmd_poke(void) { Packet *t = &PacketFromPC; int size = BSWAP16(t->size); int adrs = BSWAP32(t->adrs); int i,subcmd; uchar *pb; ushort *ph; uint *pw; uchar *sb; ushort *sh; uint *sw; subcmd = t->subcmd; switch(subcmd) { default: case MEM_BYTE: pb = (uchar *)adrs; sb = (uchar *)t->data; for(i=0; i<size; i++) { *pb++ = *sb++; } break; case MEM_HALF: ph = (ushort *)adrs; sh = (ushort *)t->data; for(i=0; i<size; i+=2) { *ph++ = *sh++; } break; case MEM_WORD: pw = (uint *)adrs; sw = (uint *)t->data; for(i=0; i<size; i+=4) { *pw++ = *sw++; } break; } }