short xlw::XlfOper4::AsShort(const std::string& ErrorId, int * pxlret) const
{
short s;
int xlret = ConvertToShort(s);
if (pxlret)
*pxlret=xlret;
else
ThrowOnError(xlret,ErrorId+" conversion to short failed");
return s;
};
short xlw::XlfOper4::AsShort(int * pxlret) const
{
short s;
int xlret = ConvertToShort(s);
if (pxlret)
*pxlret=xlret;
else
ThrowOnError(xlret);
return s;
};
int ConvertReadShort(int fp,int16 *val) {
unsigned char tmp[2];
int s=0,o=0,l=2;
while (o<2) {
s=read(fp,tmp+o,l);
o=o+s;
l=l-s;
if (s==0) return -1;
if (s==-1) return -1;
}
ConvertToShort(tmp,val);
return 0;
}
DWORD Controller::GetState(XINPUT_STATE* pState)
{
// Passthrough?
if (m_passthrough)
return XInputModuleManager::Get().XInputGetState(m_passthroughindex, pState);
if (!ControllerManager::Get().XInputEnabled())
{
// Clear state
if (pState) ZeroMemory(pState, sizeof(XINPUT_STATE));
return ERROR_SUCCESS;
}
// If state haven't changed yet then...
HRESULT hr = UpdateState();
#if 0
PrintLog("UpdateState %u %u", dwUserIndex, hr);
#endif
if (FAILED(hr)) return
ERROR_DEVICE_NOT_CONNECTED;
pState->Gamepad.wButtons = 0;
pState->Gamepad.bLeftTrigger = 0;
pState->Gamepad.bRightTrigger = 0;
pState->Gamepad.sThumbLX = 0;
pState->Gamepad.sThumbLY = 0;
pState->Gamepad.sThumbRX = 0;
pState->Gamepad.sThumbRY = 0;
// timestamp packet
pState->dwPacketNumber = GetTickCount();
if (m_stateChanged != true)
{
// If first state is not aquired yet.
if (m_emptyStateIsSet != true)
{
m_emptyState = m_state;
m_emptyStateIsSet = true;
}
// Compare two states.
int compareResult = memcmp(&m_emptyState, &m_state, sizeof(struct DIJOYSTATE2));
// If nothing changed then...
if (compareResult == 0)
{
// Return.
return ERROR_SUCCESS;
}
else
{
// Allow to use values.
m_stateChanged = true;
}
}
bool dPadButtons[16];
for (int i = 0; i < _countof(dPadButtons); ++i) dPadButtons[i] = false;
// Loop trough D-Pad button states.
for (int d = 0; d < _countof(m_state.rgdwPOV); ++d)
{
// No more than 4 D-Pads.
if (d >= 4) break;
int povdeg = m_state.rgdwPOV[d];
if (povdeg >= 0)
{
// Split PoV degrees into 8 groups by
// converting PoV degree from 0 to 36000 to number from 0 to 7.
// This will allow to have more flexible degree values mapped to buttons.
s8 y = ((2250 + povdeg) / 4500) % 8;
// XINPUT_GAMEPAD_DPAD_UP
dPadButtons[d * 4 + 0] = (y >= 0 && y <= 1) || y == 7;
// XINPUT_GAMEPAD_DPAD_RIGHT
dPadButtons[d * 4 + 1] = (y >= 1 && y <= 3);
// XINPUT_GAMEPAD_DPAD_DOWN
dPadButtons[d * 4 + 2] = (y >= 3 && y <= 5);
// XINPUT_GAMEPAD_DPAD_LEFT
dPadButtons[d * 4 + 3] = (y >= 5 && y <= 7);
}
}
// --- Map POV to the D-pad ---
if (m_mapping.DpadPOV > 0 && m_mapping.PovIsButton == false)
{
//INT pov = POVState(m_mapping.DpadPOV,dwUserIndex,Gamepad[dwUserIndex].povrotation);
s8 dPadIndex = m_mapping.DpadPOV - 1;
if (dPadButtons[dPadIndex * 4 + 0]) pState->Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_UP;
if (dPadButtons[dPadIndex * 4 + 1]) pState->Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_RIGHT;
if (dPadButtons[dPadIndex * 4 + 2]) pState->Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_DOWN;
if (dPadButtons[dPadIndex * 4 + 3]) pState->Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_LEFT;
}
//else if (m_mapping.DpadPOV > 0 && m_mapping.PovIsButton == true)
//{
// for (int i = 0; i < _countof(m_mapping.pov); ++i)
// {
// if (ButtonPressed(m_mapping.pov[i]))
// {
// pState->Gamepad.wButtons |= Config::povIDs[i];
// }
// }
//}
// Created so we can refer to each axis with an ID
s32 axis[] =
{
m_state.lX,
m_state.lY,
m_state.lZ,
m_state.lRx,
m_state.lRy,
m_state.lRz
};
s32 slider[] =
{
m_state.rglSlider[0],
m_state.rglSlider[1]
};
// --- Map buttons ---
if (ButtonPressed(m_mapping.guide))
pState->Gamepad.wButtons |= 0x400;
for (u32 i = 0; i < _countof(m_mapping.Button); ++i)
{
s8 mapId = m_mapping.Button[i].id;
// Skip invalid mappings
if (mapId == 0)
continue;
u32 mapIndex = std::abs(mapId) - 1;
Config::MappingType buttonType = m_mapping.Button[i].type;
if (buttonType == Config::DIGITAL)
{
if (ButtonPressed(mapId - 1))
pState->Gamepad.wButtons |= Config::buttonIDs[i];
}
// D-Pad button to normal button.
else if (buttonType == Config::DPADBUTTON)
{
if (mapIndex < _countof(dPadButtons) && dPadButtons[mapIndex])
pState->Gamepad.wButtons |= Config::buttonIDs[i];
}
else
{
s32 *values;
bool isRange = false;
bool isHalf = false;
switch (buttonType)
{
case Config::AXIS:
case Config::HAXIS:
case Config::CBUT:
values = axis;
break;
case Config::SLIDER:
case Config::HSLIDER:
values = slider;
break;
default:
values = axis;
break;
}
switch (buttonType)
{
// Full range
case Config::AXIS:
case Config::SLIDER:
isRange = true;
break;
// Half range
case Config::HAXIS:
case Config::HSLIDER:
case Config::CBUT:
isRange = true;
isHalf = true;
break;
default:
break;
}
s32 v = 0;
s8 id = m_mapping.Button[i].id;
u32 index = std::abs(id) - 1;
if (id != 0)
{
v = values[index];
}
// [ 32768 steps | 32768 steps ]
// DInput [ 0 32767 | 32768 65535 ]
// XInput [ -32768 -1 | 0 32767 ]
//
u16 deadZone = (u16)m_mapping.Button[i].buttondz;
bool invert = id < 0;
s32 min = -32768;
s32 max = 32767;
s32 diValue;
if (isHalf)
{
diValue = (invert) ? -1 - v : v;
}
else
{
diValue = (invert) ? max - v : v - min;
deadZone = deadZone * 2;
}
if (isRange)
{
PrintLog("Axis/Slider: %d, invert = %d, half = %d, deadZone %d diValue %d", v, invert, isHalf, deadZone, diValue);
if (diValue > deadZone)
{
pState->Gamepad.wButtons |= Config::buttonIDs[i];
}
}
}
}
// --- Map triggers ---
u8 *targetTrigger[] =
{
&pState->Gamepad.bLeftTrigger,
&pState->Gamepad.bRightTrigger
};
for (u32 i = 0; i < _countof(m_mapping.Trigger); ++i)
{
s8 triggerMapId = m_mapping.Trigger[i].id;
// Skip invalid mappings
if (triggerMapId == 0)
continue;
s8 triggerMapIndex = (s8)std::abs(triggerMapId) - 1;
Config::MappingType triggerType = m_mapping.Trigger[i].type;
if (triggerType == Config::DIGITAL)
{
if (ButtonPressed(triggerMapIndex))
*(targetTrigger[i]) = 255;
}
else if (triggerType == Config::DPADBUTTON)
{
if (triggerMapIndex < _countof(dPadButtons) && dPadButtons[triggerMapIndex])
*(targetTrigger[i]) = 255;
}
else
{
s32 *values;
switch (triggerType)
{
case Config::AXIS:
case Config::HAXIS:
case Config::CBUT:
values = axis;
break;
case Config::SLIDER:
case Config::HSLIDER:
values = slider;
break;
default:
values = axis;
break;
}
s32 v = 0;
if (m_mapping.Trigger[i].id > 0)
{
v = values[m_mapping.Trigger[i].id - 1];
}
else if (m_mapping.Trigger[i].id < 0)
{
v = -values[-m_mapping.Trigger[i].id - 1] - 1;
}
/* FIXME: axis negative max should be -32768
--- v is the full range (-32768 .. +32767) that should be projected to 0...255
--- Full ranges
AXIS: ( 0 to 255 from -32768 to 32767) using axis
SLIDER: ( 0 to 255 from -32768 to 32767) using slider
------------------------------------------------------------------------------
--- Half ranges
HAXIS: ( 0 to 255 from 0 to 32767) using axis
HSLIDER: ( 0 to 255 from 0 to 32767) using slider
*/
s32 v2 = 0;
s32 offset = 0;
s32 scaling = 1;
switch (triggerType)
{
// Full range
case Config::AXIS:
case Config::SLIDER:
scaling = 255;
offset = 32767;
break;
// Half range
case Config::HAXIS:
case Config::HSLIDER:
case Config::CBUT: // add /////////////////////////////////////////////////////////
scaling = 127;
offset = 0;
break;
default:
scaling = 1;
offset = 0;
break;
}
//v2 = (v + offset) / scaling;
// Add deadzones
//*(targetTrigger[i]) = (BYTE) deadzone(v2, 0, 255, pController->triggerdz, 255);
/////////////////////////////////////////////////////////////////////////////////////////
if (triggerType == Config::CBUT)
{
if (ButtonPressed(m_mapping.Trigger[0].but)
&& ButtonPressed(m_mapping.Trigger[1].but))
{
*(targetTrigger[0]) = 255;
*(targetTrigger[1]) = 255;
}
if (ButtonPressed(m_mapping.Trigger[0].but)
&& !ButtonPressed(m_mapping.Trigger[1].but))
{
v2 = (offset - v) / scaling;
*(targetTrigger[0]) = 255;
*(targetTrigger[1]) = 255 - (u8)deadzone(v2, 0, 255, m_mapping.Trigger[1].triggerdz, 255);
}
if (!ButtonPressed(m_mapping.Trigger[0].but)
&& ButtonPressed(m_mapping.Trigger[1].but))
{
v2 = (offset + v) / scaling;
*(targetTrigger[0]) = 255 - (u8)deadzone(v2, 0, 255, m_mapping.Trigger[0].triggerdz, 255);
*(targetTrigger[1]) = 255;
}
if (!ButtonPressed(m_mapping.Trigger[0].but)
&& !ButtonPressed(m_mapping.Trigger[1].but))
{
v2 = (offset + v) / scaling;
*(targetTrigger[i]) = (u8)deadzone(v2, 0, 255, m_mapping.Trigger[i].triggerdz, 255);
}
}
else
{
v2 = (offset + v) / scaling;
*(targetTrigger[i]) = (u8)deadzone(v2, 0, 255, m_mapping.Trigger[i].triggerdz, 255);
}
/////////////////////////////////////////////////////////////////////////////////////////
}
}
// --- Map thumbsticks ---
// Created so we can refer to each axis with an ID
SHORT *targetAxis[4] =
{
&pState->Gamepad.sThumbLX,
&pState->Gamepad.sThumbLY,
&pState->Gamepad.sThumbRX,
&pState->Gamepad.sThumbRY
};
for (u32 i = 0; i < _countof(m_mapping.Axis); ++i)
{
if (m_mapping.Axis[i].axistodpad == 0)
{
s8 axisMapId = m_mapping.Axis[i].id;
// Skip invalid mappings
if (axisMapId != 0)
{
u32 index = std::abs(axisMapId) - 1;
s32 value = axis[index];
// Analog input
if (m_mapping.Axis[i].analogType == Config::AXIS) value = axis[index];
if (m_mapping.Axis[i].analogType == Config::SLIDER) value = slider[index];
if (m_mapping.Axis[i].analogType != Config::NONE)
{
// [ 32768 steps | 32768 steps ]
// DInput [ 0 32767 | 32768 65535 ]
// XInput [ -32768 -1 | 0 32767 ]
//
//int xInput = dInputValue;
s32 xInput = value;
s32 deadZone = (s32)m_mapping.Axis[i].axisdeadzone;
s32 antiDeadZone = (s32)m_mapping.Axis[i].antideadzone;
s32 linear = (s32)m_mapping.Axis[i].axislinear;
s32 min = -32768;
s32 max = 32767;
bool invert = axisMapId < 0;
// If axis should be inverted, convert [-32768;32767] -> [32767;-32768]
if (invert) xInput = -1 - xInput;
// The following sections expect xInput values in range [0;32767]
// So, convert to positive: [-32768;-1] -> [32767;0]
bool negative = xInput < 0;
if (negative) xInput = -1 - xInput;
// If deadzone value is set then...
if (deadZone > 0)
{
if (xInput > deadZone)
{
// [deadZone;32767] => [0;32767];
xInput = (s32)((float)(xInput - deadZone) / (float)(max - deadZone) * (float)max);
}
else
{
xInput = 0;
}
}
// If anti-deadzone value is set then...
if (antiDeadZone > 0)
{
if (xInput > 0)
{
// [0;32767] => [antiDeadZone;32767];
xInput = (s32)((float)(xInput) / (float)max * (float)(max - antiDeadZone) + antiDeadZone);
}
}
// If linear value is set then...
if (linear != 0 && xInput > 0)
{
// [antiDeadZone;32767] => [0;32767];
float xInputF = (float)(xInput - antiDeadZone) / (float)(max - antiDeadZone) * (float)max;
float linearF = (float)linear / 100.f;
xInputF = ConvertToFloat((short)xInputF);
float x = -xInputF;
if (linearF < 0.f) x = 1.f + x;
float v = ((float)sqrt(1.f - x * x));
if (linearF < 0.f) v = 1.f - v;
xInputF = xInputF + (2.f - v - xInputF - 1.f) * abs(linearF);
xInput = ConvertToShort(xInputF);
// [0;32767] => [antiDeadZone;32767];
xInput = (s32)((float)(xInput) / (float)max * (float)(max - antiDeadZone) + antiDeadZone);
}
// If originally negative, convert back: [32767;0] -> [-32768;-1]
if (negative) xInput = -1 - xInput;
*(targetAxis[i]) = (s16)clamp(xInput, min, max);
//return (short)xInput;
}
}
Config::MappingType posType = m_mapping.Axis[i].positiveType;
Config::MappingType negType = m_mapping.Axis[i].negativeType;
s8 posMapId = m_mapping.Axis[i].positiveButtonID - 1;
s8 negMapId = m_mapping.Axis[i].negativeButtonID - 1;
// Map button to positive axis direction.
if (posType == Config::DIGITAL && posMapId >= 0 && ButtonPressed(posMapId))
*(targetAxis[i]) = 32767;
// Map button to negative axis direction.
if (negType == Config::DIGITAL && negMapId >= 0 && ButtonPressed(negMapId))
*(targetAxis[i]) = -32768;
// Map D-Pad button to positive axis direction.
if (posType == Config::DPADBUTTON && posMapId >= 0 && posMapId < _countof(dPadButtons) && dPadButtons[posMapId])
*(targetAxis[i]) = 32767;
// Map D-Pad button to negative axis direction.
if (negType == Config::DPADBUTTON && negMapId >= 0 && negMapId < _countof(dPadButtons) && dPadButtons[negMapId])
*(targetAxis[i]) = -32768;
}
else
{
//PrintLog("x: %d, y: %d, z: %d",Gamepad[dwUserIndex].state.lX,Gamepad[dwUserIndex].state.lY,Gamepad[dwUserIndex].state.lZ);
if (m_state.lX - m_mapping.Axis[i].a2doffset > m_mapping.Axis[i].a2ddeadzone)
pState->Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_LEFT;
if (m_state.lX - m_mapping.Axis[i].a2doffset < -m_mapping.Axis[i].a2ddeadzone)
pState->Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_RIGHT;
if (m_state.lY - m_mapping.Axis[i].a2doffset < -m_mapping.Axis[i].a2ddeadzone)
pState->Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_UP;
if (m_state.lY - m_mapping.Axis[i].a2doffset > m_mapping.Axis[i].a2ddeadzone)
pState->Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_DOWN;
}
}
// prevent sleep
SetThreadExecutionState(ES_SYSTEM_REQUIRED | ES_DISPLAY_REQUIRED);
return ERROR_SUCCESS;
}
struct fitfp *fit_open(char *fitfile,char *inxfile) {
int r1_pat[]={4,2,1,2,2,17,4,2,2,14,4,4,2,4,
2,PULSE_PAT_LEN,2,2*LAG_TAB_LEN,1,ORIG_COMBF_SIZE,4,3,
2,2*ORIG_MAX_RANGE,1,ORIG_MAX_RANGE,0,0};
int status=0;
union fit_out r;
struct fitfp *ptr=NULL;
int16 tmp,i,j;
int32 inx_buf[4];
struct radar_parms *prms=NULL;
char *tmpbuf;
ptr=malloc(sizeof(struct fitfp));
if (ptr==NULL) return NULL;
ptr->fitfp=-1;
ptr->inxfp=-1;
ptr->ibuf=NULL;
ptr->fbuf=NULL;
ptr->iptr=0;
ptr->fptr=0;
ptr->ctime=-1;
ptr->stime=-1;
ptr->etime=-1;
ptr->fitfp=open(fitfile,O_RDONLY);
if (ptr->fitfp==-1) {
free(ptr);
return NULL;
}
fstat(ptr->fitfp,&ptr->fstat);
/* buffering disabled as it is actually slower to load into memory!
ptr->fbuf=malloc(ptr->fstat.st_size);
if (ptr->fbuf !=NULL) {
if (read(ptr->fitfp,ptr->fbuf,
ptr->fstat.st_size) !=ptr->fstat.st_size) {
close(ptr->fitfp);
free(ptr->fbuf);
free(ptr);
return NULL;
}
close(ptr->fitfp);
ptr->fitfp=-1;
}
*/
if (inxfile !=NULL) { /* open the index file */
ptr->inxfp=open(inxfile,O_RDONLY);
if (ptr->inxfp !=-1) {
fstat(ptr->inxfp,&ptr->istat);
ptr->ibuf=malloc(ptr->istat.st_size);
if ((ptr->ibuf !=NULL) &&
(read(ptr->inxfp,ptr->ibuf,ptr->istat.st_size)
!=ptr->istat.st_size)) free(ptr->ibuf);
close(ptr->inxfp);
ptr->inxfp=-1;
}
}
if (ptr->fitfp !=-1) {
ConvertReadShort(ptr->fitfp,&tmp);
ptr->fit_recl=tmp;
ConvertReadShort(ptr->fitfp,&tmp);
ptr->inx_recl=tmp;
tmpbuf=malloc(ptr->fit_recl);
if (tmpbuf !=NULL) { /* get the header information */
memset(tmpbuf,0,ptr->fit_recl);
status=(read(ptr->fitfp,tmpbuf,ptr->fit_recl) !=ptr->fit_recl);
/* now decode the header information */
if (status==0) {
for (i=0;(tmpbuf[i] !='\n') && (tmpbuf[i] !=0) && (i<80);i++)
ptr->header[i]=tmpbuf[i];
ptr->header[i]=0;
j=i+1;
for (i=0;(tmpbuf[j+i] !='\n') && (tmpbuf[j+i] !=0) && (i<32);i++)
ptr->date[i]=tmpbuf[j+i];
ptr->date[i]=0;
j+=i+1;
for (i=0;(tmpbuf[j+i] !=0) && (i<256);i++)
ptr->extra[i]=tmpbuf[j+i];
ptr->extra[i]=0;
/* okay extra the version information - look for the '.' */
for (i=0;(ptr->header[i] !='.') && (ptr->header[i] !=0);i++);
if (ptr->header[i] !=0) {
tmpbuf[i]=0; /* work backwards for the major number */
for (j=0;(ptr->header[i-1-j] !=' ') && ((i-1-j)>0);j++)
tmpbuf[i-1-j]=ptr->header[i-1-j];
ptr->major_rev=atoi(tmpbuf+i-j);
for (j=0;(ptr->header[i+1+j] !=' ') &&
(ptr->header[i+1+j] !=0);i++) tmpbuf[j]=ptr->header[i+1+j];
tmpbuf[j]=0;
ptr->minor_rev=atoi(tmpbuf);
}
}
free(tmpbuf);
}
lseek(ptr->fitfp,ptr->fit_recl,SEEK_SET);
/* read the first parameter block se we can determine the year */
status=(read(ptr->fitfp,&r,sizeof(union fit_out)) !=sizeof(union fit_out));
if (status==0) {
ConvertBlock( (unsigned char *) &r,r1_pat);
status=(r.r1.rrn !=0);
prms=(struct radar_parms *) &(r.r1.plist[0]);
}
lseek(ptr->fitfp,ptr->fit_recl,SEEK_SET);
} else {
ConvertToShort(ptr->fbuf,&tmp);
ptr->fit_recl=tmp;
ConvertToShort(ptr->fbuf+2,&tmp);
ptr->inx_recl=tmp;
ptr->fptr=ptr->fit_recl;
memcpy( (unsigned char *) &r,
ptr->fbuf+ptr->fit_recl,sizeof(union fit_out));
ConvertBlock( (unsigned char *) &r,r1_pat);
status=(r.r1.rrn !=0);
prms=(struct radar_parms *) &(r.r1.plist[0]);
}
if (status !=0) {
if (ptr->fitfp !=-1) close(ptr->fitfp);
if (ptr->fbuf !=NULL) free(ptr->fbuf);
if (ptr->inxfp !=-1) close(ptr->inxfp);
if (ptr->ibuf !=NULL) free(ptr->ibuf);
free(ptr);
return NULL;
}
ptr->ctime=TimeYMDHMSToEpoch(prms->YEAR,prms->MONTH,prms->DAY,
prms->HOUR,prms->MINUT,prms->SEC);
ptr->stime=ptr->ctime;
if (fit_read_inx(ptr,inx_buf,-1)==0) {
if (inx_buf[0] > inx_buf[1]) prms->YEAR++;
/* generate the end time of the file */
ptr->etime=TimeYMDHMSToEpoch(prms->YEAR,1,1,0,0,0)
+inx_buf[1];
ptr->inx_srec=inx_buf[2]-2;
ptr->inx_erec=inx_buf[3];
} else { /* corrupt index file */
if (ptr->inxfp !=-1) close(ptr->inxfp);
if (ptr->ibuf !=NULL) free(ptr->ibuf);
ptr->ibuf=NULL;
ptr->inxfp=-1;
}
ptr->fitread=fit_read_current;
return ptr;
}
struct DataMap *DataMapDecodeBuffer(char *buf,int size) {
int c,x,n,i,e;
int32 sn,an;
int32 code,sze;
char *name;
char *tmp;
char type;
unsigned int off=0;
int32 tsze;
struct DataMap *ptr;
struct DataMapScalar *s;
struct DataMapArray *a;
ptr=DataMapMake();
if (ptr==NULL) return NULL;
ConvertToInt(buf+off,&code);
off+=sizeof(int32);
ConvertToInt(buf+off,&sze);
off+=sizeof(int32);
ConvertToInt(buf+off,&sn);
off+=sizeof(int32);
ConvertToInt(buf+off,&an);
off+=sizeof(int32);
if (sn>0) {
ptr->snum=sn;
ptr->scl=malloc(sizeof(struct DataMapScalar *)*sn);
if (ptr->scl==NULL) {
DataMapFree(ptr);
return NULL;
}
for (c=0;c<sn;c++) ptr->scl[c]=NULL;
}
if (an>0) {
ptr->anum=an;
ptr->arr=malloc(sizeof(struct DataMapArray *)*an);
if (ptr->arr==NULL) {
DataMapFree(ptr);
return NULL;
}
for (c=0;c<an;c++) ptr->arr[c]=NULL;
}
for (c=0;c<sn;c++) {
e=0;
n=0;
while ((buf[off+n] !=0) && (off+n<size)) n++;
if (off+n>=size) break;
name=malloc(n+1);
if (name==NULL) break;
memcpy(name,buf+off,n+1);
off+=n+1;
type=buf[off];
off++;
s=malloc(sizeof(struct DataMapScalar));
if (s==NULL) {
free(name);
break;
}
s->name=name;
s->mode=6;
s->type=type;
ptr->scl[c]=s;
switch (s->type) {
case DATACHAR:
s->data.vptr=malloc(sizeof(char));
if (s->data.vptr==NULL) {
e=1;
break;
}
s->data.cptr[0]=buf[off];
off++;
break;
case DATASHORT:
s->data.vptr=malloc(sizeof(int16));
if (s->data.vptr==NULL) {
e=1;
break;
}
ConvertToShort(buf+off,s->data.sptr);
off+=sizeof(int16);
break;
case DATAINT:
s->data.vptr=malloc(sizeof(int32));
if (s->data.vptr==NULL) {
e=1;
break;
}
ConvertToInt(buf+off,s->data.iptr);
off+=sizeof(int32);
break;
case DATALONG:
s->data.vptr=malloc(sizeof(int64));
if (s->data.vptr==NULL) {
e=1;
break;
}
ConvertToLong(buf+off,s->data.lptr);
off+=sizeof(int64);
break;
case DATAUCHAR:
s->data.vptr=malloc(sizeof(unsigned char));
if (s->data.vptr==NULL) {
e=1;
break;
}
s->data.ucptr[0]=buf[off];
off++;
break;
case DATAUSHORT:
s->data.vptr=malloc(sizeof(uint16));
if (s->data.vptr==NULL) {
e=1;
break;
}
ConvertToUShort(buf+off,s->data.usptr);
off+=sizeof(uint16);
break;
case DATAUINT:
s->data.vptr=malloc(sizeof(uint32));
if (s->data.vptr==NULL) {
e=1;
break;
}
ConvertToUInt(buf+off,s->data.uiptr);
off+=sizeof(uint32);
break;
case DATAULONG:
s->data.vptr=malloc(sizeof(uint64));
if (s->data.vptr==NULL) {
e=1;
break;
}
ConvertToULong(buf+off,s->data.ulptr);
off+=sizeof(uint64);
break;
case DATAFLOAT:
s->data.vptr=malloc(sizeof(float));
if (s->data.vptr==NULL) {
e=1;
break;
}
ConvertToFloat(buf+off,s->data.fptr);
off+=sizeof(float);
break;
case DATADOUBLE:
s->data.vptr=malloc(sizeof(double));
if (s->data.vptr==NULL) {
e=1;
break;
}
ConvertToDouble(buf+off,s->data.dptr);
off+=sizeof(double);
break;
case DATASTRING:
n=0;
while ((buf[off+n] !=0) && (off+n<size)) n++;
if (off+n>=size) {
e=1;
break;
}
s->data.vptr=malloc(sizeof(char *));
if (s->data.vptr==NULL) {
e=1;
break;
}
if (n !=0) {
tmp=malloc(n+1);
if (tmp==NULL) {
e=1;
break;
}
memcpy(tmp,buf+off,n+1);
off+=n+1;
*( (char **) s->data.vptr)=tmp;
} else {
*( (char **) s->data.vptr)=NULL;
off++;
}
break;
default:
s->data.vptr=malloc(sizeof(struct DataMap *));
if (s->data.vptr==NULL) {
e=1;
break;
}
ConvertToInt(buf+off,&tsze);
off+=sizeof(int32);
if (tsze !=0) {
*s->data.mptr=DataMapDecodeBuffer(buf+off,tsze);
off+=tsze;
} else *s->data.mptr=NULL;
}
if (e==1) break;
}
if (c !=sn) {
DataMapFree(ptr);
return NULL;
}
for (c=0;c<an;c++) {
e=0;
n=0;
while ((buf[off+n] !=0) && (off+n<size)) n++;
if (off+n>=size) break;
name=malloc(n+1);
if (name==NULL) break;
memcpy(name,buf+off,n+1);
off+=n+1;
type=buf[off];
off++;
a=malloc(sizeof(struct DataMapArray));
if (a==NULL) {
free(name);
break;
}
a->name=name;
a->mode=7;
a->type=type;
ptr->arr[c]=a;
ConvertToInt(buf+off,(int32 *) &(a->dim));
off+=sizeof(int32);
a->rng=malloc(a->dim*sizeof(int32));
if (a->rng==NULL) break;
for (x=0;x<a->dim;x++) {
ConvertToInt(buf+off,&a->rng[x]);
off+=sizeof(int32);
}
if (x!=a->dim) break;
n=1;
for (x=0;x<a->dim;x++) n=a->rng[x]*n;
switch (a->type) {
case DATACHAR:
a->data.vptr=malloc(sizeof(char)*n);
if (a->data.vptr==NULL) {
e=1;
break;
}
memcpy(a->data.cptr,buf+off,sizeof(char)*n);
off+=sizeof(char)*n;
break;
case DATASHORT:
a->data.vptr=malloc(sizeof(int16)*n);
if (a->data.vptr==NULL) {
e=1;
break;
}
for (x=0;x<n;x++) {
ConvertToShort(buf+off,&a->data.sptr[x]);
off+=sizeof(int16);
}
break;
case DATAINT:
a->data.vptr=malloc(sizeof(int32)*n);
if (a->data.vptr==NULL) {
break;
e=1;
}
for (x=0;x<n;x++) {
ConvertToInt(buf+off,&a->data.iptr[x]);
off+=sizeof(int32);
}
break;
case DATALONG:
a->data.vptr=malloc(sizeof(int64)*n);
if (a->data.vptr==NULL) {
e=1;
break;
}
for (x=0;x<n;x++) {
ConvertToLong(buf+off,&a->data.lptr[x]);
off+=sizeof(int64);
}
break;
case DATAUCHAR:
a->data.vptr=malloc(sizeof(unsigned char)*n);
if (a->data.vptr==NULL) {
e=1;
break;
}
memcpy(a->data.cptr,buf+off,sizeof(unsigned char)*n);
off+=sizeof(unsigned char)*n;
break;
case DATAUSHORT:
a->data.vptr=malloc(sizeof(uint16)*n);
if (a->data.vptr==NULL) {
e=1;
break;
}
for (x=0;x<n;x++) {
ConvertToUShort(buf+off,&a->data.usptr[x]);
off+=sizeof(uint16);
}
break;
case DATAUINT:
a->data.vptr=malloc(sizeof(uint32)*n);
if (a->data.vptr==NULL) {
e=1;
break;
}
for (x=0;x<n;x++) {
ConvertToUInt(buf+off,&a->data.uiptr[x]);
off+=sizeof(uint32);
}
break;
case DATAULONG:
a->data.vptr=malloc(sizeof(uint64)*n);
if (a->data.vptr==NULL) {
e=1;
break;
}
for (x=0;x<n;x++) {
ConvertToULong(buf+off,&a->data.ulptr[x]);
off+=sizeof(uint64);
}
break;
case DATAFLOAT:
a->data.vptr=malloc(sizeof(float)*n);
if (a->data.vptr==NULL) {
e=1;
break;
}
for (x=0;x<n;x++) {
ConvertToFloat(buf+off,&a->data.fptr[x]);
off+=sizeof(float);
}
break;
case DATADOUBLE:
a->data.vptr=malloc(sizeof(double)*n);
if (a->data.vptr==NULL) {
e=1;
break;
}
for (x=0;x<n;x++) {
ConvertToDouble(buf+off,&a->data.dptr[x]);
off+=sizeof(double);
}
break;
case DATASTRING:
a->data.vptr=malloc(sizeof(char *)*n);
if (a->data.vptr==NULL) {
e=1;
break;
}
for (x=0;x<n;x++) {
i=0;
while ((buf[off+i] !=0) && (off+i<size)) i++;
if (off+i>=size) break;
if (i !=0) {
tmp=malloc(i+1);
if (tmp==NULL) break;
memcpy(tmp,buf+off,i+1);
((char **) a->data.vptr)[x]=tmp;
} else ((char **) a->data.vptr)[x]=NULL;
off+=i+1;
}
if (x !=n) e=1;
break;
default:
a->data.mptr=malloc(sizeof(struct DataMap *)*n);
if (a->data.vptr==NULL) {
e=1;
break;
}
for (x=0;x<n;x++) {
ConvertToInt(buf+off,&tsze);
off+=sizeof(int32);
if (tsze !=0) {
a->data.mptr[x]=DataMapDecodeBuffer(buf+off,tsze);
off+=tsze;
} else a->data.mptr[x]=0;
}
}
if (e==1) break;
}
if (c !=an) {
DataMapFree(ptr);
return NULL;
}
return ptr;
}
DWORD Controller::GetState(XINPUT_STATE* pState)
{
// Passthrough?
if (m_passthrough)
return XInputModuleManager::Get().XInputGetState(m_passthroughindex, pState);
if (!ControllerManager::Get().XInputEnabled())
{
// Clear state
if (pState) ZeroMemory(pState, sizeof(XINPUT_STATE));
return ERROR_SUCCESS;
}
HRESULT hr = UpdateState();
#if 0
PrintLog("UpdateState %u %u", dwUserIndex, hr);
#endif
if (FAILED(hr)) return
ERROR_DEVICE_NOT_CONNECTED;
pState->Gamepad.wButtons = 0;
pState->Gamepad.bLeftTrigger = 0;
pState->Gamepad.bRightTrigger = 0;
pState->Gamepad.sThumbLX = 0;
pState->Gamepad.sThumbLY = 0;
pState->Gamepad.sThumbRX = 0;
pState->Gamepad.sThumbRY = 0;
// timestamp packet
pState->dwPacketNumber = GetTickCount();
// --- Map POV to the D-pad ---
if (m_mapping.DpadPOV > 0 && m_mapping.PovIsButton == false)
{
//INT pov = POVState(m_mapping.DpadPOV,dwUserIndex,Gamepad[dwUserIndex].povrotation);
int povdeg = m_state.rgdwPOV[m_mapping.DpadPOV - 1];
if (povdeg >= 0)
{
// Up-left, up, up-right, up (at 360 degrees)
if (IN_RANGE2(povdeg, m_mapping.pov[Config::DPAD_LEFT] + 1, m_mapping.pov[Config::DPAD_UP]) || IN_RANGE2(povdeg, 0, m_mapping.pov[Config::DPAD_RIGHT] - 1))
pState->Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_UP;
// Up-right, right, down-right
if (IN_RANGE(povdeg, 0, m_mapping.pov[Config::DPAD_DOWN]))
pState->Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_RIGHT;
// Down-right, down, down-left
if (IN_RANGE(povdeg, m_mapping.pov[Config::DPAD_RIGHT], m_mapping.pov[Config::DPAD_LEFT]))
pState->Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_DOWN;
// Down-left, left, up-left
if (IN_RANGE(povdeg, m_mapping.pov[Config::DPAD_DOWN], m_mapping.pov[Config::DPAD_UP]))
pState->Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_LEFT;
}
}
else if (m_mapping.PovIsButton == true)
{
for (int i = 0; i < _countof(m_mapping.pov); ++i)
{
if (ButtonPressed(m_mapping.pov[i]))
{
pState->Gamepad.wButtons |= Config::povIDs[i];
}
}
}
// Created so we can refer to each axis with an ID
s32 axis[] =
{
m_state.lX,
m_state.lY,
m_state.lZ,
m_state.lRx,
m_state.lRy,
m_state.lRz
};
s32 slider[] =
{
m_state.rglSlider[0],
m_state.rglSlider[1]
};
// --- Map buttons ---
if (ButtonPressed(m_mapping.guide))
pState->Gamepad.wButtons |= 0x400;
for (u32 i = 0; i < _countof(m_mapping.Button); ++i)
{
// Skip invalid mappings
if (m_mapping.Button[i].id == 0)
continue;
Config::MappingType buttonType = m_mapping.Button[i].type;
if (buttonType == Config::DIGITAL)
{
if (ButtonPressed(m_mapping.Button[i].id -1))
pState->Gamepad.wButtons |= Config::buttonIDs[i];
}
else
{
s32 *values;
switch (buttonType)
{
case Config::AXIS:
case Config::HAXIS:
case Config::CBUT:
values = axis;
break;
case Config::SLIDER:
case Config::HSLIDER:
values = slider;
break;
default:
values = axis;
break;
}
s32 v = 0;
if (m_mapping.Button[i].id > 0)
{
v = values[m_mapping.Button[i].id - 1];
}
else if (m_mapping.Button[i].id < 0)
{
v = -values[-m_mapping.Button[i].id - 1] - 1;
}
s32 v2 = 0;
s32 offset = 0;
s32 scaling = 1;
switch (buttonType)
{
// Full range
case Config::AXIS:
case Config::SLIDER:
scaling = 255;
offset = 32767;
break;
// Half range
case Config::HAXIS:
case Config::HSLIDER:
case Config::CBUT:
scaling = 127;
offset = 0;
break;
default:
scaling = 1;
offset = 0;
break;
}
v2 = (offset + v) / scaling;
if (deadzone(v2, 0, 1, m_mapping.Button[i].buttondz, 1) > 0)
{
pState->Gamepad.wButtons |= Config::buttonIDs[i];
}
}
}
// --- Map triggers ---
u8 *targetTrigger[] =
{
&pState->Gamepad.bLeftTrigger,
&pState->Gamepad.bRightTrigger
};
for (u32 i = 0; i < _countof(m_mapping.Trigger); ++i)
{
// Skip invalid mappings
if (m_mapping.Trigger[i].id == 0)
continue;
Config::MappingType triggerType = m_mapping.Trigger[i].type;
if (triggerType == Config::DIGITAL)
{
if (ButtonPressed(m_mapping.Trigger[i].id - 1))*(targetTrigger[i]) = 255;
}
else
{
s32 *values;
switch (triggerType)
{
case Config::AXIS:
case Config::HAXIS:
case Config::CBUT:
values = axis;
break;
case Config::SLIDER:
case Config::HSLIDER:
values = slider;
break;
default:
values = axis;
break;
}
s32 v = 0;
if (m_mapping.Trigger[i].id > 0)
{
v = values[m_mapping.Trigger[i].id - 1];
}
else if (m_mapping.Trigger[i].id < 0)
{
v = -values[-m_mapping.Trigger[i].id - 1] - 1;
}
/* FIXME: axis negative max should be -32768
--- v is the full range (-32768 .. +32767) that should be projected to 0...255
--- Full ranges
AXIS: ( 0 to 255 from -32768 to 32767) using axis
SLIDER: ( 0 to 255 from -32768 to 32767) using slider
------------------------------------------------------------------------------
--- Half ranges
HAXIS: ( 0 to 255 from 0 to 32767) using axis
HSLIDER: ( 0 to 255 from 0 to 32767) using slider
*/
s32 v2 = 0;
s32 offset = 0;
s32 scaling = 1;
switch (triggerType)
{
// Full range
case Config::AXIS:
case Config::SLIDER:
scaling = 255;
offset = 32767;
break;
// Half range
case Config::HAXIS:
case Config::HSLIDER:
case Config::CBUT: // add /////////////////////////////////////////////////////////
scaling = 127;
offset = 0;
break;
default:
scaling = 1;
offset = 0;
break;
}
//v2 = (v + offset) / scaling;
// Add deadzones
//*(targetTrigger[i]) = (BYTE) deadzone(v2, 0, 255, pController->triggerdz, 255);
/////////////////////////////////////////////////////////////////////////////////////////
if (triggerType == Config::CBUT)
{
if (ButtonPressed(m_mapping.Trigger[0].but)
&& ButtonPressed(m_mapping.Trigger[1].but))
{
*(targetTrigger[0]) = 255;
*(targetTrigger[1]) = 255;
}
if (ButtonPressed(m_mapping.Trigger[0].but)
&& !ButtonPressed(m_mapping.Trigger[1].but))
{
v2 = (offset - v) / scaling;
*(targetTrigger[0]) = 255;
*(targetTrigger[1]) = 255 - (u8)deadzone(v2, 0, 255, m_mapping.Trigger[1].triggerdz, 255);
}
if (!ButtonPressed(m_mapping.Trigger[0].but)
&& ButtonPressed(m_mapping.Trigger[1].but))
{
v2 = (offset + v) / scaling;
*(targetTrigger[0]) = 255 - (u8)deadzone(v2, 0, 255, m_mapping.Trigger[0].triggerdz, 255);
*(targetTrigger[1]) = 255;
}
if (!ButtonPressed(m_mapping.Trigger[0].but)
&& !ButtonPressed(m_mapping.Trigger[1].but))
{
v2 = (offset + v) / scaling;
*(targetTrigger[i]) = (u8)deadzone(v2, 0, 255, m_mapping.Trigger[i].triggerdz, 255);
}
}
else
{
v2 = (offset + v) / scaling;
*(targetTrigger[i]) = (u8)deadzone(v2, 0, 255, m_mapping.Trigger[i].triggerdz, 255);
}
/////////////////////////////////////////////////////////////////////////////////////////
}
}
// --- Map thumbsticks ---
// Created so we can refer to each axis with an ID
SHORT *targetAxis[4] =
{
&pState->Gamepad.sThumbLX,
&pState->Gamepad.sThumbLY,
&pState->Gamepad.sThumbRX,
&pState->Gamepad.sThumbRY
};
for (u32 i = 0; i < _countof(m_mapping.Axis); ++i)
{
if (m_mapping.Axis[i].axistodpad == 0)
{
// Skip invalid mappings
if (m_mapping.Axis[i].id != 0)
{
u32 index = std::abs(m_mapping.Axis[i].id) - 1;
s32 value = axis[index];
// Analog input
if (m_mapping.Axis[i].analogType == Config::AXIS) value = axis[index];
if (m_mapping.Axis[i].analogType == Config::SLIDER) value = slider[index];
if (m_mapping.Axis[i].analogType != Config::NONE)
{
// [ 32768 steps | 32768 steps ]
// DInput [ 0 32767 | 32768 65535 ]
// XInput [ 32768 -1 | 0 32767 ]
//
//int xInput = dInputValue;
s32 xInput = value;
s32 deadZone = (s32)m_mapping.Axis[i].axisdeadzone;
s32 antiDeadZone = (s32)m_mapping.Axis[i].antideadzone;
s32 linear = (s32)m_mapping.Axis[i].axislinear;
s32 min = -32768;
s32 max = 32767;
bool invert = m_mapping.Axis[i].id < 0;
// If axis should be inverted, convert [-32768;32767] -> [32767;-32768]
if (invert) xInput = -1 - xInput;
// The following sections expect xInput values in range [0;32767]
// So, convert to positive: [-32768;-1] -> [32767;0]
bool negative = xInput < 0;
if (negative) xInput = -1 - xInput;
// If deadzone value is set then...
if (deadZone > 0)
{
if (xInput > deadZone)
{
// [deadZone;32767] => [0;32767];
xInput = (s32)((float)(xInput - deadZone) / (float)(max - deadZone) * (float)max);
}
else
{
xInput = 0;
}
}
// If anti-deadzone value is set then...
if (antiDeadZone > 0)
{
if (xInput > 0)
{
// [0;32767] => [antiDeadZone;32767];
xInput = (s32)((float)(xInput) / (float)max * (float)(max - antiDeadZone) + antiDeadZone);
}
}
// If linear value is set then...
if (linear != 0 && xInput > 0)
{
// [antiDeadZone;32767] => [0;32767];
float xInputF = (float)(xInput - antiDeadZone) / (float)(max - antiDeadZone) * (float)max;
float linearF = (float)linear / 100.f;
xInputF = ConvertToFloat((short)xInputF);
float x = -xInputF;
if (linearF < 0.f) x = 1.f + x;
float v = ((float)sqrt(1.f - x * x));
if (linearF < 0.f) v = 1.f - v;
xInputF = xInputF + (2.f - v - xInputF - 1.f) * abs(linearF);
xInput = ConvertToShort(xInputF);
// [0;32767] => [antiDeadZone;32767];
xInput = (s32)((float)(xInput) / (float)max * (float)(max - antiDeadZone) + antiDeadZone);
}
// If originally negative, convert back: [32767;0] -> [-32768;-1]
if (negative) xInput = -1 - xInput;
*(targetAxis[i]) = (s16)clamp(xInput, min, max);
//return (short)xInput;
}
}
// Map axis to Button: Digital input, positive direction
if (m_mapping.Axis[i].hasDigital && m_mapping.Axis[i].positiveButtonID >= 0)
{
if (ButtonPressed(m_mapping.Axis[i].positiveButtonID))
*(targetAxis[i]) = 32767;
}
// Map axis to Button: Digital input, negative direction
if (m_mapping.Axis[i].hasDigital && m_mapping.Axis[i].negativeButtonID >= 0)
{
if (ButtonPressed(m_mapping.Axis[i].negativeButtonID))
*(targetAxis[i]) = -32768;
}
}
else
{
//PrintLog("x: %d, y: %d, z: %d",Gamepad[dwUserIndex].state.lX,Gamepad[dwUserIndex].state.lY,Gamepad[dwUserIndex].state.lZ);
if (m_state.lX - m_mapping.Axis[i].a2doffset > m_mapping.Axis[i].a2ddeadzone)
pState->Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_LEFT;
if (m_state.lX - m_mapping.Axis[i].a2doffset < -m_mapping.Axis[i].a2ddeadzone)
pState->Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_RIGHT;
if (m_state.lY - m_mapping.Axis[i].a2doffset < -m_mapping.Axis[i].a2ddeadzone)
pState->Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_UP;
if (m_state.lY - m_mapping.Axis[i].a2doffset > m_mapping.Axis[i].a2ddeadzone)
pState->Gamepad.wButtons |= XINPUT_GAMEPAD_DPAD_DOWN;
}
}
return ERROR_SUCCESS;
}
struct DataMap *DataMapDecodeBuffer(unsigned char *buf,int size) {
int c,x,n,i;
int32 sn,an;
int32 code,sze;
char *name;
unsigned char *tmp;
char type;
unsigned int off=0;
struct DataMap *ptr;
struct DataMapScalar *s;
struct DataMapArray *a;
ptr=DataMapMake();
if (ptr==NULL) return NULL;
ConvertToInt(buf+off,&code);
off+=sizeof(int32);
ConvertToInt(buf+off,&sze);
off+=sizeof(int32);
ConvertToInt(buf+off,&sn);
off+=sizeof(int32);
ConvertToInt(buf+off,&an);
off+=sizeof(int32);
if (sn>0) {
ptr->snum=sn;
ptr->scl=malloc(sizeof(struct DataMapScalar *)*sn);
if (ptr->scl==NULL) {
DataMapFree(ptr);
return NULL;
}
for (c=0;c<sn;c++) ptr->scl[c]=NULL;
}
if (an>0) {
ptr->anum=an;
ptr->arr=malloc(sizeof(struct DataMapArray *)*an);
if (ptr->arr==NULL) {
DataMapFree(ptr);
return NULL;
}
for (c=0;c<an;c++) ptr->arr[c]=NULL;
}
for (c=0;c<sn;c++) {
n=0;
while ((buf[off+n] !=0) && (off+n<size)) n++;
if (off+n>=size) break;
name=malloc(n+1);
if (name==NULL) break;
memcpy(name,buf+off,n+1);
off+=n+1;
type=buf[off];
off++;
s=malloc(sizeof(struct DataMapScalar));
if (s==NULL) {
free(name);
break;
}
s->name=name;
s->mode=1;
s->type=type;
ptr->scl[c]=s;
switch (s->type) {
case DATACHAR:
s->data.vptr=malloc(sizeof(char));
if (s->data.vptr==NULL) break;
s->data.cptr[0]=buf[off];
off++;
break;
case DATASHORT:
s->data.vptr=malloc(sizeof(int16));
if (s->data.vptr==NULL) break;
ConvertToShort(buf+off,s->data.sptr);
off+=sizeof(int16);
break;
case DATAINT:
s->data.vptr=malloc(sizeof(int32));
if (s->data.vptr==NULL) break;
ConvertToInt(buf+off,s->data.iptr);
off+=sizeof(int32);
break;
case DATAFLOAT:
s->data.vptr=malloc(sizeof(float));
if (s->data.vptr==NULL) break;
ConvertToFloat(buf+off,s->data.fptr);
off+=sizeof(float);
break;
case DATADOUBLE:
s->data.vptr=malloc(sizeof(double));
if (s->data.vptr==NULL) break;
ConvertToDouble(buf+off,s->data.dptr);
off+=sizeof(double);
break;
default:
n=0;
while ((buf[off+n] !=0) && (off+n<size)) n++;
if (off+n>=size) break;
s->data.vptr=malloc(sizeof(char *));
if (s->data.vptr==NULL) break;
tmp=realloc(ptr->buf,ptr->sze+n+1);
if (tmp==NULL) break;
ptr->buf=tmp;
memcpy(ptr->buf+ptr->sze,buf+off,n+1);
off+=n+1;
*(s->data.optr)=ptr->sze;
ptr->sze+=n+1;
break;
}
}
if (c !=sn) {
DataMapFree(ptr);
return NULL;
}
for (c=0;c<an;c++) {
n=0;
while ((buf[off+n] !=0) && (off+n<size)) n++;
if (off+n>=size) break;
name=malloc(n+1);
if (name==NULL) break;
memcpy(name,buf+off,n+1);
off+=n+1;
type=buf[off];
off++;
a=malloc(sizeof(struct DataMapArray));
if (a==NULL) {
free(name);
break;
}
a->name=name;
a->mode=3;
a->type=type;
ptr->arr[c]=a;
ConvertToInt(buf+off,(int32 *) &(a->dim));
off+=sizeof(int32);
a->rng=malloc(a->dim*sizeof(int32));
if (a->rng==NULL) break;
for (x=0;x<a->dim;x++) {
ConvertToInt(buf+off,&a->rng[x]);
off+=sizeof(int32);
}
if (x!=a->dim) break;
n=1;
for (x=0;x<a->dim;x++) n=a->rng[x]*n;
switch (a->type) {
case DATACHAR:
a->data.vptr=malloc(sizeof(char)*n);
if (a->data.vptr==NULL) break;
memcpy(a->data.cptr,buf+off,sizeof(char)*n);
off+=sizeof(char)*n;
break;
case DATASHORT:
a->data.vptr=malloc(sizeof(int16)*n);
if (a->data.vptr==NULL) break;
for (x=0;x<n;x++) {
ConvertToShort(buf+off,&a->data.sptr[x]);
off+=sizeof(int16);
}
break;
case DATAINT:
a->data.vptr=malloc(sizeof(int32)*n);
if (a->data.vptr==NULL) break;
for (x=0;x<n;x++) {
ConvertToInt(buf+off,&a->data.iptr[x]);
off+=sizeof(int32);
}
break;
case DATAFLOAT:
a->data.vptr=malloc(sizeof(float)*n);
if (a->data.vptr==NULL) break;
for (x=0;x<n;x++) {
ConvertToFloat(buf+off,&a->data.fptr[x]);
off+=sizeof(float);
}
break;
case DATADOUBLE:
a->data.vptr=malloc(sizeof(double)*n);
if (a->data.vptr==NULL) break;
for (x=0;x<n;x++) {
ConvertToDouble(buf+off,&a->data.dptr[x]);
off+=sizeof(double);
}
break;
default:
a->data.vptr=malloc(sizeof(char *)*n);
if (a->data.vptr==NULL) break;
for (x=0;x<n;x++) {
i=0;
while ((buf[off+i] !=0) && (off+i<size)) i++;
if (off+i>=size) break;
tmp=realloc(ptr->buf,ptr->sze+i+1);
if (tmp==NULL) break;
ptr->buf=tmp;
memcpy(ptr->buf+ptr->sze,buf+off,i+1);
a->data.optr[x]=ptr->sze;
ptr->sze+=i+1;
off+=i+1;
}
if (x !=n) break;
}
}
if (c !=an) {
DataMapFree(ptr);
return NULL;
}
for (c=0;c<ptr->snum;c++) {
if (ptr->scl[c]==NULL) continue;
s=ptr->scl[c];
if (s->type==DATASTRING)
*((char **) s->data.vptr)=(char *) (ptr->buf+*(s->data.optr));
}
for (c=0;c<ptr->anum;c++) {
if (ptr->arr[c]==NULL) continue;
a=ptr->arr[c];
if (a->type==DATASTRING) {
n=1;
for (x=0;x<a->dim;x++) n=a->rng[x]*n;
for (x=0;x<n;x++)
( (char **) a->data.vptr)[x]=(char *) (ptr->buf+a->data.optr[x]);
}
}
return ptr;
}
int raw_read_current(struct rawfp *fp,struct rawdata *raw_data) {
/* read raw data block from file */
int radar_parms_pat[]={1,2,2,17,4,2,2,14,4,4,2,4,0,0};
int i;
int16 range;
int j;
int16 prev_range;
int xcf_data;
unsigned int stat;
int16 num_byte;
int32 rec_num=0;
unsigned char *inbuf;
unsigned char *inbuf_ptr;
xcf_data = 0;
prev_range = -1;
inbuf=malloc(sizeof(struct rawdata));
/* zero out the raw data buffer */
memset(raw_data,0,sizeof(struct rawdata));
fp->rlen=0;
do {
if (ConvertReadShort(fp->rawfp,&num_byte) !=0) {
free(inbuf);
return -1;
}
fp->rlen+=num_byte;
fp->ptr+=num_byte;
num_byte = num_byte - 2;
stat = read(fp->rawfp,inbuf,num_byte);
if(stat != num_byte) {
free(inbuf);
return -1;
}
inbuf_ptr=inbuf;
ConvertToInt(inbuf_ptr,&rec_num);
} while (rec_num==0);
inbuf_ptr = inbuf_ptr + 12; /* skip rec_num + rawwrite */
num_byte = num_byte - 12;
/* zero out the raw data buffer */
/* copy radar_parms */
ConvertBlock(inbuf_ptr,radar_parms_pat);
memcpy((void *) &(raw_data->PARMS),inbuf_ptr,sizeof(struct radar_parms));
inbuf_ptr = inbuf_ptr + sizeof(struct radar_parms);
num_byte = num_byte - sizeof(struct radar_parms);
/* copy the pulse pattern */
for (i=0;i<raw_data->PARMS.MPPUL;i++) {
ConvertToShort(inbuf_ptr,&raw_data->PULSE_PATTERN[i]);
inbuf_ptr+=sizeof(int16);
num_byte-=sizeof(int16);
}
/* copy the lag table */
for(j=0;j < 2; ++j)
for(i=0; i < raw_data->PARMS.MPLGS; ++i) {
ConvertToShort(inbuf_ptr,&raw_data->LAG_TABLE[j][i]);
inbuf_ptr = inbuf_ptr + sizeof(int16);
num_byte = num_byte - sizeof(int16);
}
/* copy comment buffer */
memcpy(raw_data->COMBF,inbuf_ptr,ORIG_COMBF_SIZE);
inbuf_ptr = inbuf_ptr + ORIG_COMBF_SIZE;
num_byte = num_byte - ORIG_COMBF_SIZE;
/* decompress and copy the lag-0 powers */
for(i=0 ; i < raw_data->PARMS.NRANG ; ++i) {
raw_data->pwr0[i] = dcmpr(inbuf_ptr);
inbuf_ptr = inbuf_ptr + sizeof(int16);
num_byte = num_byte - sizeof(int16);
}
/* decompress and copy acfs */
while ( num_byte > 0 ) {
ConvertToShort(inbuf_ptr,&range);
--range;
inbuf_ptr = inbuf_ptr + sizeof(int16);
num_byte = num_byte - sizeof(int16);
if((range <= prev_range) && (raw_data->PARMS.XCF))
xcf_data = 1;
for(i = 0; i < raw_data->PARMS.MPLGS ; ++i) {
for(j=0 ; j < 2; ++j) {
if (xcf_data) raw_data->xcfd[range][i][j] = dcmpr(inbuf_ptr);
else raw_data->acfd[range][i][j] = dcmpr(inbuf_ptr);
inbuf_ptr = inbuf_ptr + sizeof(int16);
num_byte = num_byte - sizeof(int16);
}
}
prev_range = range;
}
fp->ctime=TimeYMDHMSToEpoch(raw_data->PARMS.YEAR,
raw_data->PARMS.MONTH,
raw_data->PARMS.DAY,
raw_data->PARMS.HOUR,
raw_data->PARMS.MINUT,
raw_data->PARMS.SEC);
free(inbuf);
return 0;
}
int CFitRead(struct CFitfp *fptr,struct CFitdata *ptr) {
float val;
int i;
if (fptr->fp !=-1) {
if (ConvertReadDouble(fptr->fp,&ptr->time) !=0) return -1;
if (ConvertReadShort(fptr->fp,&ptr->stid) !=0) return -1;
if (ConvertReadShort(fptr->fp,&ptr->scan) !=0) return -1;
if (ConvertReadShort(fptr->fp,&ptr->cp) !=0) return -1;
if (ConvertReadShort(fptr->fp,&ptr->bmnum) !=0) return -1;
if (ConvertReadFloat(fptr->fp,&ptr->bmazm) !=0) return -1;
if (ConvertReadShort(fptr->fp,&ptr->channel) !=0) return -1;
if (ConvertReadShort(fptr->fp,&ptr->intt.sc) !=0) return -1;
if (ConvertReadInt(fptr->fp,&ptr->intt.us) !=0) return -1;
if (ConvertReadShort(fptr->fp,&ptr->frang) !=0) return -1;
if (ConvertReadShort(fptr->fp,&ptr->rsep) !=0) return -1;
if (ConvertReadShort(fptr->fp,&ptr->rxrise) !=0) return -1;
if (ConvertReadShort(fptr->fp,&ptr->tfreq) !=0) return -1;
if (ConvertReadInt(fptr->fp,&ptr->noise) !=0) return -1;
if (ConvertReadShort(fptr->fp,&ptr->atten) !=0) return -1;
if (ConvertReadShort(fptr->fp,&ptr->nave) !=0) return -1;
if (ConvertReadShort(fptr->fp,&ptr->nrang) !=0) return -1;
} else {
if ((fptr->fptr+sizeof(double)+7*sizeof(int16)+
sizeof(int32)+sizeof(float))>fptr->fsze) return -1;
ConvertToDouble(&fptr->fbuf[fptr->fptr],&ptr->time);
fptr->fptr+=sizeof(double);
ConvertToShort(fptr->fbuf+fptr->fptr,&ptr->stid);
fptr->fptr+=sizeof(int16);
ConvertToShort(fptr->fbuf+fptr->fptr,&ptr->scan);
fptr->fptr+=sizeof(int16);
ConvertToShort(fptr->fbuf+fptr->fptr,&ptr->cp);
fptr->fptr+=sizeof(int16);
ConvertToShort(fptr->fbuf+fptr->fptr,&ptr->bmnum);
fptr->fptr+=sizeof(int16);
ConvertToFloat(fptr->fbuf+fptr->fptr,&ptr->bmazm);
fptr->fptr+=sizeof(float);
ConvertToShort(fptr->fbuf+fptr->fptr,&ptr->channel);
fptr->fptr+=sizeof(int16);
ConvertToShort(fptr->fbuf+fptr->fptr,&ptr->intt.sc);
fptr->fptr+=sizeof(int16);
ConvertToInt(fptr->fbuf+fptr->fptr,&ptr->intt.us);
fptr->fptr+=sizeof(int32);
ConvertToShort(fptr->fbuf+fptr->fptr,&ptr->frang);
fptr->fptr+=sizeof(int16);
ConvertToShort(fptr->fbuf+fptr->fptr,&ptr->rsep);
fptr->fptr+=sizeof(int16);
ConvertToShort(fptr->fbuf+fptr->fptr,&ptr->rxrise);
fptr->fptr+=sizeof(int16);
ConvertToShort(fptr->fbuf+fptr->fptr,&ptr->tfreq);
fptr->fptr+=sizeof(int16);
ConvertToInt(fptr->fbuf+fptr->fptr,&ptr->noise);
fptr->fptr+=sizeof(int32);
ConvertToShort(fptr->fbuf+fptr->fptr,&ptr->atten);
fptr->fptr+=sizeof(int16);
ConvertToShort(fptr->fbuf+fptr->fptr,&ptr->nave);
fptr->fptr+=sizeof(int16);
ConvertToShort(fptr->fbuf+fptr->fptr,&ptr->nrang);
fptr->fptr+=sizeof(int16);
}
fptr->ctime=ptr->time;
if (fptr->fp !=-1) {
if (read(fptr->fp,&ptr->num,1) !=1) return -1;
if (read(fptr->fp,ptr->rng,ptr->num) !=ptr->num) return -1;
} else {
if (fptr->fptr>=fptr->fsze) return -1;
ptr->num=fptr->fbuf[fptr->fptr];
fptr->fptr+=1;
if ((fptr->fptr+ptr->num)>=fptr->fsze) return -1;
memcpy(ptr->rng,&fptr->fbuf[fptr->fptr],ptr->num);
fptr->fptr+=ptr->num;
}
for (i=0;i<ptr->num;i++) {
if (fptr->fp !=-1) {
if (read(fptr->fp,&ptr->data[i].gsct,1) !=1) return -1;
if (ptr->data[i].gsct==EOF) return -1;
if (ConvertReadFloat(fptr->fp,&val) !=0) return -1;
ptr->data[i].p_0=val;
if (ConvertReadFloat(fptr->fp,&val) !=0) return -1;
ptr->data[i].p_0_e=val;
if (ConvertReadFloat(fptr->fp,&val) !=0) return -1;
ptr->data[i].v=val;
if (ConvertReadFloat(fptr->fp,&val) !=0) return -1;
ptr->data[i].p_l=val;
if (ConvertReadFloat(fptr->fp,&val) !=0) return -1;
ptr->data[i].w_l=val;
if (ConvertReadFloat(fptr->fp,&val) !=0) return -1;
ptr->data[i].v_e=val;
if (ConvertReadFloat(fptr->fp,&val) !=0) return -1;
ptr->data[i].p_l_e=val;
if (ConvertReadFloat(fptr->fp,&val) !=0) return -1;
ptr->data[i].w_l_e=val;
} else {
if ((fptr->fptr+1+sizeof(float)*6)>=fptr->fsze) return -1;
ptr->data[i].gsct=fptr->fbuf[fptr->fptr];
fptr->fptr+=1;
ConvertToFloat(fptr->fbuf+fptr->fptr,&val);
fptr->fptr+=sizeof(float);
ptr->data[i].p_0=val;
ConvertToFloat(fptr->fbuf+fptr->fptr,&val);
fptr->fptr+=sizeof(float);
ptr->data[i].p_0_e=val;
ConvertToFloat(fptr->fbuf+fptr->fptr,&val);
fptr->fptr+=sizeof(float);
ptr->data[i].v=val;
ConvertToFloat(fptr->fbuf+fptr->fptr,&val);
fptr->fptr+=sizeof(float);
ptr->data[i].p_l=val;
ConvertToFloat(fptr->fbuf+fptr->fptr,&val);
fptr->fptr+=sizeof(float);
ptr->data[i].w_l=val;
ConvertToFloat(fptr->fbuf+fptr->fptr,&val);
fptr->fptr+=sizeof(float);
ptr->data[i].v_e=val;
ConvertToFloat(fptr->fbuf+fptr->fptr,&val);
fptr->fptr+=sizeof(float);
ptr->data[i].p_l_e=val;
ConvertToFloat(fptr->fbuf+fptr->fptr,&val);
fptr->fptr+=sizeof(float);
ptr->data[i].w_l_e=val;
}
}
return 0;
}
