_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; }