void Dot3Protocol::loadConfigWidget()
{
configWidget();
configForm->cbOverrideLength->setChecked(
fieldData(dot3_is_override_length, FieldValue).toBool());
configForm->leLength->setText(
fieldData(dot3_length, FieldValue).toString());
}
int ArpProtocol::protocolFrameVariableCount() const
{
int count = AbstractProtocol::protocolFrameVariableCount();
if (fieldData(arp_senderHwAddrMode, FieldValue).toUInt()
!= uint(OstProto::Arp::kFixed))
{
count = AbstractProtocol::lcm(count,
fieldData(arp_senderHwAddrCount, FieldValue).toUInt());
}
if (fieldData(arp_senderProtoAddrMode, FieldValue).toUInt()
!= uint(OstProto::Arp::kFixed))
{
count = AbstractProtocol::lcm(count,
fieldData(arp_senderProtoAddrCount, FieldValue).toUInt());
}
if (fieldData(arp_targetHwAddrMode, FieldValue).toUInt()
!= uint(OstProto::Arp::kFixed))
{
count = AbstractProtocol::lcm(count,
fieldData(arp_targetHwAddrCount, FieldValue).toUInt());
}
if (fieldData(arp_targetProtoAddrMode, FieldValue).toUInt()
!= uint(OstProto::Arp::kFixed))
{
count = AbstractProtocol::lcm(count,
fieldData(arp_targetProtoAddrCount, FieldValue).toUInt());
}
return count;
}
ID3v2_AttachedPictureFrame::ID3v2_AttachedPictureFrame(const SjByteVector &data, ID3v2_FrameHeader *h)
: ID3v2_Frame(h)
{
m_textEncoding = SJ_LATIN1;
m_type = ID3v2_Other;
parseFields(fieldData(data));
}
void fluid_dampen(fluid *in_f, int y, pvt_fluidMode *mode)
{
struct dampen * d = &mode->dampen;
field *f = d->f;
float scale = d->e;
int w = fieldWidth(f);
int nc = fieldComponents(f);
int sx = fieldStrideX(f);
int sy = fieldStrideY(f)*y;
float *ptr = fieldData(f);
int i;
for (i=0; i<w; i++)
{
int c;
for (c=0; c<nc; c++)
{
fluidFloatPointer(ptr, sy)[c] *= scale;
}
sy+=sx;
}
}
// -----------------------------------------------------------------------------
// CPIMAgnToDoAdapter::ReadDateFieldsL
// (other items were commented in a header)
// -----------------------------------------------------------------------------
//
void CPIMAgnToDoAdapter::ReadDateFieldsL(MPIMItemData& aData, CCalEntry& aEntry)
{
JELOG2(EPim);
TTime nullTime = Time::NullTTime();
// The Agenda todo entry end field is the due date
TTime due(aEntry.EndTimeL().TimeLocalL());
if (due != nullTime)
{
// Set due to the PIM API specific due date, in this case, the start of date
// Note that PIM API uses times as UTC times so the due date must be in
// correct format. Previously requested as local time -> do not change
TPIMDate pimDueDate(StartOfDay(due));
// Date must be converted UTC time because acquired as local above
ConvertTimeL(pimDueDate, EPIMDateUTC);
TPIMFieldData dueFieldData(EPIMToDoDue, KPIMAttrNone, pimDueDate);
aData.AddValueL(dueFieldData);
// Get alarm. Ownership is transferred to the caller. Alarm cannot be set
// if the due date is not set because the calculation is done as an offset
// from the ToDo due date.
CCalAlarm* calAlarm = aEntry.AlarmL();
if (calAlarm)
{
TTimeIntervalMinutes nativeValue = calAlarm->TimeOffset();
// The alarm is not needed anymore so it can be deleted
delete calAlarm;
calAlarm = NULL;
// Change the time to the start of the due date
TTime startOfDayLocal(StartOfDay(due));
// Calculate the difference from the start of due date and start time including
// the original alarm offset which was previously read
TTimeIntervalMinutes temp(0);
User::LeaveIfError(startOfDayLocal.MinutesFrom(due, temp));
// Since it is not possible to substract TTimeIntervalMinutes
// from TTime (probably a Symbian error), the difference has
// to be calculated using the following way...
TInt alarm = (nativeValue.Int() + temp.Int()) * KPIMSecondsInMinute;
// Add alarm value to the item
TPIMFieldData fieldData(EPIMToDoExtAlarm, EPIMFieldInt,
KPIMAttrNone, alarm);
// Add value to the PIM item data
aData.AddValueL(fieldData);
}
}
// Completion date. If the item has a completion date, the item is then completed
// and completed flag is set to true in PIM API. Null time if not crossed out.
TTime completed = aEntry.CompletedTimeL().TimeUtcL();
if (completed != nullTime)
{
TPIMFieldData dateData(EPIMToDoCompletionDate, KPIMAttrNone, completed);
aData.AddValueL(dateData);
// Note that boolean and integer fields must be identified in the constructor
TPIMFieldData flag(EPIMToDoCompleted, EPIMFieldBoolean, KPIMAttrNone,
ETrue);
aData.AddValueL(flag);
}
}
void ID3v2_Frame::parse(const SjByteVector &data)
{
if(m_header)
m_header->setData(data);
else
m_header = new ID3v2_FrameHeader(data);
parseFields(fieldData(data));
}
int GmpProtocol::protocolFrameVariableCount() const
{
int count = AbstractProtocol::protocolFrameVariableCount();
// No fields vary for Ssm Report
if (isSsmReport())
return count;
// For all other msg types, check the group mode
if (fieldData(kGroupMode, FieldValue).toUInt()
!= uint(OstProto::Gmp::kFixed))
{
count = AbstractProtocol::lcm(count,
fieldData(kGroupCount, FieldValue).toUInt());
}
return count;
}
// -----------------------------------------------------------------------------
// CPIMAgnApptAdapter::ReadEndFromAgnL
// Reads Agenda entry's end field and converts it into PIM Item field.
// -----------------------------------------------------------------------------
//
void CPIMAgnApptAdapter::ReadEndFromAgnL(MPIMEventItem& aItem,
CCalEntry& aEntry)
{
JELOG2(EPim);
TTime agnEndTime = aEntry.EndTimeL().TimeUtcL();
if (agnEndTime != Time::NullTTime())
{
TPIMFieldData fieldData(EPIMEventEnd, KPIMAttrNone, agnEndTime);
aItem.ItemData().AddValueL(fieldData);
}
}
// -----------------------------------------------------------------------------
// CPIMAgnEventAdapter::ReadNoteFromAgnL
// Reads Agenda entry's notes field and converts it into PIM Item field.
// -----------------------------------------------------------------------------
//
void CPIMAgnEventAdapter::ReadNoteFromAgnL(MPIMEventItem& aItem,
CCalEntry& aEntry)
{
JELOG2(EPim);
const TDesC& note = aEntry.DescriptionL();
if (note != KNullDesC)
{
TPIMFieldData fieldData(EPIMEventNote, KPIMAttrNone, note.AllocLC());
aItem.ItemData().AddValueL(fieldData);
CleanupStack::Pop(); // notes.AllocLC( )
}
}
// -----------------------------------------------------------------------------
// CPIMAgnToDoAdapter::ReadStringFieldsL
// (other items were commented in a header)
// -----------------------------------------------------------------------------
//
void CPIMAgnToDoAdapter::ReadStringFieldsL(MPIMItemData& aData,
CCalEntry& aEntry)
{
JELOG2(EPim);
// Summary is converted to PIM API ToDo summary field
const TDesC& sum = aEntry.SummaryL();
if (sum != KNullDesC)
{
TPIMFieldData fieldData(EPIMToDoSummary, KPIMAttrNone, sum.AllocLC());
aData.AddValueL(fieldData);
CleanupStack::Pop(); // agnSummary.AllocLC()
}
// Description is converted to PIM API ToDo note field
const TDesC& note = aEntry.DescriptionL();
if (note != KNullDesC)
{
TPIMFieldData fieldData(EPIMToDoNote, KPIMAttrNone, note.AllocLC());
aData.AddValueL(fieldData);
CleanupStack::Pop(); // AllocLC
}
}
// -----------------------------------------------------------------------------
// CPIMAgnEventAdapter::ReadLocationFromAgnL
// Reads Agenda entry's location field and converts it into PIM Item field.
// -----------------------------------------------------------------------------
//
void CPIMAgnEventAdapter::ReadLocationFromAgnL(MPIMEventItem& aItem,
CCalEntry& aEntry)
{
JELOG2(EPim);
const TDesC& agnLocation = aEntry.LocationL();
if (agnLocation != KNullDesC)
{
TPIMFieldData fieldData(EPIMEventLocation, KPIMAttrNone,
agnLocation.AllocLC());
aItem.ItemData().AddValueL(fieldData);
CleanupStack::Pop(); // agnLocation.AllocLC()
}
}
// -----------------------------------------------------------------------------
// CPIMAgnMemoAdapter::ReadEndFromAgnL
// Reads Agenda entry's end field and converts it into PIM Item field.
// -----------------------------------------------------------------------------
//
void CPIMAgnMemoAdapter::ReadEndFromAgnL(MPIMEventItem& aItem,
CCalEntry& aEntry)
{
JELOG2(EPim);
TTime agnEndDate(aEntry.EndTimeL().TimeUtcL());
if (agnEndDate != Time::NullTTime())
{
// TTime end date, as a TTime but without a time component.
TPIMFieldData fieldData(EPIMEventEnd, KPIMAttrNone, agnEndDate);
aItem.ItemData().AddValueL(fieldData);
}
}
bool GetDeviceDescriptorSets::Response::match_data(const InertialDataField& field)
{
InertialPacket::Payload fieldData(field.fieldData());
//verify the field is the minimum size
if(fieldData.size() < 2)
{
return false;
}
//call match from the super class as well
return GenericInertialCommand::Response::match_data(field);
}
// -----------------------------------------------------------------------------
// CPIMAgnEventAdapter::ReadAlarmFromAgnL
// Reads alarm offset from the native Calendar entry. In case of Anniversary,
// the offset is calculated from the midnight since native Calendar supports
// only dates in these types of entries
// -----------------------------------------------------------------------------
//
void CPIMAgnEventAdapter::ReadAlarmFromAgnL(MPIMEventItem& aItem,
CCalEntry& aEntry)
{
JELOG2(EPim);
CCalAlarm* calAlarm = aEntry.AlarmL();
// The previous function call returns NULL if there is no alarm
// set in the item. The ownership is transferred to the caller
// if the alarm values has been added to the item.
if (calAlarm)
{
TTimeIntervalMinutes nativeValue = calAlarm->TimeOffset();
// The alarm is not needed anymore so it can be deleted
delete calAlarm;
calAlarm = NULL;
// nativeValue.Int() );
// Convert the alarm value based on the start time of the entry
CCalEntry::TType entryType = aEntry.EntryTypeL();
// Events (memos) and anniversaries do not have time in the native
// side, therefore alarm field in those entries need to be calculated
// from the end of the day
if (entryType == CCalEntry::EAnniv)
{
TTime start(aEntry.StartTimeL().TimeLocalL());
// Change the time to the end of the start date
TTime startOfDayLocal(start);
startOfDayLocal = StartOfDay(startOfDayLocal);
// Calculate the difference from end of day and start time including
// the original alarm offset which was previously read
TTimeIntervalMinutes temp(0);
User::LeaveIfError(startOfDayLocal.MinutesFrom(start, temp));
// Since it is not possible to substract TTimeIntervalMinutes
// from TTime (probably a Symbian error), the difference has
// to be calculated using the following way...
nativeValue = nativeValue.Int() + temp.Int();
}
TInt alarmValue = nativeValue.Int() * KPIMSecondsInMinute;
// alarmValue );
// Add alarm value to the item
TPIMFieldData fieldData(EPIMEventAlarm, EPIMFieldInt, KPIMAttrNone,
alarmValue);
aItem.ItemData().AddValueL(fieldData);
}
}
// -----------------------------------------------------------------------------
// CPIMAgnEventAdapter::ReadClassFromAgnL
// Reads entry's class details and converts them into PIM class.
// -----------------------------------------------------------------------------
//
void CPIMAgnEventAdapter::ReadClassFromAgnL(MPIMEventItem& aItem,
CCalEntry& aEntry)
{
JELOG2(EPim);
TPIMEventClassValue eClassValue = EPIMEventClassPrivate;
const CCalEntry::TReplicationStatus replicationStatus =
aEntry.ReplicationStatusL();
// Map calendar entry values to pim value
switch (replicationStatus)
{
case CCalEntry::EOpen:
{
eClassValue = EPIMEventClassPublic;
break;
}
case CCalEntry::EPrivate:
{
eClassValue = EPIMEventClassPrivate;
break;
}
case CCalEntry::ERestricted:
{
eClassValue = EPIMEventClassConfidential;
break;
}
default:
{
User::Leave(KErrArgument);
break;
}
}
TPIMFieldData fieldData(EPIMEventClass, EPIMFieldInt, KPIMAttrNone,
eClassValue);
// Set value for the class item
aItem.ItemData().AddValueL(fieldData);
}
//Simply generate positions for advection...
void fluid_advection_stam_repos(fluid *in_f, const int y, pvt_fluidMode *mode)
{
struct mccormack_vel_repos *data = &mode->mccormack_vel_repos;
int x; //Simple looping var
int w = fieldWidth(data->srcVelX); //Width of the data
int h = fieldHeight(data->srcVelX);
int sY = fieldStrideY(data->srcVelY);
x128f timestep = {-data->timestep,-data->timestep,-data->timestep,-data->timestep};
const float *srcVelX = fieldData(data->srcVelX);
const float *srcVelY = fieldData(data->srcVelY);
float *dstReposX = fieldData(data->dstReposX);
float *dstReposY = fieldData(data->dstReposY);
const int curxy = y*sY;
const int w2 = w/4;
//printf("%i %i\n", w2, w);
x128f vMin = {-ADVECT_DIST, -ADVECT_DIST, -ADVECT_DIST, -ADVECT_DIST};
x128f vMax = {ADVECT_DIST, ADVECT_DIST, ADVECT_DIST, ADVECT_DIST};
const x128f *vSrcVelX = (x128f*)fluidFloatPointer(srcVelX, curxy);
const x128f *vSrcVelY = (x128f*)fluidFloatPointer(srcVelY, curxy);
x128f *vDstReposX = (x128f*)fluidFloatPointer(dstReposX, curxy);
x128f *vDstReposY = (x128f*)fluidFloatPointer(dstReposY, curxy);
x128f vX = {0.0f, 1.0f, 2.0f, 3.0f};
const x128f vY = {y, y, y, y};
const x128f v4 = {4.0f, 4.0f, 4.0f, 4.0f};
const x128f vW = {w-1.01f,w-1.01f,w-1.01f,w-1.01f};
const x128f vH = {h-1.01f,h-1.01f,h-1.01f,h-1.01f};
for (x=0; x<w2; x++)
{
//Basic...
u128f fVelX, fVelY;
fVelX.v = x_mul(timestep, vSrcVelX[x]);
fVelY.v = x_mul(timestep, vSrcVelY[x]);
//Advect forward in time...
x128f fSrcVelX = x_clamp(fVelX.v, vMin, vMax);
x128f fSrcVelY = x_clamp(fVelY.v, vMin, vMax);
//Go forward
x128f fwdX = x_clamp(x_add(fSrcVelX, vX), x_simd_zero, vW);
x128f fwdY = x_clamp(x_add(fSrcVelY, vY), x_simd_zero, vH);
vDstReposX[x] = fwdX;
vDstReposY[x] = fwdY;
vX = x_add(vX, v4);
}
}
ID3v2_CommentsFrame::ID3v2_CommentsFrame(const SjByteVector &data, ID3v2_FrameHeader *h) : ID3v2_Frame(h)
{
m_textEncoding = SJ_LATIN1;
parseFields(fieldData(data));
}
//Basic advection of only the velocity...
void fluid_advection_stam_velocity_npt(fluid *in_f, int y, pvt_fluidMode *mode)
{
int x;
int w = fieldWidth(mode->advection_stam_velocity.srcVelX);
int h = fieldHeight(mode->advection_stam_velocity.srcVelY);
float *velX = fieldData(mode->advection_stam_velocity.srcVelX);
float *velY = fieldData(mode->advection_stam_velocity.srcVelY);
float *velDestX = fieldData(mode->advection_stam_velocity.dstVelX);
float *velDestY = fieldData(mode->advection_stam_velocity.dstVelY);
float *repDestX = fieldData(mode->advection_stam_velocity.dstReposX);
float *repDestY = fieldData(mode->advection_stam_velocity.dstReposY);
int sX = fieldStrideX(mode->advection_stam_velocity.srcVelX);
int sY = fieldStrideY(mode->advection_stam_velocity.srcVelY);
float timestep = -mode->advection_stam_velocity.timestep * 0.1f;
//Loop over the data and do the desired computation
float fx;
float fy = (float)y;
x=0;
fx=0;
while(x<w)
{
float fDataX = fluidFloatPointer(velX, x*sX + y*sY)[0];
float fDataY = fluidFloatPointer(velY, x*sX + y*sY)[0];
/*Find the cell back in time (keep a -10,10 radius)*/
float backX = timestep * fDataX + fx;
float backY = timestep * fDataY + fy;
int nBackX = (int)backX ;
int nBackY = (int)backY ;
float scaleX = backX - (float)(nBackX );
float scaleY = backY - (float)(nBackY );
/*Clamp as it's easier to parallelize given the scheduler*/
nBackX = fluidClamp(nBackX , 0,w-2);
nBackY = fluidClamp(nBackY , 0,h-2);
/*That was easy... now advect the velocity...*/
float *fVelDestX = fluidFloatPointer(velDestX, x*sX + y*sY);
float *fVelDestY = fluidFloatPointer(velDestY, x*sX + y*sY);
int offBackX = nBackX * sX;
int offBackY = nBackY * sY;
int offX2 = offBackX + sX;
int offY2 = offBackY + sY;
float bZZ_x = fluidFloatPointer(velX, offBackX + offBackY )[0];
float bOZ_x = fluidFloatPointer(velX, offX2 + offBackY )[0];
float bZO_x = fluidFloatPointer(velX, offBackX + offY2 )[0];
float bOO_x = fluidFloatPointer(velX, offX2 + offY2 )[0];
float bZZ_y = fluidFloatPointer(velY, offBackX + offBackY )[0];
float bOZ_y = fluidFloatPointer(velY, offX2 + offBackY )[0];
float bZO_y = fluidFloatPointer(velY, offBackX + offY2 )[0];
float bOO_y = fluidFloatPointer(velY, offX2 + offY2 )[0];
//Second velocities are here!!!!
int i;
for (i=0; i<9;i++)
{
fDataX = fluidLinearInterpolation(scaleX , scaleY ,
bZZ_x , bOZ_x , bZO_x , bOO_x );
fDataY = fluidLinearInterpolation(scaleX , scaleY ,
bZZ_y , bOZ_y , bZO_y , bOO_y );
//Compute using the next characteristic that we find (follow the curve!)
backX += timestep * fDataX;
backY += timestep * fDataY;
nBackX = (int)backX;
nBackY = (int)backY;
scaleX = backX - (float)nBackX;
scaleY = backY - (float)nBackY;
nBackX = fluidClamp(nBackX, 0, w-2);
nBackY = fluidClamp(nBackY, 0, h-2);
offBackX = nBackX * sX;
offBackY = nBackY * sY;
offX2 = offBackX + sX;
offY2 = offBackY + sY;
bZZ_x = fluidFloatPointer(velX, offBackX + offBackY )[0];
bOZ_x = fluidFloatPointer(velX, offX2 + offBackY )[0];
bZO_x = fluidFloatPointer(velX, offBackX + offY2 )[0];
bOO_x = fluidFloatPointer(velX, offX2 + offY2 )[0];
bZZ_y = fluidFloatPointer(velY, offBackX + offBackY )[0];
bOZ_y = fluidFloatPointer(velY, offX2 + offBackY )[0];
bZO_y = fluidFloatPointer(velY, offBackX + offY2 )[0];
bOO_y = fluidFloatPointer(velY, offX2 + offY2 )[0];
//Second velocities are here!!!!
fDataX = fluidLinearInterpolation(scaleX , scaleY ,
bZZ_x , bOZ_x , bZO_x , bOO_x );
fDataY = fluidLinearInterpolation(scaleX , scaleY ,
bZZ_y , bOZ_y , bZO_y , bOO_y );
}
backX = fluidClamp(backX, 0, w-2);
backY = fluidClamp(backY, 0, h-2);
fluidFloatPointer(repDestX, x*sX + y*sY)[0] = backX;
fluidFloatPointer(repDestY, x*sX + y*sY)[0] = backY;
fVelDestX[0] = fDataX;
fVelDestY[0] = fDataY;
x++;
fx++;
}
}
int TextProtocol::protocolFrameSize(int streamIndex) const
{
return fieldData(textProto_text, FieldFrameValue, streamIndex)
.toByteArray().size() ;
}
void fluid_genPressure_black(fluid *in_f, int y, pvt_fluidMode *mode)
{
struct pressure *p = &mode->pressure;
int w = fieldWidth(p->velX);
int h = fieldHeight(p->velX);
#ifdef __APPLE_ALTIVEC__
#elif defined __SSE3__
#else
int sx = fieldStrideX(p->velX);
#endif
int sy = fieldStrideY(p->velY);
float *velX = fieldData(p->velX);
float *velY = fieldData(p->velY);
float *pressure = fieldData(p->pressure);
if (y == 0)
{
#ifdef X_SIMD
x128f *vPressure = (x128f*)fluidFloatPointer(pressure, 0*sy);
x128f *vPressureP = (x128f*)fluidFloatPointer(pressure, 1*sy);
int x;
w/=4;
for (x=0; x<w; x++)
{
vPressure[x] = vPressureP[x];
}
#else
int x;
for (x=0; x<w; x++)
{
fluidFloatPointer(pressure,x*sx)[0] = fluidFloatPointer(pressure,x*sx + sy)[0];
}
#endif
}
else if (y == h-1)
{
#ifdef X_SIMD
x128f *vPressure = (x128f*)fluidFloatPointer(pressure, y*sy);
x128f *vPressureP = (x128f*)fluidFloatPointer(pressure, (y-1)*sy);
int x;
w/=4;
for (x=0; x<w; x++)
{
vPressure[x] = vPressureP[x];
}
#else
int x;
for (x=0; x<w; x++)
{
fluidFloatPointer(pressure,x*sx + y*sy)[0] =
fluidFloatPointer(pressure,x*sx + (y-1)*sy)[0];
}
#endif
}
else
{
#ifdef X_SIMD
float *vPressureRow = fluidFloatPointer(pressure, y*sy);
x128f *vPressure = (x128f*)vPressureRow;
x128f *vVelX = (x128f*)fluidFloatPointer(velX, y*sy);
x128f *vPressureN = (x128f*)fluidFloatPointer(pressure, (y+1)*sy);
x128f *vVelYN = (x128f*)fluidFloatPointer(velY, (y+1)*sy);
x128f *vPressureP = (x128f*)fluidFloatPointer(pressure, (y-1)*sy);
x128f *vVelYP = (x128f*)fluidFloatPointer(velY, (y-1)*sy);
x128f div4 = {0.0f, 1.0f/4.0f, 0.0f, 1.0f/4.0f};
x128f mask = {1.0f, 0.0f, 1.0f, 0.0f};
#endif
#ifdef __APPLE_ALTIVEC__
//int myTempVariable = __mfspr( 1023 );
vector float vZero = {0,0,0,0};
vec_dstst(vPressure, 0x01000001, 0);
vec_dst(vVelX, 0x01000001, 1);
vec_dst(vVelYN, 0x01000001, 2);
vec_dst(vVelYP, 0x01000001, 3);
int x;
{
vector float tmp;
//Compute shifts
vector float sl_p = vec_sld(vPressure[0], vPressure[1],4);
vector float sr_p = vec_sld(vZero, vPressure[0], 12);
vector float sl_vx = vec_sld(vVelX[0], vVelX[1],4);
vector float sr_vx = vec_sld(vZero, vVelX[0], 12);
//Sum everything!!!
tmp = vec_add(sl_p, sr_p);
tmp = vec_add(tmp, vPressureN[0]);
tmp = vec_add(tmp, vPressureP[0]);
tmp = vec_sub(tmp, sl_vx);
tmp = vec_add(tmp, sr_vx);
tmp = vec_sub(tmp, vVelYN[0]);
tmp = vec_add(tmp, vVelYP[0]);
vPressure[0] = vec_madd(tmp, div4, vZero);
vPressureRow[0] = vPressureRow[1];
}
x=1;
while (x<w/4-5)
{
PRESSURE_VEC_PRE(0)
PRESSURE_VEC_PRE(1)
PRESSURE_VEC_PRE(2)
PRESSURE_VEC_PRE(3)
PRESSURE_VEC_SHIFT(0)
PRESSURE_VEC_SHIFT(1)
PRESSURE_VEC_SHIFT(2)
PRESSURE_VEC_SHIFT(3)
PRESSURE_VEC_END(0)
PRESSURE_VEC_END(1)
PRESSURE_VEC_END(2)
PRESSURE_VEC_END(3)
x+=4;
}
while (x<w/4-1)
{
PRESSURE_VEC_PRE(0)
PRESSURE_VEC_SHIFT(0)
PRESSURE_VEC_END(0)
x++;
}
{
vector float tmp;
//Compute shifts
vector float sl_p = vec_sld(vPressure[x], vZero,4);
vector float sr_p = vec_sld(vPressure[x-1], vPressure[x], 12);
vector float sl_vx = vec_sld(vVelX[x], vZero,4);
vector float sr_vx = vec_sld(vVelX[x-1], vVelX[x], 12);
//Sum everything!!!
tmp = vec_add(sl_p, sr_p);
tmp = vec_add(tmp, vPressureN[x]);
tmp = vec_add(tmp, vPressureP[x]);
tmp = vec_sub(tmp, sl_vx);
tmp = vec_add(tmp, sr_vx);
tmp = vec_sub(tmp, vVelYN[x]);
tmp = vec_add(tmp, vVelYP[x]);
vPressure[x] = vec_madd(tmp, div4, vZero);
vPressureRow[w-1] = vPressureRow[w-2];
}
#elif defined __SSE3__
int x;
{
__m128 tmp;
//Compute shifts
__m128 sl_p = _mm_srli_sf128(vPressure[0],4);
sl_p = _mm_add_ps(sl_p,_mm_slli_sf128(vPressure[1],12));
__m128 sr_p = _mm_slli_sf128(vPressure[0],4);
__m128 sl_vx = _mm_srli_sf128(vVelX[0],4);
sl_vx = _mm_add_ps(sl_vx,_mm_slli_sf128(vVelX[1],12));
__m128 sr_vx = _mm_slli_sf128(vVelX[0],4);
//Sum everything!!!
tmp = _mm_add_ps(sl_p, sr_p);
tmp = _mm_add_ps(tmp, vPressureN[0]);
tmp = _mm_add_ps(tmp, vPressureP[0]);
tmp = _mm_sub_ps(tmp, sl_vx);
tmp = _mm_add_ps(tmp, sr_vx);
tmp = _mm_sub_ps(tmp, vVelYN[0]);
tmp = _mm_add_ps(tmp, vVelYP[0]);
vPressure[0] = _mm_mul_ps(tmp, div4);
vPressureRow[0] = vPressureRow[1];
}
x=1;
while (x<w/4-9)
{
//Compute shifts (1)
PRESSURE_SSE_PRE(0);
PRESSURE_SSE_PRE(1);
PRESSURE_SSE_PRE(2);
//Sum everything!!! (1)
PRESSURE_SSE_POST(0);
PRESSURE_SSE_POST(1);
PRESSURE_SSE_POST(2);
x+=3;
}
while (x<w/4-1)
{
//Compute shifts
PRESSURE_SSE_PRE(0);
//Sum everything!!!
PRESSURE_SSE_POST(0);
x++;
}
{
__m128 tmp;
//Compute shifts
__m128 sl_p = _mm_srli_sf128(vPressure[x],4);
__m128 sr_p = _mm_slli_sf128(vPressure[x],4);
sr_p = _mm_add_ps(sr_p,_mm_srli_sf128(vPressure[x-1],12));
__m128 sl_vx = _mm_srli_sf128(vVelX[x],4);
__m128 sr_vx = _mm_slli_sf128(vVelX[x],4);
sr_vx = _mm_add_ps(sr_vx,_mm_srli_sf128(vVelX[x-1],12));
//Sum everything!!!
tmp = _mm_add_ps(sl_p, sr_p);
tmp = _mm_add_ps(tmp, vPressureN[x]);
tmp = _mm_add_ps(tmp, vPressureP[x]);
tmp = _mm_sub_ps(tmp, sl_vx);
tmp = _mm_add_ps(tmp, sr_vx);
tmp = _mm_sub_ps(tmp, vVelYN[x]);
tmp = _mm_add_ps(tmp, vVelYP[x]);
vPressure[x] = _mm_mul_ps(tmp, div4);
vPressureRow[w-1] = vPressureRow[w-2];
}
#else
float lastPressureX = fluidFloatPointer(pressure,sx + y*sy)[0];
float lastVelX = fluidFloatPointer(velX, y*sy)[0];
float curPressureX = lastPressureX;
float curVelX = fluidFloatPointer(velX, sx + y*sy)[0];
fluidFloatPointer(pressure,y*sy)[0] = lastPressureX;
int x;
int curxy = sx + y*sy;
for (x=1; x<w-1; x++)
{
float nextPressureX = fluidFloatPointer(pressure,curxy + sx)[0];
float nextVelX = fluidFloatPointer(velX,curxy + sx)[0];
fluidFloatPointer(pressure,curxy)[0] =
( lastPressureX
+ nextPressureX
+ fluidFloatPointer(pressure,curxy - sy)[0]
+ fluidFloatPointer(pressure,curxy + sy)[0]
- ( nextVelX
- lastVelX
+ fluidFloatPointer(velY,curxy + sy)[0]
- fluidFloatPointer(velY,curxy - sy)[0])) / 4.0f;
lastPressureX = curPressureX;
curPressureX = nextPressureX;
lastVelX = curVelX;
curVelX = nextVelX;
curxy += sx;
}
fluidFloatPointer(pressure,(w-1)*sx + y*sy)[0]
= fluidFloatPointer(pressure,(w-2)*sx + y*sy)[0];
#endif
}
}
QVariant PayloadProtocol::fieldData(int index, FieldAttrib attrib,
int streamIndex) const
{
switch (index)
{
case payload_dataPattern:
switch(attrib)
{
case FieldName:
return QString("Data");
case FieldValue:
return data.pattern();
case FieldTextValue:
return QString(fieldData(index, FieldFrameValue,
streamIndex).toByteArray().toHex());
case FieldFrameValue:
{
QByteArray fv;
int dataLen;
dataLen = protocolFrameSize(streamIndex);
// FIXME: Hack! Bad! Bad! Very Bad!!!
if (dataLen <= 0)
dataLen = 1;
fv.resize(dataLen+4);
switch(data.pattern_mode())
{
case OstProto::Payload::e_dp_fixed_word:
for (int i = 0; i < (dataLen/4)+1; i++)
qToBigEndian((quint32) data.pattern(),
(uchar*)(fv.data()+(i*4)) );
break;
case OstProto::Payload::e_dp_inc_byte:
for (int i = 0; i < dataLen; i++)
fv[i] = i % (0xFF + 1);
break;
case OstProto::Payload::e_dp_dec_byte:
for (int i = 0; i < dataLen; i++)
fv[i] = 0xFF - (i % (0xFF + 1));
break;
case OstProto::Payload::e_dp_random:
//! \todo (HIGH) cksum is incorrect for random pattern
for (int i = 0; i < dataLen; i++)
fv[i] = qrand() % (0xFF + 1);
break;
default:
qWarning("Unhandled data pattern %d",
data.pattern_mode());
}
fv.resize(dataLen);
return fv;
}
default:
break;
}
break;
// Meta fields
case payload_dataPatternMode:
switch(attrib)
{
case FieldValue: return data.pattern_mode();
default: break;
}
break;
default:
break;
}
return AbstractProtocol::fieldData(index, attrib, streamIndex);
}
ID3v2_TextIdentificationFrame::ID3v2_TextIdentificationFrame(const SjByteVector &data, ID3v2_FrameHeader *h)
: ID3v2_Frame(h)
{
m_textEncoding = SJ_LATIN1;
parseFields(fieldData(data));
}
//Basic advection of only the velocity...
void fluid_advection_stam_velocity(fluid *in_f, int y, pvt_fluidMode *mode)
{
int x;
int w = fieldWidth(mode->advection_stam_velocity.srcVelX);
int h = fieldHeight(mode->advection_stam_velocity.srcVelY);
float *velX = fieldData(mode->advection_stam_velocity.srcVelX);
float *velY = fieldData(mode->advection_stam_velocity.srcVelY);
float *velDestX = fieldData(mode->advection_stam_velocity.dstVelX);
float *velDestY = fieldData(mode->advection_stam_velocity.dstVelY);
int sX = fieldStrideX(mode->advection_stam_velocity.srcVelX);
int sY = fieldStrideY(mode->advection_stam_velocity.srcVelY);
float timestep = mode->advection_stam_velocity.timestep;
//Loop over the data and do the desired computation
float fx;
float fy = (float)y;
#define ADVECT_PRE(n) \
float fDataX ## n = fluidFloatPointer(velX, x*sX + y*sY)[n]; \
float fDataY ## n = fluidFloatPointer(velY, x*sX + y*sY)[n]; \
\
/*Find the cell back in time (keep a -10,10 radius)*/ \
float backX ## n = -timestep * fDataX ## n + fx+n; \
float backY ## n = -timestep * fDataY ## n + fy; \
\
int nBackX ## n = (int)backX ## n; \
int nBackY ## n = (int)backY ## n; \
\
float scaleX ## n = backX ## n - (float)(nBackX ## n); \
float scaleY ## n = backY ## n - (float)(nBackY ## n); \
\
/*Clamp as it's easier to parallelize given the scheduler*/ \
nBackX ## n = fluidClamp(nBackX ## n, 0,w-2); \
nBackY ## n = fluidClamp(nBackY ## n, 0,h-2); \
\
/*That was easy... now advect the velocity...*/ \
float *fVelDestX ## n = fluidFloatPointer(velDestX, x*sX + y*sY); \
float *fVelDestY ## n = fluidFloatPointer(velDestY, x*sX + y*sY); \
\
int offBackX ## n = nBackX ## n * sX; \
int offBackY ## n = nBackY ## n * sY; \
int offX2 ## n = offBackX ## n + sX; \
int offY2 ## n = offBackY ## n + sY; \
\
float bZZ_x ## n = fluidFloatPointer(velX, offBackX ## n + offBackY ## n)[0]; \
float bOZ_x ## n = fluidFloatPointer(velX, offX2 ## n + offBackY ## n)[0]; \
float bZO_x ## n = fluidFloatPointer(velX, offBackX ## n + offY2 ## n)[0]; \
float bOO_x ## n = fluidFloatPointer(velX, offX2 ## n + offY2 ## n)[0]; \
\
float bZZ_y ## n = fluidFloatPointer(velY, offBackX ## n + offBackY ## n)[0]; \
float bOZ_y ## n = fluidFloatPointer(velY, offX2 ## n + offBackY ## n)[0]; \
float bZO_y ## n = fluidFloatPointer(velY, offBackX ## n + offY2 ## n)[0]; \
float bOO_y ## n = fluidFloatPointer(velY, offX2 ## n + offY2 ## n)[0];
#define ADVECT_X(n) \
fVelDestX ## n[n] = fluidLinearInterpolation(scaleX ## n, scaleY ## n, \
bZZ_x ## n, bOZ_x ## n, bZO_x ## n, bOO_x ## n);
#define ADVECT_Y(n) \
fVelDestY ## n[n] = fluidLinearInterpolation(scaleX ## n, scaleY ## n, \
bZZ_y ## n, bOZ_y ## n, bZO_y ## n, bOO_y ## n);
x=0;
fx=0;
while(x<w-3)
{
ADVECT_PRE(0)
ADVECT_PRE(1)
ADVECT_PRE(2)
ADVECT_X(0)
ADVECT_X(1)
ADVECT_X(2)
ADVECT_Y(0)
ADVECT_Y(1)
ADVECT_Y(2)
x+=3;
fx+=3;
}
while(x<w)
{
ADVECT_PRE(0)
ADVECT_X(0)
ADVECT_Y(0)
x++;
fx++;
}
}
ID3v2_UniqueFileIdentifierFrame::ID3v2_UniqueFileIdentifierFrame(const SjByteVector &data, ID3v2_FrameHeader *h) :
ID3v2_Frame(h)
{
parseFields(fieldData(data));
}
ID3v2_UnknownFrame::ID3v2_UnknownFrame(const SjByteVector &data, ID3v2_FrameHeader *h) : ID3v2_Frame(h)
{
parseFields(fieldData(data));
}
int fieldServerOnConnect(void *i, netServer *s, netClient *c)
{
fieldServer *r = (fieldServer*)i;
struct fieldServerJitHeader header;
double prevTime; //Store times (no manipulation == easier!)
int hasLatency = 0; //Set to 1 after first matrix arrives.
nextPacket:
netClientGetBinary(c, &header, sizeof(header), 10);
header.id = ntohl(header.id);
if (header.id == 'JMTX')
{
struct fieldServerJitLatency latency;
latency.id = htonl('JMLP');
//printf("FieldServer: Jitter Matrix!\n");
struct fieldServerJitMatrix matrixInfo;
// int invByteOrder = 0;
// if (sizeof(matrixInfo) != header.size)
// {
// header.size = ntohl(header.size);
// if (header.size != sizeof(matrixInfo))
// {
// printf("FieldServer: ERROR: More data sent than expected! (sent %i expected %u)\n",
// header.size, (unsigned int)sizeof(matrixInfo));
// return 0;
// }
// else
// invByteOrder = 1;
// }
netClientGetBinary(c, &matrixInfo, sizeof(matrixInfo), 10);
matrixInfo.planeCount = ntohl(matrixInfo.planeCount);
matrixInfo.type = ntohl(matrixInfo.type);
matrixInfo.dimCount = ntohl(matrixInfo.dimCount);
if (matrixInfo.dimCount < 2 || matrixInfo.dimCount > 32)
{
printf("FieldServer: ERROR: Insane dim count! (sent %i)\n", matrixInfo.dimCount);
return 0;
}
int x;
for (x=0; x<matrixInfo.dimCount; x++)
matrixInfo.dim[x] = ntohl(matrixInfo.dim[x]);
for (x=0; x<matrixInfo.dimCount; x++)
matrixInfo.dimStride[x] = ntohl(matrixInfo.dimStride[x]);
matrixInfo.dataSize = ntohl(matrixInfo.dataSize);
//printf(" - planeCount: %u\n", matrixInfo.planeCount);
//printf(" - dimCount: %u\n", matrixInfo.dimCount);
//printf(" - time: %f\n", matrixInfo.time);
int sizeOfData;
if (r->dataType == FIELD_JIT_FLOAT32)
sizeOfData = 4;
else
sizeOfData = 1;
pthread_mutex_lock(&r->mtx);
while (r->needSwap == 1)
{
x_pthread_cond_wait(&r->cnd, &r->mtx);
if (r->server == NULL)
{
pthread_mutex_unlock(&r->mtx);
return 0;
}
}
pthread_mutex_unlock(&r->mtx);
//Attempt to resize the field
fieldResize_sy(r->fld_net, matrixInfo.dim[0], matrixInfo.dim[1], matrixInfo.dimStride[1]);
//Loop over and receive!!!
if (matrixInfo.dimCount == 2
&& matrixInfo.type == r->dataType
&& matrixInfo.planeCount == fieldComponents(r->fld_net)
&& matrixInfo.dim[0] == fieldWidth(r->fld_net)
&& matrixInfo.dim[1] == fieldHeight(r->fld_net)
&& matrixInfo.dimStride[0] == fieldStrideX(r->fld_net)
&& matrixInfo.dimStride[1] == fieldStrideY(r->fld_net)
&& matrixInfo.dataSize ==
fieldStrideY(r->fld_net) * fieldHeight(r->fld_net))
{
//printf(" - OPTIMAL!\n");
float *d = fieldData(r->fld_net);
netClientGetBinary(c, d, matrixInfo.dataSize, 10);
pthread_mutex_lock(&r->mtx);
r->needSwap = 1;
if (r->server == NULL)
{
pthread_mutex_unlock(&r->mtx);
return 0;
}
//printf("AWAKE!!\n");
pthread_mutex_unlock(&r->mtx);
if (hasLatency == 0)
{
hasLatency = 1;
prevTime = matrixInfo.time;
}
else
{
latency.client_time = prevTime;
latency.parsed_header = matrixInfo.time;
latency.parsed_done = matrixInfo.time;
/*double diff = latency.parsed_header - matrixInfo.time;
latency.parsed_header -= diff;
latency.parsed_done -= diff;
diff = (latency.parsed_done-latency.parsed_header)/2;
latency.parsed_header += diff;
latency.parsed_done += diff;*/
//printf("LATENCY (%f,%f,%f)\n",latency.client_time,
// latency.parsed_done,
// latency.parsed_header);
netClientSendBinary(c, &latency, sizeof(latency));
prevTime = matrixInfo.time;
}
goto nextPacket;
}
else
{
printf(" - Backup data fetcher = discard...\n");
printf(" --> Type: %u (%u)\n", matrixInfo.type, r->dataType);
printf(" --> Dims: %u (%u)\n", matrixInfo.dimCount, 2);
printf(" --> Planes: %u (%u)\n", matrixInfo.planeCount, fieldComponents(r->fld_net));
printf(" --> Width: %u (%u)\n", matrixInfo.dim[0], fieldWidth(r->fld_net));
printf(" --> Height: %u (%u)\n", matrixInfo.dim[1], fieldHeight(r->fld_net));
printf(" --> StrideX: %u (%u)\n", matrixInfo.dimStride[0], fieldStrideX(r->fld_net));
printf(" --> StrideY: %u (%u)\n", matrixInfo.dimStride[1], fieldStrideY(r->fld_net));
printf(" --> dataSize: %u (%u)\n", matrixInfo.dataSize, fieldStrideY(r->fld_net) * fieldHeight(r->fld_net));
}
}
else if (header.id == 'JMLP')
{
printf("FieldServer: Jitter Latency!\n");
}
else if (header.id == 'JMMP')
{
int rdMsg = 0;
pthread_mutex_lock(&r->mtx);
while ((r->curWriteMsg + 2) % 8 == r->curReadMsg)
{
printf("FieldServer: MSG Stall\n");
x_pthread_cond_wait(&r->cndMsg, &r->mtx);
if (r->server == NULL)
{
pthread_mutex_unlock(&r->mtx);
return 0;
}
}
//printf("FieldServer: MSG Pass\n");
rdMsg = r->curWriteMsg;
pthread_mutex_unlock(&r->mtx);
fieldMsgReceive(r->msg_loop[rdMsg], c);
pthread_mutex_lock(&r->mtx);
r->curWriteMsg = (r->curWriteMsg+1)%8;
pthread_mutex_unlock(&r->mtx);
goto nextPacket;
}
else
{
char *cda = (char*)&header.id;
printf("FieldServer: ERROR: Unknown Packet '%c%c%c%c'!\n",cda[0],cda[1],
cda[2], cda[3]);
return 0;
}
printf("FieldServer: Completed Processing!\n");
return 0;
}
//Basic corrector part of predictor-corrector.
void fluid_advection_mccormack_repos(fluid *in_f, const int y, pvt_fluidMode *mode)
{
struct mccormack_vel_repos *data = &mode->mccormack_vel_repos;
int x; //Simple looping var
int w = fieldWidth(data->srcVelX); //Width of the data
int h = fieldHeight(data->srcVelX);
int sY = fieldStrideY(data->srcVelY);
x128f timestep = {data->timestep,data->timestep,data->timestep,data->timestep};
int sX = fieldStrideX(data->srcVelX);
x128i vsX = {sX, sX, sX, sX};
x128i vsY = {sY, sY, sY, sY};
const float *srcVelX = fieldData(data->srcVelX);
const float *srcVelY = fieldData(data->srcVelY);
float *dstReposX = fieldData(data->dstReposX);
float *dstReposY = fieldData(data->dstReposY);
const int curxy = y*sY;
const int w2 = w/4;
//printf("%i %i\n", w2, w);
x128f vMin = {-ADVECT_DIST, -ADVECT_DIST, -ADVECT_DIST, -ADVECT_DIST};
x128f vMax = {ADVECT_DIST, ADVECT_DIST, ADVECT_DIST, ADVECT_DIST};
const x128f *vSrcVelX = (x128f*)fluidFloatPointer(srcVelX, curxy);
const x128f *vSrcVelY = (x128f*)fluidFloatPointer(srcVelY, curxy);
// const x128f *vSrcVelXM = (x128f*)fluidFloatPointer(srcVelX, curxy-sY);
// const x128f *vSrcVelYM = (x128f*)fluidFloatPointer(srcVelY, curxy-sY);
//
// const x128f *vSrcVelXP = (x128f*)fluidFloatPointer(srcVelX, curxy+sY);
// const x128f *vSrcVelYP = (x128f*)fluidFloatPointer(srcVelY, curxy+sY);
x128f *vDstReposX = (x128f*)fluidFloatPointer(dstReposX, curxy);
x128f *vDstReposY = (x128f*)fluidFloatPointer(dstReposY, curxy);
x128f vX = {0.0f, 1.0f, 2.0f, 3.0f};
const x128f vY = {y, y, y, y};
// const x128f vYM = {y-1, y-1, y-1, y-1};
// const x128f vYP = {y+1, y+1, y+1, y+1};
const x128f vHalf = {0.5f,0.5f,0.5f,0.5f};
const x128f v4 = {4.0f, 4.0f, 4.0f, 4.0f};
const x128f vN1 = {-1.0f, -1.0f, -1.0f, -1.0f};
const x128f vW = {w-1.01f,w-1.01f,w-1.01f,w-1.01f};
const x128f vH = {h-1.01f,h-1.01f,h-1.01f,h-1.01f};
u128i offBackX, offBackY, offBackX2, offBackY2, d1, d2, d3, d4;
u128f scaleX, scaleY, fwdVelX, fwdVelY;
float bZZ, bOZ, bZO, bOO;
for (x=0; x<w2; x++)
{
//Basic...
u128f fVelX, fVelY;
fVelX.v = x_mul(timestep, vSrcVelX[x]);
fVelY.v = x_mul(timestep, vSrcVelY[x]);
// //Assume we can do this ina 9x9 window...
// x128f x1 = x_sub(x_sub(vX, x_simd_one), fVelX.v);
// x128f x2 = x_sub(vX, fVelX.v);
// x128f x3 = x_sub(x_add(vX, x_simd_one), fVelX.v);
//
// x128f y1 = x_sub(vYM, fVelY.v);
// x128f y2 = x_sub(vY, fVelY.v);
// x128f y3 = x_sub(vYP, fVelY.v);
//
// x128f sum1 = x_add(x_add(x_add(x1,x2),x3),x_add(x_add(y1,y2),y3));
//
// x1 = x_abs(x1);
// x2 = x_abs(x2);
// x3 = x_abs(x3);
//
// y1 = x_abs(y1);
// y2 = x_abs(y2);
// y3 = x_abs(y3);
//
//
// x128f sum2 = x_add(x_add(x_add(x1,x2),x3),x_add(x_add(y1,y2),y3));
//Clamp the values...
// x1 = x_sub(x_simd_one, x1);
// x2 = x_sub(x_simd_one, x2);
// x3 = x_sub(x_simd_one, x3);
//
// y1 = x_sub(x_simd_one, y1);
// y2 = x_sub(x_simd_one, y2);
// y3 = x_sub(x_simd_one, y3);
//Advect forward in time...
x128f fSrcVelX = x_clamp(fVelX.v, vMin, vMax);
x128f fSrcVelY = x_clamp(fVelY.v, vMin, vMax);
//Go forward
x128f fwdX = x_clamp(x_add(vX, fSrcVelX), x_simd_zero, vW);
x128f fwdY = x_clamp(x_add(vY, fSrcVelY), x_simd_zero, vH);
// x128f fwdX = x_clamp(x_add(fSrcVelX, vX), x_simd_zero, vW);
// x128f fwdY = x_clamp(x_add(fSrcVelY, vY), x_simd_zero, vH);
//Back as integer
x128i nBackX = x_ftoi(fwdX);
x128i nBackY = x_ftoi(fwdY);
// if (!x_all_lt(sum1, sum2))
// {
// x1 = x_max(x_simd_zero, x1);
// x2 = x_max(x_simd_zero, x2);
// x3 = x_max(x_simd_zero, x3);
//
// y1 = x_max(x_simd_zero, y1);
// y2 = x_max(x_simd_zero, y2);
// y3 = x_max(x_simd_zero, y3);
//
// x128f slX, slY, srX, srY;
//
// x128f yMX, yMY, yPX, yPY;
//
// x128f X11, X31, X33, X13;
// x128f Y11, Y31, Y33, Y13;
//
// if (y == 0)
// {
// yMX = x_simd_zero;
// yMY = x_simd_zero;
//
// X31 = x_simd_zero;
// X11 = x_simd_zero;
//
// Y31 = x_simd_zero;
// Y11 = x_simd_zero;
// }
// else
// {
// yMX = vSrcVelXM[x];
// yMY = vSrcVelYM[x];
//
// if (x == 0)
// {
// X11 = x_sld(x_simd_zero, vSrcVelXM[x], 4);
// Y11 = x_sld(x_simd_zero, vSrcVelYM[x], 4);
// }
// else
// {
// X11 = x_sld(vSrcVelXM[x-1], vSrcVelXM[x], 4);
// Y11 = x_sld(vSrcVelXM[x-1], vSrcVelYM[x], 4);
// }
//
// if (x == w2-1)
// {
// X31 = x_sld(vSrcVelXM[x], x_simd_zero, 12);
// Y31 = x_sld(vSrcVelYM[x], x_simd_zero, 12);
// }
// else
// {
// X31 = x_sld(vSrcVelXM[x], vSrcVelXM[x+1], 12);
// Y31 = x_sld(vSrcVelXM[x], vSrcVelYM[x+1], 12);
// }
// }
//
// if (y == h-1)
// {
// yPX = x_simd_zero;
// yPY = x_simd_zero;
//
// X33 = x_simd_zero;
// X13 = x_simd_zero;
//
// Y33 = x_simd_zero;
// Y13 = x_simd_zero;
// }
// else
// {
// yPX = vSrcVelXP[x];
// yPY = vSrcVelYP[x];
//
// if (x == 0)
// {
// X13 = x_sld(x_simd_zero, vSrcVelXP[x], 4);
// Y13 = x_sld(x_simd_zero, vSrcVelYP[x], 4);
// }
// else
// {
// X13 = x_sld(vSrcVelXP[x-1], vSrcVelXP[x], 4);
// Y13 = x_sld(vSrcVelXP[x-1], vSrcVelYP[x], 4);
// }
//
// if (x == w2-1)
// {
// X33 = x_sld(vSrcVelXP[x], x_simd_zero, 12);
// Y33 = x_sld(vSrcVelYP[x], x_simd_zero, 12);
// }
// else
// {
// X33 = x_sld(vSrcVelXP[x], vSrcVelXP[x+1], 12);
// Y33 = x_sld(vSrcVelXP[x], vSrcVelYP[x+1], 12);
// }
// }
//
// if (x == 0)
// {
// srX = x_sld(x_simd_zero, vSrcVelX[x], 4);
// srY = x_sld(x_simd_zero, vSrcVelY[x], 4);
// }
// else
// {
// srX = x_sld(vSrcVelX[x-1], vSrcVelX[x], 4);
// srY = x_sld(vSrcVelY[x-1], vSrcVelY[x], 4);
// }
//
// if (x == w2 - 1)
// {
// slX = x_sld(vSrcVelX[x], x_simd_zero, 12);
// slY = x_sld(vSrcVelX[x], x_simd_zero, 12);
// }
// else
// {
// slX = x_sld(vSrcVelX[x], vSrcVelX[x+1], 12);
// slY = x_sld(vSrcVelX[x], vSrcVelX[x+1], 12);
// }
//
// fwdVelX.v = x_mul(x_mul(x2,y2), vSrcVelX[x]);
// fwdVelY.v = x_mul(x_mul(x2,y2), vSrcVelY[x]);
//
//
//
// fwdVelX.v = x_madd(x_mul(x1,y2), srX, fwdVelX.v);
// fwdVelY.v = x_madd(x_mul(x1,y2), srY, fwdVelY.v);
//
// fwdVelX.v = x_madd(x_mul(x3,y2), srX, fwdVelX.v);
// fwdVelY.v = x_madd(x_mul(x3,y2), srY, fwdVelY.v);
//
//
// fwdVelX.v = x_madd(x_mul(x2,y1), yMX, fwdVelX.v);
// fwdVelY.v = x_madd(x_mul(x2,y1), yMY, fwdVelY.v);
//
// fwdVelX.v = x_madd(x_mul(x2,y3), yPX, fwdVelX.v);
// fwdVelY.v = x_madd(x_mul(x2,y3), yPY, fwdVelY.v);
//
//
//
// fwdVelX.v = x_madd(x_mul(x1,y1), X11, fwdVelX.v);
// fwdVelY.v = x_madd(x_mul(x1,y1), Y11, fwdVelY.v);
//
// fwdVelX.v = x_madd(x_mul(x1,y3), X13, fwdVelX.v);
// fwdVelY.v = x_madd(x_mul(x1,y3), Y13, fwdVelY.v);
//
//
// fwdVelX.v = x_madd(x_mul(x3,y1), X31, fwdVelX.v);
// fwdVelY.v = x_madd(x_mul(x3,y1), Y31, fwdVelY.v);
//
// fwdVelX.v = x_madd(x_mul(x3,y3), X33, fwdVelX.v);
// fwdVelY.v = x_madd(x_mul(x3,y3), Y33, fwdVelY.v);
// }
// else
// {
//Compute scaling factor
scaleX.v = x_sub(fwdX, x_itof(nBackX));
scaleY.v = x_sub(fwdY, x_itof(nBackY));
//Compute the addresses of the destinations...
offBackX.v = x_imul(nBackX, vsX);
offBackY.v = x_imul(nBackY, vsY);
offBackX2.v = x_iadd(offBackX.v, vsX);
offBackY2.v = x_iadd(offBackY.v, vsY);
d1.v = x_iadd(offBackX.v, offBackY.v);
d2.v = x_iadd(offBackX2.v, offBackY.v);
d3.v = x_iadd(offBackX.v, offBackY2.v);
d4.v = x_iadd(offBackX2.v, offBackY2.v);
int i;
for (i=0; i<4; i++)
{
bZZ = fluidFloatPointer(srcVelX, d1.i[i])[0];
bOZ = fluidFloatPointer(srcVelX, d2.i[i])[0];
bZO = fluidFloatPointer(srcVelX, d3.i[i])[0];
bOO = fluidFloatPointer(srcVelX, d4.i[i])[0];
fwdVelX.f[i] = fluidLinearInterpolation(scaleX.f[i], scaleY.f[i],bZZ, bOZ, bZO, bOO);
bZZ = fluidFloatPointer(srcVelY, d1.i[i])[0];
bOZ = fluidFloatPointer(srcVelY, d2.i[i])[0];
bZO = fluidFloatPointer(srcVelY, d3.i[i])[0];
bOO = fluidFloatPointer(srcVelY, d4.i[i])[0];
fwdVelY.f[i] = fluidLinearInterpolation(scaleX.f[i], scaleY.f[i],bZZ, bOZ, bZO, bOO);
}
// }
//
// __builtin_prefetch(vSrcVelX+x+4);
// __builtin_prefetch(vSrcVelXM+x+4);
// __builtin_prefetch(vSrcVelXP+x+4);
//
// __builtin_prefetch(vSrcVelY+x+4);
// __builtin_prefetch(vSrcVelYM+x+4);
// __builtin_prefetch(vSrcVelYP+x+4);
//Compute the velocity at that point...
//This velocity (computed the other way) will give spatial error
u128f errX, errY;
//errX.v = x_sub(x_add(x_clamp(x_mul(x_mul(vN1, timestep), fwdVelX.v), vMin, vMax), fwdX), vX);
//errY.v = x_sub(x_add(x_clamp(x_mul(x_mul(vN1, timestep), fwdVelY.v), vMin, vMax), fwdY), vY);
errX.v = x_clamp(x_mul(timestep, fwdVelX.v), vMin, vMax);
errY.v = x_clamp(x_mul(timestep, fwdVelY.v), vMin, vMax);
//Most of the error is from velocity advection (so we assume)
// This is a cheap way of computing error!
x128f backX = x_add(x_clamp(x_madd(vHalf,errX.v,x_mul(fVelX.v,vN1)),vMin,vMax), vX);
vDstReposX[x] = x_clamp(backX,x_simd_zero, vW);
x128f backY = x_add(x_clamp(x_madd(vHalf,errY.v,x_mul(fVelY.v,vN1)),vMin,vMax), vY);
vDstReposY[x] = x_clamp(backY,x_simd_zero, vH);
vX = x_add(vX, v4);
}
}
