void
IT_REGSERVERDOC (ENV *envp, LONGPROC f)
{
LHSERVER lhHandle;
LPSTR lpString1;
LPOLESERVERDOC lpdoc;
LPBYTE lpStr;
LHSERVERDOC lhdoc;
DWORD retcode;
lhHandle = (LHSERVER)GETDWORD(SP+16);
lpString1 = (LPSTR)GetAddress(GETWORD(SP+14),GETWORD(SP+12));
#ifdef LATER
translate the LPOLESERVERDOC and the structures behind it
#endif
lpdoc = (LPOLESERVERDOC)GETDWORD(SP+8);
lpStr = (LPBYTE)GetAddress(GETWORD(SP+6),GETWORD(SP+4));
retcode = OleRegisterServerDoc(lhHandle,
lpString1,
lpdoc,
&lhdoc);
PUTDWORD(lpStr,lhdoc);
envp->reg.sp += 2*DWORD_86 + 2*LP_86 + RET_86;
envp->reg.ax = LOWORD(retcode);
envp->reg.dx = HIWORD(retcode);
}
void
IT_LOADACCEL (ENV *envp,LONGPROC f)
{
LPSTR lpString;
HGLOBAL hGlobal;
WORD wSel = 0;
MEMORYINFO *lpMemory;
HINSTANCE hInst;
lpString = (LPSTR)GetAddress(GETWORD(SP+6),GETWORD(SP+4));
hInst = GetSelectorHandle(GETWORD(SP+8));
hGlobal = (f)((HANDLE) hInst,lpString);
if (hGlobal && (lpMemory = GETHANDLEINFO(hGlobal))) {
if (lpMemory->lpData == NULL)
lpMemory->lpData = (LPSTR)ConvertResourceToBin
((LPBYTE)lpMemory->lpCore,lpMemory->wIndex);
if (lpMemory->lpData) {
wSel = AssignSelector((LPBYTE)lpMemory->lpData + 4,0,
TRANSFER_DATA,lpMemory->dwBinSize);
SetSelectorHandle(wSel,hGlobal);
}
}
envp->reg.ax = wSel & 0xfffe;
envp->reg.dx = 0;
envp->reg.sp += HANDLE_86 + LP_86 + RET_86;
if (lpMemory)
RELEASEHANDLEINFO(lpMemory);
}
void
IT_WINEXEC (ENV *envp,LONGPROC f)
{
char buf[0x100];
LPSTR lpCmdLine,lpTemp;
LPSTR lpString;
DWORD retcode;
lpCmdLine = (LPSTR)GetAddress(GETWORD(SP+8),GETWORD(SP+6));
if (!lpCmdLine || !strlen(lpCmdLine))
retcode = 0;
else {
lpString = (LPSTR)WinStrdup(lpCmdLine);
lpTemp = strchr(lpString,' ');
if (lpTemp)
*lpTemp = '\0';
xdoscall(XDOS_GETALTNAME,0,(void *) buf,(void *) lpString);
if (strlen(buf) == 0)
strcpy(buf,lpString);
if (lpTemp) {
strcat(buf," ");
strcat(buf,++lpTemp);
}
retcode = (DWORD)WinExec(buf,(UINT)GETWORD(SP+4));
WinFree(lpString);
}
if (retcode > 32)
retcode = GetDataSelectorFromInstance(retcode);
envp->reg.ax = LOWORD(retcode);
envp->reg.dx = HIWORD(retcode);
envp->reg.sp += LP_86 + UINT_86 + RET_86;
}
void
IT_SIZEOFRESOURCE (ENV *envp,LONGPROC f)
{
DWORD retcode;
HINSTANCE hInst;
HRSRC hrsrc;
NAMEINFO *lpni = NULL;
MEMORYINFO *lpMemory;
hInst = (HINSTANCE)GetSelectorHandle(GETWORD(SP+6));
hrsrc = (HRSRC)GETWORD(SP+4);
lpMemory = GETHANDLEINFO(hrsrc);
if (lpMemory)
lpni = (NAMEINFO *)lpMemory->lpCore;
if (lpni) {
if (lpni->hGlobal) {
lpMemory = GETHANDLEINFO(lpni->hGlobal);
if (lpMemory && lpMemory->wType)
retcode = lpMemory->dwBinSize;
else
retcode = lpni->rcslength;
}
else
retcode = lpni->rcslength;
}
else
retcode = 0L;
envp->reg.ax = LOWORD(retcode);
envp->reg.dx = HIWORD(retcode);
envp->reg.sp += 2*HANDLE_86 + RET_86;
if (lpMemory)
RELEASEHANDLEINFO(lpMemory);
}
/**
* \brief This function loads some constants, this normally happens when the game is loaded
* and the values change depending on what is read for the mods
*/
void CPhysicsSettings::loadGameConstants(int episode, byte* data)
{
if(episode >= 4 && episode <= 6 )
{
// Galaxy Engine
fallspeed_increase = 7;
max_fallspeed = 175; // Factor 2.5 to the original assembly it is
misc.visibility = 7;
}
else
{
// Vorticon Engine
misc.visibility = 3;
fallspeed_increase = 4;
max_fallspeed = 104;
if(episode == 1)
{ // Code for Episode 1.
// player
byte pogo = *(data+0x900E);
player.pogostickonstart = pogo;
player.start_with_shots = *(data+0x9008);
// vorticon
vorticon.default_hp = *(data+0x180D)+1;
vorticon.commander_hp = *(data+0x1819)+1;
// tank bot
tankbot.shot_height_from_top = *(data+0x4900);
misc.ctspace_ammo = GETWORD(data+0xE03);
misc.ctspace_keys = GETWORD(data+0xE11);
misc.one_eyed_tile = GETWORD(data+0x4547);
misc.joy_tile = GETWORD(data+0x992A);
misc.bat_tile = GETWORD(data+0x995D);
misc.vac_tile = GETWORD(data+0x9990);
misc.wsk_tile = GETWORD(data+0x99C3);
misc.raygun_tile = GETWORD(data+0x1166);
misc.pogo_tile = GETWORD(data+0x11A7);
misc.changestoneblock = GETWORD(data+0x2414);
// TODO: ... More stuff will come here
}
else if(episode == 2)
{ // Code for Episode 2.
player.pogostickonstart = true;
player.start_with_shots = *(data+0x8AA2);
// TODO: ... More stuff will come here
}
else if(episode == 3)
{ // Code for Episode 3.
player.pogostickonstart = true;
player.start_with_shots = 5;
// TODO: ... More stuff will come here
}
}
}
static const char *config_access(struct access **ls)
{
struct access *l;
GETOPEN();
while (NOTCLOSE()) {
REQWORD();
MAKE(l, struct access);
l->next = *ls;
*ls = l;
if (strceq(tokbuf, c_allow))
l->type = ALLOW;
else if (strceq(tokbuf, c_deny))
l->type = DENY;
else if (strceq(tokbuf, c_apply))
l->type = APPLY;
else
return e_keyword;
GETWORD();
if (*tokbuf == '*')
l->mask = l->addr = 0;
else {
if (strceq(tokbuf, c_exact))
l->mask = (unsigned long) -1;
else if ((l->mask = inet_addr(tokbuf))
== (unsigned long) -1)
return e_bad_addr;
GETWORD();
if ((l->addr = inet_addr(tokbuf))
== (unsigned long) -1)
return e_bad_addr;
}
}
return 0;
}
void
IT_GLOBALFREE (ENV *envp,LONGPROC f)
{
DWORD retcode;
WORD wSel;
HGLOBAL hGlobal;
wSel = GETWORD(SP+4) | 1;
if (wSel == 1)
{
envp->reg.sp += HANDLE_86 + RET_86;
envp->reg.ax = GETWORD(SP+4);
envp->reg.dx = 0;
return;
}
hGlobal = GetSelectorHandle(wSel);
ZapSegRegs(envp,wSel);
/* for HUGE objects */
while ((GetSelectorHandle((UINT)(wSel-8))==hGlobal))
wSel -= 8;
while (GetSelectorHandle(wSel) == hGlobal) {
FreeSelector(wSel);
wSel += 8;
}
retcode = (f)(hGlobal);
envp->reg.sp += HANDLE_86 + RET_86;
envp->reg.ax = LOWORD(retcode);
envp->reg.dx = HIWORD(retcode);
}
void
IT_COPYMETAFILE(ENV *envp,LONGPROC f)
{
char buf[0x100];
WORD wSel;
HGLOBAL hGlobal;
LPSTR lpszFile;
LPBYTE lpData;
wSel = GETWORD(SP+8);
hGlobal = GetSelectorHandle(wSel);
lpszFile = GetAddress(GETWORD(SP+6),GETWORD(SP+4));
if (lpszFile && strchr(lpszFile,'\\')) {
xdoscall(XDOS_GETALTNAME,0,(void *) buf,(void *) lpszFile); lpszFile = buf;
}
hGlobal = CopyMetaFile(hGlobal,lpszFile);
if (hGlobal) {
lpData = (LPBYTE)GlobalLock(hGlobal);
wSel = AssignSelector(lpData,0,TRANSFER_DATA,
GlobalSize(hGlobal));
SetSelectorHandle(wSel,hGlobal);
GlobalUnlock(hGlobal);
}
else
wSel = 0;
envp->reg.sp += HANDLE_86 + LP_86 + RET_86;
envp->reg.ax = wSel & 0xfffe;
envp->reg.dx = 0;
}
int h3600_micro_asset_read( struct h3600_asset *asset )
{
unsigned char buf[2];
int retval = -1; // TODO: fix this to "no such asset"
if (0) printk("%s (%d)\n", __FUNCTION__, asset->type);
switch (asset->type) {
case ASSET_HM_VERSION:
retval = h3600_micro_eeprom_read( 0, asset->a.tchar, 10 );
break;
case ASSET_SERIAL_NUMBER:
retval = h3600_micro_eeprom_read( 10, asset->a.tchar, 40 );
break;
case ASSET_MODULE_ID:
retval = h3600_micro_eeprom_read( 50, asset->a.tchar, 20 );
break;
case ASSET_PRODUCT_REVISION:
retval = h3600_micro_eeprom_read( 70, asset->a.tchar, 10 );
break;
case ASSET_PRODUCT_ID:
retval = h3600_micro_eeprom_read( 80, buf, 2 );
asset->a.vshort = GETWORD(buf);
break;
case ASSET_FRAME_RATE:
retval = h3600_micro_eeprom_read( 82, buf, 2 );
asset->a.vshort = GETWORD(buf);
break;
case ASSET_PAGE_MODE:
retval = h3600_micro_eeprom_read( 84, buf, 2 );
asset->a.vshort = GETWORD(buf);
break;
case ASSET_COUNTRY_ID:
retval = h3600_micro_eeprom_read( 86, buf, 2 );
asset->a.vshort = GETWORD(buf);
break;
case ASSET_IS_COLOR_DISPLAY:
retval = h3600_micro_eeprom_read( 88, buf, 2 );
asset->a.vshort = GETWORD(buf);
break;
case ASSET_ROM_SIZE:
retval = h3600_micro_eeprom_read( 90, buf, 2 );
asset->a.vshort = GETWORD(buf);
break;
case ASSET_RAM_SIZE:
retval = h3600_micro_eeprom_read( 92, buf, 2 );
asset->a.vshort = GETWORD(buf);
break;
case ASSET_HORIZONTAL_PIXELS:
retval = h3600_micro_eeprom_read( 94, buf, 2 );
asset->a.vshort = GETWORD(buf);
break;
case ASSET_VERTICAL_PIXELS:
retval = h3600_micro_eeprom_read( 96, buf, 2 );
asset->a.vshort = GETWORD(buf);
break;
}
return retval;
}
void
IT_ISBADCODEPTR (ENV *envp,LONGPROC f)
{
DWORD retcode;
LPSTR lpString;
lpString = MAKELP(GETWORD(SP+8),GETWORD(SP+6));
retcode = (f)(lpString,0);
envp->reg.sp += LP_86 + RET_86;
envp->reg.ax = LOWORD(retcode);
envp->reg.dx = HIWORD(retcode);
}
void
IT_LOCALREALLOC (ENV *envp,LONGPROC f) /* TWIN_LocalReAlloc */
{
DWORD retcode;
retcode = TWIN_LocalReAlloc((HANDLE)GETWORD(SP+8),
(UINT)GETWORD(SP+6),
(UINT)GETWORD(SP+4));
envp->reg.sp += HANDLE_86 + 2*UINT_86 + RET_86;
envp->reg.ax = LOWORD(retcode);
envp->reg.dx = HIWORD(retcode);
}
void
IT_ACCESSRESOURCE (ENV *envp,LONGPROC f)
{
DWORD retcode;
retcode = (DWORD)AccessResourceBin(
(HINSTANCE)GetSelectorHandle(GETWORD(SP+6)),
(HRSRC)GETWORD(SP+4));
envp->reg.ax = LOWORD(retcode);
envp->reg.dx = HIWORD(retcode);
envp->reg.sp += 2*HANDLE_86 + RET_86;
}
void
IT_OLEENUMOBJ(ENV *envp,LONGPROC f)
{
DWORD retcode;
LPBYTE lp1;
lp1 = (LPBYTE)GetAddress(GETWORD(SP+6),GETWORD(SP+4));
retcode = OleEnumObjects((LHCLIENTDOC)GETDWORD(SP+8),
(LPOLEOBJECT *)lp1);
envp->reg.sp += LP_86 + LONG_86 + RET_86;
envp->reg.ax = LOWORD(retcode);
envp->reg.dx = HIWORD(retcode);
}
void
IT_LOCALALLOC (ENV *envp,LONGPROC f) /* TWIN_LocalAlloc */
{
DWORD retcode;
if (envp != envp_global)
envp_global = envp;
retcode = TWIN_LocalAlloc((UINT)GETWORD(SP+6),
(UINT)GETWORD(SP+4));
envp->reg.sp += 2*UINT_86 + RET_86;
envp->reg.ax = LOWORD(retcode);
envp->reg.dx = HIWORD(retcode);
}
void
IT_PLAYMETAFILE(ENV *envp,LONGPROC f)
{
HDC hDC;
WORD wSel;
HGLOBAL hGlobal;
hDC = GETWORD(SP+6);
wSel = GETWORD(SP+4);
hGlobal = GetSelectorHandle(wSel);
envp->reg.ax = PlayMetaFile(hDC, hGlobal);
envp->reg.sp += 2 * HANDLE_86 + RET_86;
}
void
IT_LOCALINIT (ENV *envp,LONGPROC f) /* TWIN_LocalInit */
{
DWORD retcode;
UINT seg;
seg = (UINT)GETWORD(SP+8);
if (!seg)
seg = envp->reg.ds;
retcode = TWIN_LocalInit(seg, (UINT)GETWORD(SP+6),
(UINT)GETWORD(SP+4));
envp->reg.sp += 3*UINT_86 + RET_86;
envp->reg.ax = LOWORD(retcode);
envp->reg.dx = HIWORD(retcode);
}
void
IT_UNBLOCKSERVER (ENV *envp,LONGPROC f) /* OleUnblockServer */
{
DWORD retcode;
LPBYTE lpData;
BOOL flag;
lpData = (LPBYTE)GetAddress(GETWORD(SP+6),GETWORD(SP+4));
flag = (BOOL)GETWORD(lpData);
retcode = (f)((LHSERVER)GETDWORD(SP+8),&flag);
PUTWORD(lpData,(WORD)flag);
envp->reg.sp += LONG_86 + LP_86 + RET_86;
envp->reg.ax = LOWORD(retcode);
envp->reg.dx = HIWORD(retcode);
}
void
_86_GlobalHandle (ENV *envp,LONGPROC f)
{
DWORD retcode;
WORD wSel;
HGLOBAL hGlobal;
MEMORYINFO *lpMemory = NULL;
wSel = GETWORD(SP+4);
hGlobal = GetSelectorHandle(wSel);
if (hGlobal && (lpMemory = GETHANDLEINFO(hGlobal))) {
if (!(lpMemory->wFlags & GMEM_MOVEABLE))
wSel |= 1;
else
wSel &= 0xfffe;
}
else
wSel &= 0xfffe;
retcode = MAKELONG(wSel,wSel | 1);
envp->reg.sp += WORD_86 + RET_86;
envp->reg.ax = LOWORD(retcode);
envp->reg.dx = HIWORD(retcode);
if (lpMemory != NULL)
RELEASEHANDLEINFO(lpMemory);
}
// Messenger Chat
bool CCharServer::pakMessengerChat ( CCharClient* thisclient, CPacket* P )
{
WORD id = GETWORD((*P),0);
char* message = new char[P->Size-41];
if(message==NULL)
{
Log(MSG_ERROR, "Error allocing memory: pakMessengerChat" );
return false;
}
memcpy( message, &P->Buffer[35], P->Size-41 );
CCharClient* otherclient = (CCharClient*) GetClientByID(id);
if(otherclient!=NULL)
{
BEGINPACKET( pak, 0x7e2 );
ADDWORD ( pak, thisclient->charid );
ADDWORD ( pak, 0x0000 );
ADDSTRING ( pak, thisclient->charname );
UINT namesize = strlen(thisclient->charname);
for (int i=0;i<30-namesize;i++)
ADDBYTE ( pak, 0x00 );
ADDBYTE ( pak, 0x00 );
ADDSTRING ( pak, message );
ADDBYTE ( pak, 0x00 );
otherclient->SendPacket(&pak);
}
delete []message;
return true;
}
int xreloc_relocate( xreloc xr ) {
table *t = (table *) xr;
int loc;
int word;
int mask;
int err = 0;
symbol *sym;
symbol *rel = NULL;
reloc *r;
rel = findsym( t, REL_NAME );
rel->flags = FLAG_RELOCAT | FLAG_GLOBAL;
rel->loc = 0;
for( sym = t->syms; sym; sym = sym->next ) {
if( sym->flags & FLAG_GLOBAL ) { /* symbols to be written to symbol table */
continue;
} else if( sym->flags & FLAG_RELOCAT ) { /* symbols need to be relocated */
sym->flags |= FLAG_WRITTEN;
for( r = sym->relocs; r; r = r->next ) {
add_reloc( t, rel, r->loc, r->size, XRELOC_ABSOLUTE );
word = GETWORD( t->mem, r->loc );
mask = ( 1 << r->size ) - 1;
loc = ( word & mask ) + sym->loc;
if( loc & ~mask ) {
fprintf( t->err, "error: relocation out of range for symbol '%s'\n",
sym->name );
err = 1;
}
word = ( word & ~mask ) | ( loc & mask );
t->mem[r->loc] = word >> 8;
t->mem[r->loc + 1] = word;
}
} else if( sym->loc != INV_ADDR ) { /* symbol is defined */
uint64_t archive_fetch_data(int fd, int size)
{
unsigned char data[8] = { 0 };
uint64_t val = 0;
if (read(fd, data, size) != size) {
DPRINTF("Invalid data block\n");
return (uint64_t)-1;
}
switch (size) {
case 1: val = GETBYTE(data);
break;
case 2: val = GETWORD(data);
break;
case 4: val = GETUINT32(data);
break;
case 8: val = GETUINT64(data);
break;
default:val = (uint64_t)-1;
DPRINTF("Cannot get %d bytes: Not implemented\n", size);
break;
}
return val;
}
/*
** A "local" function of ProcessRequest(). Adds an entry for #object# in the
** registration file indicating that it expires at #expiration#.
*/
static void
DoRegister(const char *object,
unsigned long expiration) {
char expirationImage[15 + 1];
const char *existing;
const char *registration;
/*
** Overwrite any existing expiration. This minimizes the size of the
** registration file and simplifies searches.
*/
for(rewind(registrationFile); (registration = ReadRegistration()) != NULL;) {
(void)GETWORD(expirationImage, registration, &existing);
existing++; /* Skip space after expiration. */
if(strcmp(object, existing) == 0) {
fseek(registrationFile, -strlen(registration) - 1, SEEK_CUR);
fprintf(registrationFile, EXPIRATION_FORMAT, expiration);
return;
}
}
fprintf(registrationFile, EXPIRATION_FORMAT, expiration);
fprintf(registrationFile, " %s\n", object);
}
/*
** A "local" function of ProcessRequest(). Searches through the registration
** file for unexpired objects that match #filter#. Returns a malloc'ed string
** of the matching objects.
*/
static char *
DoSearch(const char *filter) {
unsigned long expiration;
char expirationImage[15 + 1];
unsigned long now;
const char *object;
const char *registration;
char *returnValue;
now = (unsigned long)CurrentTime();
returnValue = strdup("");
for(rewind(registrationFile); (registration = ReadRegistration()) != NULL;) {
(void)GETWORD(expirationImage, registration, &object);
expiration = atol(expirationImage);
if((expiration == ETERNAL) || (expiration > now)) {
object++; /* Skip space after expiration. */
if(MatchFilter(object, filter)) {
returnValue =
REALLOC(returnValue, strlen(returnValue) + strlen(object) + 1);
strcat(returnValue, object);
}
}
}
return returnValue;
}
/*
** A "local" function of main(). Deletes from the registration file all
** objects that have an expiration time which has already passed.
*/
static void
CompressRegistrations(void) {
size_t bytesCompressed = 0;
unsigned long expiration;
char expirationImage[15 + 1];
const char *ignored;
unsigned long now;
size_t recordLen;
const char *registration;
now = (unsigned long)CurrentTime();
for(rewind(registrationFile); (registration = ReadRegistration()) != NULL;) {
(void)GETWORD(expirationImage, registration, &ignored);
expiration = atol(expirationImage);
recordLen = strlen(registration) + 1;
if((expiration != ETERNAL) && (expiration <= now)) {
bytesCompressed += recordLen;
}
else if(bytesCompressed > 0) {
/* Move this record forward to the end of the still-current objects. */
fseek(registrationFile, -(recordLen + bytesCompressed), SEEK_CUR);
fprintf(registrationFile, "%s\n", registration);
fseek(registrationFile, bytesCompressed, SEEK_CUR);
}
}
/* Truncate any records that we've moved. */
if(bytesCompressed > 0) {
fseek(registrationFile, -bytesCompressed, SEEK_CUR);
ftruncate(fileno(registrationFile), ftell(registrationFile));
}
}
void
IT_GETCLIPBDATA (ENV *envp,LONGPROC f)
{
WORD wSel;
HGLOBAL hGlobal;
MEMORYINFO *lpMemory;
UINT uiFormat = GETWORD(SP+4);
hGlobal = (DWORD)(f)(uiFormat);
if (uiFormat == CF_BITMAP)
envp->reg.ax = hGlobal;
else {
if (hGlobal) {
lpMemory = GETHANDLEINFO(hGlobal);
if (lpMemory) {
wSel = AssignSelector((LPBYTE)lpMemory->lpCore,0,
TRANSFER_DATA,lpMemory->dwSize);
SetSelectorHandle(wSel,hGlobal);
envp->reg.ax = wSel & 0xfffe;
}
else
envp->reg.ax = 0;
}
else
envp->reg.ax = 0;
}
envp->reg.dx = 0;
envp->reg.sp += UINT_86 + RET_86;
if (lpMemory)
RELEASEHANDLEINFO(lpMemory);
}
void CJpegParse::ParseExif(unsigned char* ptr, PTThumbNail pthumbinfo)
{
UINT32 i = 0;
UINT16 byteOrder;
UINT32 ifdOffset;
byteOrder = GETWORD(ptr, i);
i += 2;
if(byteOrder == 0x4949)
pthumbinfo->byteOrder = EXIF_BYTE_ORDER_INTEL;
else if(byteOrder == 0x4D4D)
pthumbinfo->byteOrder = EXIF_BYTE_ORDER_MOTOROLA;
else
return;
i += 2; //skip '2A00'
ifdOffset = ExifGetDword(ptr+i, pthumbinfo->byteOrder);
ifdOffset = GetIFD0(ptr, ifdOffset, pthumbinfo);
if(ifdOffset != 0)
ifdOffset = GetIFD1(ptr, ifdOffset, pthumbinfo);
}
unsigned short CJpegParse::GetDQT(PTJpegIndex pinfo, unsigned char* ptr)
{
unsigned short len, i = 0;
unsigned char n;
len = GETWORD(ptr,0);
i += 2;
while(i < len)
{
if(ptr[i] & 0xf0) //16 bit precision
{
n = ptr[i] & 0xf;
if(n > 3)
return 0;
pinfo->QTPrecision[n] = 16;
pinfo->QT[n] = ptr+i+1;
i += 1 + (64 << 1);
}
else //8 bit precision
{
n = ptr[i] & 0xf;
if(n > 3)
return 0;
pinfo->QTPrecision[n] = 8;
pinfo->QT[n] = ptr+i+1;
i += 1 + 64;
}
pinfo->QTCount++;
}
return len;
}
bool CCharServer::pakUpdateLevel( CCharClient* thisclient, CPacket* P )
{
if(!thisclient->isLoggedIn) return false;
WORD charid = GETWORD((*P),0);
WORD level = GETWORD((*P),2);
for(UINT i=0;i<ClientList.size();i++)
{
CCharClient* player = (CCharClient*) ClientList.at(i);
if(player->charid==charid)
{
player->level = level;
break;
}
}
return true;
}
unsigned short CJpegParse::GetDHT(PTJpegIndex pinfo, unsigned char* ptr)
{
unsigned short len, j, n, k, HTLen;
unsigned char *pd = ptr+2;
// int tablen[4] = {0x1c, 0xb2, 0x1c, 0xb2};
j = 0;
len = GETWORD(ptr,0);
while(j < len-3)
{
HTLen = 0;
n = pd[j] & 0xf;
k = pd[j] & 0xf0;
n <<= 1;
n += k >> 4;
if(n > 3)
return 0;
j++;
pinfo->HT[n] = pd+j;
k = j + 16;
while(j < k)
{
HTLen = HTLen + (unsigned short)(pd[j]);
j++;
}
pinfo->HTLen[n] = (unsigned char)(16 + HTLen);
// if (pinfo->HTLen[n] != tablen[n])
// return 0;
j = j+HTLen;
pinfo->HTCount++;
}
return len;
}
unsigned short CJpegParse::GetSOS(PTJpegIndex pinfo, unsigned char* ptr)
{
unsigned short len;
unsigned char i, k, n, ac, dc, count, *pbuf = ptr+3;
len = GETWORD(ptr,0);
count = ptr[2];
if(len != 6 + (count << 1))
return 0;
for(i = 0; i < count; i++)
{
k = i << 1;
n = pbuf[k]-1;
if(n > 3)
return 0;
ac = pbuf[k+1] & 0xf;
dc = pbuf[k+1] & 0xf0;
if(!ac)
pinfo->Comp[n] |= 0x2;
if(!dc)
pinfo->Comp[n] |= 0x1;
}
return len;
}
