_declspec(dllexport) BDiffResult __stdcall diff_img_byte(BImage left, BImage right, DiffOptions options) {
Image leftf = ConvertToFloat(left);
Image rightf = ConvertToFloat(right);
DiffResult resultf = diff_img(leftf, rightf, options);
BDiffResult resultb = { ConvertToByte(resultf.img), resultf.similarity };
_aligned_free(resultf.img.r);
_aligned_free(leftf.r);
_aligned_free(rightf.r);
return resultb;
}
void PtexReader::getPixel(int faceid, int u, int v,
float* result, int firstchan, int nchannels,
Ptex::Res res)
{
memset(result, 0, nchannels);
// clip nchannels against actual number available
nchannels = PtexUtils::min(nchannels,
_header.nchannels-firstchan);
if (nchannels <= 0) return;
// get raw pixel data
PtexPtr<PtexFaceData> data ( getData(faceid, res) );
if (!data) return;
void* pixel = alloca(_pixelsize);
data->getPixel(u, v, pixel);
// adjust for firstchan offset
int datasize = DataSize(_header.datatype);
if (firstchan)
pixel = (char*) pixel + datasize * firstchan;
// convert/copy to result as needed
if (_header.datatype == dt_float)
memcpy(result, pixel, datasize * nchannels);
else
ConvertToFloat(result, pixel, _header.datatype, nchannels);
}
bool Rasterizer::UpdateZBuff(float Z, float nearZ, float farZ, int index)
{
float tempBuff = (Z - _nearPlane)/(_farPlane - _nearPlane);
if ( (tempBuff <= ConvertToFloat(_zBuff[index])) && (tempBuff > 0.0f))
{
_zBuff[index] = ConvertTo16Bit(tempBuff);
return true;
}
else
{
return false;
}
}
int ConvertReadFloat(int fp,float *val) {
unsigned char tmp[4];
int s=0,o=0,l=4;
while (o<4) {
s=read(fp,tmp+o,l);
o=o+s;
l=l-s;
if (s==0) return -1;
if (s==-1) return -1;
}
ConvertToFloat(tmp,val);
return 0;
}
//============================================================================//
//============================================================================//
void ReadArgs(int argc, char **argv, char *&silo_path, char *&probe_path,
int &cycle, float &phi_rot) {
// Count the initial command line arguments:
if(!(argc == (1+4))) {
char message[1001];
sprintf(message," %s\n %s",
"An improper number of command line arguments was found.",
stopmsg);
StopExecution(message);
}
// Distribute the command line arguments
silo_path = argv[1];
probe_path = argv[2];
VerifyPath(silo_path,stopmsg);
VerifyPath(probe_path,stopmsg);
ConvertToInt(argv[3],cycle,stopmsg);
ConvertToFloat(argv[4],phi_rot,stopmsg);
}
int CDVDAudioCodecFFmpeg::Decode(uint8_t* pData, int iSize)
{
int iBytesUsed, got_frame;
if (!m_pCodecContext) return -1;
m_iBufferSize1 = AVCODEC_MAX_AUDIO_FRAME_SIZE ;
m_iBufferSize2 = 0;
AVPacket avpkt;
m_dllAvCodec.av_init_packet(&avpkt);
avpkt.data = pData;
avpkt.size = iSize;
iBytesUsed = m_dllAvCodec.avcodec_decode_audio4( m_pCodecContext
, m_pFrame1
, &got_frame
, &avpkt);
if (iBytesUsed < 0 || !got_frame)
{
m_iBufferSize1 = 0;
return iBytesUsed;
}
m_iBufferSize1 = m_dllAvUtil.av_samples_get_buffer_size(NULL, m_pCodecContext->channels, m_pFrame1->nb_samples, m_pCodecContext->sample_fmt, 1);
/* some codecs will attempt to consume more data than what we gave */
if (iBytesUsed > iSize)
{
CLog::Log(LOGWARNING, "CDVDAudioCodecFFmpeg::Decode - decoder attempted to consume more data than given");
iBytesUsed = iSize;
}
if(m_iBufferSize1 == 0 && iBytesUsed >= 0)
m_iBuffered += iBytesUsed;
else
m_iBuffered = 0;
if(m_bLpcmMode || m_bNeedConversion)
ConvertToFloat();
return iBytesUsed;
}
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;
}
_declspec(dllexport) DiffResult __stdcall diff_img(Image left, Image right, DiffOptions options) {
if (options.ignoreColor) {
makeGreyscale(left);
makeGreyscale(right);
}
float* imgMem = (float*)_aligned_malloc(left.width * left.height * sizeof(float) * 4, 16);
int colorOffset = left.width * left.height;
Image diff = { left.width, left.height, left.stride, imgMem, imgMem + colorOffset, imgMem + colorOffset * 2, imgMem + colorOffset * 3 };
float* drp = diff.r;
float* dgp = diff.g;
float* dbp = diff.b;
float* dap = diff.a;
float* lrp = left.r;
float* lgp = left.g;
float* lbp = left.b;
float* lap = left.a;
float* rrp = right.r;
float* rgp = right.g;
float* rbp = right.b;
float* rap = right.a;
Color error = ConvertToFloat(options.errorColor);
auto er = _mm_set_ps1(error.r);
auto eg = _mm_set_ps1(error.g);
auto eb = _mm_set_ps1(error.b);
auto ea = _mm_set_ps1(error.a);
auto tolerance = _mm_set_ps1(options.tolerance);
auto overlayTransparency = _mm_set_ps1(options.overlayTransparency);
OverlayType overlayType = options.overlayType;
byte weightByDiffPercentage = options.weightByDiffPercentage;
auto diffPixelCount = _mm_set_epi32(0, 0, 0, 0);
auto onei = _mm_set1_epi32(1);
auto one = _mm_set1_ps(1);
auto zero = _mm_set1_ps(0);
for (int y = 0; y < left.height; y++) {
for (int x = 0; x < left.width; x+=4) {
auto lr = _mm_load_ps(lrp);
auto lg = _mm_load_ps(lgp);
auto lb = _mm_load_ps(lbp);
auto la = _mm_load_ps(lap);
auto rr = _mm_load_ps(rrp);
auto rg = _mm_load_ps(rgp);
auto rb = _mm_load_ps(rbp);
auto ra = _mm_load_ps(rap);
auto rdiff = _mm_sub_ps(rr, lr);
auto gdiff = _mm_sub_ps(rg, lg);
auto bdiff = _mm_sub_ps(rb, lb);
auto adiff = _mm_sub_ps(ra, la);
auto distance = _mm_mul_ps(rdiff, rdiff);
distance = _mm_add_ps(distance, _mm_mul_ps(gdiff, gdiff));
distance = _mm_add_ps(distance, _mm_mul_ps(bdiff, bdiff));
distance = _mm_add_ps(distance, _mm_mul_ps(adiff, adiff));
distance = _mm_sqrt_ps(distance);
auto t = overlayTransparency;
if (weightByDiffPercentage) {
t = _mm_mul_ps(t, distance);
}
auto isdiff = _mm_cmpgt_ps(distance, tolerance);
t = _mm_min_ps(one, _mm_max_ps(zero, t));
auto mlr = rr;
auto mlg = rg;
auto mlb = rb;
auto mla = ra;
if (overlayType == OverlayType::Movement) {
mlr = _mm_mul_ps(mlr, er);
mlg = _mm_mul_ps(mlg, eg);
mlb = _mm_mul_ps(mlb, eb);
mla = _mm_mul_ps(mla, ea);
}
auto oneMinusT = _mm_sub_ps(one, t);
auto mixedR = _mm_add_ps(_mm_mul_ps(mlr, oneMinusT), _mm_mul_ps(er, t));
auto mixedG = _mm_add_ps(_mm_mul_ps(mlg, oneMinusT), _mm_mul_ps(eg, t));
auto mixedB = _mm_add_ps(_mm_mul_ps(mlb, oneMinusT), _mm_mul_ps(eb, t));
auto mixedA = one;
if (overlayType != OverlayType::Movement) {
mixedA = _mm_add_ps(_mm_mul_ps(mla, oneMinusT), _mm_mul_ps(ea, t));
}
// (((b ^ a) & mask)^a)
auto dr = _mm_xor_ps(lr, _mm_and_ps(isdiff, _mm_xor_ps(mixedR, lr)));
auto dg = _mm_xor_ps(lg, _mm_and_ps(isdiff, _mm_xor_ps(mixedG, lg)));
auto db = _mm_xor_ps(lb, _mm_and_ps(isdiff, _mm_xor_ps(mixedB, lb)));
auto da = _mm_xor_ps(la, _mm_and_ps(isdiff, _mm_xor_ps(mixedA, la)));
diffPixelCount = _mm_xor_si128(diffPixelCount,
_mm_and_si128(_mm_castps_si128(isdiff),
_mm_xor_si128(_mm_add_epi32(diffPixelCount, onei),
diffPixelCount)));
_mm_store_ps(drp, dr);
_mm_store_ps(dgp, dg);
_mm_store_ps(dbp, db);
_mm_store_ps(dap, da);
drp+=4;
dgp+=4;
dbp+=4;
dap+=4;
lrp+=4;
lgp+=4;
lbp+=4;
lap+=4;
rrp+=4;
rgp+=4;
rbp+=4;
rap+=4;
}
}
int* pixelCounts = (int*)_aligned_malloc(4 * sizeof(int), 16);
_mm_store_si128((__m128i*)pixelCounts, diffPixelCount);
int totalCount = pixelCounts[0] + pixelCounts[1] + pixelCounts[2] + pixelCounts[3];
_aligned_free(pixelCounts);
return{ diff, 1.0f - float(totalCount) / (left.height * left.width - left.height * left.stride) };
}
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 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;
}
