AL_API void AL_APIENTRY alBufferSamplesSOFT(ALuint buffer,
ALuint samplerate, ALenum internalformat, ALsizei samples,
ALenum channels, ALenum type, const ALvoid *data)
{
ALCdevice *device;
ALCcontext *context;
ALbuffer *albuf;
ALsizei align;
ALenum err;
context = GetContextRef();
if(!context) return;
device = context->Device;
if((albuf=LookupBuffer(device, buffer)) == NULL)
SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
if(!(samples >= 0 && samplerate != 0))
SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
if(IsValidType(type) == AL_FALSE || IsValidChannels(channels) == AL_FALSE)
SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
align = albuf->UnpackAlign;
if(SanitizeAlignment(type, &align) == AL_FALSE)
SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
if((samples%align) != 0)
SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
err = LoadData(albuf, samplerate, internalformat, samples,
channels, type, data, align, AL_FALSE);
if(err != AL_NO_ERROR)
SET_ERROR_AND_GOTO(context, err, done);
done:
ALCcontext_DecRef(context);
}
bool
AbstractTaskFactory::Append(const OrderedTaskPoint &new_tp,
const bool auto_mutate)
{
if (task.IsFull())
return false;
if (auto_mutate) {
if (!task.TaskSize()) {
// empty task, so add as a start point
if (IsValidType(new_tp, task.TaskSize())) {
// candidate is ok, so add it
return task.Append(new_tp);
} else {
// candidate must be transformed into a startpoint
StartPoint* sp = CreateStart(new_tp.GetWaypoint());
bool success = task.Append(*sp);
delete sp;
return success;
}
}
// non-empty task
if (task.HasFinish()) {
// old finish must be mutated into an intermediate point
IntermediateTaskPoint* sp =
CreateIntermediate(task.GetTaskPoint(task.TaskSize() - 1).GetWaypoint());
task.Replace(*sp, task.TaskSize()-1);
delete sp;
}
if (IsValidType(new_tp, task.TaskSize()))
// ok to append directly
return task.Append(new_tp);
// this point must be mutated into a finish
FinishPoint* sp = CreateFinish(new_tp.GetWaypoint());
bool success = task.Append(*sp);
delete sp;
return success;
}
return task.Append(new_tp);
}
RegisterSpace* TypedRegisterAllocator::GetRegisterSpace(Types type) const
{
if (!IsValidType(type))
{
Assert("Invalid type for RegisterSpace in TypedMemoryStructure");
Js::Throw::InternalError();
}
Assert(!IsTypeExcluded(type));
return mTypeSpaces[type];
}
AL_API void AL_APIENTRY alGetBufferSamplesSOFT(ALuint buffer,
ALsizei offset, ALsizei samples,
ALenum channels, ALenum type, ALvoid *data)
{
ALCdevice *device;
ALCcontext *context;
ALbuffer *albuf;
ALsizei align;
context = GetContextRef();
if(!context) return;
device = context->Device;
LockBuffersRead(device);
if((albuf=LookupBuffer(device, buffer)) == NULL)
SET_ERROR_AND_GOTO(context, AL_INVALID_NAME, done);
if(!(samples >= 0 && offset >= 0))
SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
if(IsValidType(type) == AL_FALSE)
SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
ReadLock(&albuf->lock);
align = ATOMIC_LOAD_SEQ(&albuf->PackAlign);
if(SanitizeAlignment(type, &align) == AL_FALSE)
{
ReadUnlock(&albuf->lock);
SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
}
if(channels != (ALenum)albuf->FmtChannels)
{
ReadUnlock(&albuf->lock);
SET_ERROR_AND_GOTO(context, AL_INVALID_ENUM, done);
}
if(offset > albuf->SampleLen || samples > albuf->SampleLen-offset)
{
ReadUnlock(&albuf->lock);
SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
}
if((samples%align) != 0)
{
ReadUnlock(&albuf->lock);
SET_ERROR_AND_GOTO(context, AL_INVALID_VALUE, done);
}
/* offset -> byte offset */
offset *= FrameSizeFromFmt(albuf->FmtChannels, albuf->FmtType);
ConvertData(data, type, (char*)albuf->data+offset, (enum UserFmtType)albuf->FmtType,
ChannelsFromFmt(albuf->FmtChannels), samples, align);
ReadUnlock(&albuf->lock);
done:
UnlockBuffersRead(device);
ALCcontext_DecRef(context);
}
bool
AbstractTaskFactory::AppendOptionalStart(const OrderedTaskPoint &new_tp,
const bool auto_mutate)
{
if (auto_mutate && !IsValidType(new_tp, 0)) {
// candidate must be transformed into a startpoint of appropriate type
StartPoint* sp = CreateStart(new_tp.GetWaypoint());
bool success = task.AppendOptionalStart(*sp);
delete sp;
return success;
}
// ok to add directly
return task.AppendOptionalStart(new_tp);
}
bool
AbstractTaskFactory::MutateTPsToTaskType()
{
bool changed = RemoveExcessTPsPerTaskType();
for (unsigned int i = 0; i < task.TaskSize(); i++) {
const OrderedTaskPoint &tp = task.GetPoint(i);
if (!IsValidType(tp, i) ||
task.GetFactoryType() == TaskFactoryType::MAT ||
task.GetFactoryType() == TaskFactoryType::FAI_GENERAL) {
TaskPointFactoryType newtype = GetMutatedPointType(tp);
if (IsPositionFinish(i)) {
if (!IsValidFinishType(newtype))
newtype = GetDefaultFinishType();
FinishPoint *fp = (FinishPoint*)CreateMutatedPoint(tp, newtype);
assert(fp);
if (Replace(*fp, i, true))
changed = true;
delete fp;
} else if (i == 0) {
if (!IsValidStartType(newtype))
newtype = GetDefaultStartType();
StartPoint *sp = (StartPoint*)CreateMutatedPoint(tp, newtype);
assert(sp);
if (Replace(*sp, i, true))
changed = true;
delete sp;
} else {
if (!IsValidIntermediateType(newtype))
newtype = GetDefaultIntermediateType();
OrderedTaskPoint *tpnew = (OrderedTaskPoint*)CreateMutatedPoint(tp, newtype);
if (Replace(*tpnew, i, true))
changed = true;
delete tpnew;
}
}
}
changed |= MutateClosedFinishPerTaskType();
return changed;
}
bool
AbstractTaskFactory::Insert(const OrderedTaskPoint &new_tp,
const unsigned position,
const bool auto_mutate)
{
if (position >= task.TaskSize())
return Append(new_tp, auto_mutate);
if (auto_mutate) {
if (position == 0) {
if (task.HasStart()) {
// old start must be mutated into an intermediate point
IntermediateTaskPoint* sp =
CreateIntermediate(task.GetTaskPoint(0).GetWaypoint());
task.Replace(*sp, 0);
delete sp;
}
if (IsValidType(new_tp, 0)) {
return task.Insert(new_tp, 0);
} else {
// candidate must be transformed into a startpoint
StartPoint* sp = CreateStart(new_tp.GetWaypoint());
bool success = task.Insert(*sp, 0);
delete sp;
return success;
}
} else {
if (new_tp.IsIntermediatePoint()) {
// candidate ok for direct insertion
return task.Insert(new_tp, position);
} else {
// candidate must be transformed into a intermediatepoint
IntermediateTaskPoint* sp = CreateIntermediate(new_tp.GetWaypoint());
bool success = task.Insert(*sp, position);
delete sp;
return success;
}
}
}
return task.Insert(new_tp, position);
}
virtual void OnIterStart(SActivationInfo *pActInfo)
{
const int type = GetPortInt(pActInfo, EIP_Type);
const Vec3& min(GetPortVec3(pActInfo, EIP_Min));
const Vec3& max(GetPortVec3(pActInfo, EIP_Max));
IPhysicalWorld *pWorld = gEnv->pPhysicalWorld;
IPhysicalEntity **ppList = NULL;
int numEnts = pWorld->GetEntitiesInBox(min,max,ppList,ent_all);
for (int i = 0; i < numEnts; ++i)
{
const EntityId id = pWorld->GetPhysicalEntityId(ppList[i]);
const EEntityType entityType = GetEntityType(id);
if (IsValidType(type, entityType))
{
AddEntity(id);
}
}
}
virtual void OnIterStart(SActivationInfo *pActInfo)
{
const int type = GetPortInt(pActInfo, EIP_Type);
const Vec3& center(GetPortVec3(pActInfo, EIP_Pos));
const float range = GetPortFloat(pActInfo, EIP_Range);
const float rangeSq = range * range;
const Vec3 min(center.x-range, center.y-range, center.z-range);
const Vec3 max(center.x+range, center.y+range, center.z+range);
IPhysicalWorld *pWorld = gEnv->pPhysicalWorld;
IPhysicalEntity **ppList = NULL;
int numEnts = pWorld->GetEntitiesInBox(min,max,ppList,ent_all);
for (int i = 0; i < numEnts; ++i)
{
const EntityId id = pWorld->GetPhysicalEntityId(ppList[i]);
const EEntityType entityType = GetEntityType(id);
if (IsValidType(type, entityType))
{
AddEntity(id);
}
}
}
static pwr_tStatus InitTrendList( trend_tCtx ctx)
{
pwr_tStatus sts;
pwr_tUInt32 dummy;
pwr_tTypeId type;
int tix;
pwr_tAttrRef aref;
pwr_tAttrRef oaref;
pwr_tAName name;
pwr_tDisableAttr disabled;
/* Init DsTrend objects */
/* Scan through typelist and insert valid objects in list and initiate */
/* the DsTrend objects. */
for ( sts = gdh_GetClassListAttrRef(pwr_cClass_DsTrend, &aref);
ODD(sts);
sts = gdh_GetNextAttrRef( pwr_cClass_DsTrend, &aref, &aref) ) {
trend_sListEntry *ep;
pwr_sClass_DsTrend *o;
sts = gdh_AttrrefToName( &aref, name, sizeof(name), cdh_mNName);
if (EVEN(sts))
continue;
/* Check if parent object is disabled */
sts = gdh_AttrArefToObjectAref( &aref, &oaref);
if ( ODD(sts)) {
sts = gdh_ArefDisabled( &oaref, &disabled);
if ( ODD(sts) && disabled)
continue;
}
ep = calloc(1, sizeof(*ep));
if (ep == NULL) {
errh_CErrLog(DS__ERRALLOC, NULL);
errh_SetStatus( PWR__SRVTERM);
exit(DS__ERRALLOC);
}
sts = gdh_RefObjectInfo(name, (pwr_tAddress *)&ep->o,
&ep->o_subid, sizeof(*ep->o));
if (EVEN(sts)) {
errh_Error("Couldn't get subscription for '%s'\n%m", name, sts);
free(ep);
continue;
}
o = ep->o;
/* Set init values */
o->BufferStatus[0] = 1;
o->BufferStatus[1] = 1;
o->NoOfBuffers = 2;
o->NoOfBufElement = 239;
/* Initiate DsTrend object, sampled attribute must be on local node */
sts = gdh_DLRefObjectInfoAttrref((pwr_sAttrRef *)&o->DataName,
(pwr_tAddress *)&o->DataPointer, &o->DataSubId);
if (EVEN(sts)) {
if ( sts == GDH__RTDBNULL && IsDisabled( &o->DataName))
continue;
errh_Error("Couldn't get direct link to %s's attribute DataName\n%m", name, sts);
gdh_UnrefObjectInfo(ep->o_subid);
free(ep);
continue;
}
sts = gdh_GetAttributeCharAttrref((pwr_sAttrRef *)&o->DataName,
&type, &dummy, &dummy, &dummy);
if (EVEN(sts)) {
errh_Error("Couldn't get datatype for %s's attribute DataName\n%m", name, sts);
gdh_UnrefObjectInfo(ep->o_subid);
free(ep);
continue;
}
tix = cdh_TypeIdToIndex(type);
if (!IsValidType(tix)) {
errh_Error("No valid datatype for %s's attribute DataName\n%m", name, DS__ERRTYPE);
gdh_UnrefObjectInfo(ep->o_subid);
free(ep);
continue;
}
o->DataType = tix;
if ( o->Multiple == 0)
o->Multiple = 1;
o->NoOfSample = (o->StorageTime * ctx->scantime) / o->Multiple;
if(o->NoOfSample > o->NoOfBufElement)
o->NoOfSample = o->NoOfBufElement;
o->ScanTime = ctx->scantime;
ep->next = ctx->o_list;
ctx->o_list = ep;
}
/* Init DsTrendCurve objects */
/* Scan through typelist and insert valid objects in list and initiate
the DsTrend objects. */
for (sts = gdh_GetClassListAttrRef(pwr_cClass_DsTrendCurve, &aref);
ODD(sts);
sts = gdh_GetNextAttrRef( pwr_cClass_DsTrendCurve, &aref, &aref) ) {
trend_sListEntryTC *ep;
pwr_sClass_DsTrendCurve *o;
int i;
int found;
sts = gdh_AttrrefToName( &aref, name, sizeof(name), cdh_mNName);
if (EVEN(sts))
continue;
/* Check if parent object is disabled */
sts = gdh_AttrArefToObjectAref( &aref, &oaref);
if ( ODD(sts)) {
sts = gdh_ArefDisabled( &oaref, &disabled);
if ( ODD(sts) && disabled)
continue;
}
ep = calloc(1, sizeof(*ep));
if (ep == NULL) {
errh_CErrLog(DS__ERRALLOC, NULL);
errh_SetStatus( PWR__SRVTERM);
exit(DS__ERRALLOC);
}
ep->first_scan = 1;
sts = gdh_RefObjectInfo(name, (pwr_tAddress *)&ep->o,
&ep->o_subid, sizeof(*ep->o));
if (EVEN(sts)) {
errh_Error("Couldn't get subscription for '%s'\n%m", name, sts);
free(ep);
continue;
}
o = ep->o;
if ( o->Function & 1) {
/* Data stored by user */
gdh_UnrefObjectInfo(ep->o_subid);
free(ep);
continue;
}
ep->multiple = (int) (o->ScanTime / ctx->scantime_tc + 0.5);
o->NoOfSample = (int) (o->StorageTime / ctx->scantime_tc * ep->multiple + 0.5);
/* Initiate DsTrendCuve object, sampled attribute must be on local node */
found = 0;
for ( i = 0; i < 10; i++) {
if ( cdh_ObjidIsNull( o->Attribute[i].Objid))
continue;
/* Link to attribute */
sts = gdh_DLRefObjectInfoAttrref((pwr_sAttrRef *)&o->Attribute[i],
(pwr_tAddress *)&ep->datap[i], &ep->data_subid[i]);
if (EVEN(sts)) {
if ( sts == GDH__RTDBNULL && IsDisabled( &o->Attribute[i]))
continue;
errh_Error("Couldn't get direct link to %s's attribute %d, %m", name, i+1, sts);
ep->datap[i] = 0;
continue;
}
sts = gdh_GetAttributeCharAttrref((pwr_sAttrRef *)&o->Attribute[i],
&type, &dummy, &dummy, &dummy);
if (EVEN(sts)) {
errh_Error("Couldn't get datatype for %s's attribute DataName\n%m", name, sts);
gdh_UnrefObjectInfo(ep->data_subid[i]);
ep->datap[i] = 0;
continue;
}
tix = cdh_TypeIdToIndex(type);
ep->data_size[i] = cdh_TypeToSize( type);
if (!IsValidType(tix)) {
errh_Error("No valid datatype for %s's attribute DataName\n%m", name, DS__ERRTYPE);
gdh_UnrefObjectInfo(ep->data_subid[i]);
ep->datap[i] = 0;
continue;
}
o->AttributeType[i] = type;
/* Link to buffer */
sts = gdh_DLRefObjectInfoAttrref((pwr_sAttrRef *)&o->Buffers[i],
(pwr_tAddress *)&ep->buffheadp[i], &ep->buff_subid[i]);
if (EVEN(sts)) {
errh_Error("Couldn't get direct link to %s's buffer %d, %m", name, i+1, sts);
gdh_UnrefObjectInfo(ep->data_subid[i]);
ep->datap[i] = 0;
continue;
}
ep->buffp[i] = (char *)ep->buffheadp[i] + pwr_AlignLW(sizeof(pwr_sClass_CircBuffHeader));
/* Get buffer size */
sts = gdh_GetAttributeCharAttrref( &o->Buffers[i], 0, &ep->buff_size[i], 0, 0);
if ( EVEN(sts)) return sts;
ep->buff_size[i] -= pwr_AlignLW(sizeof(pwr_sClass_CircBuffHeader));
found = 1;
}
if ( !found) {
errh_Error("No valid attributes for %s", name);
gdh_UnrefObjectInfo(ep->o_subid);
free(ep);
continue;
}
/* Link to time buffer */
if ( cdh_ObjidIsNotNull( o->TimeBuffer.Objid)) {
sts = gdh_DLRefObjectInfoAttrref((pwr_sAttrRef *)&o->TimeBuffer,
(pwr_tAddress *)&ep->timeheadp, &ep->timebuff_subid);
if (EVEN(sts)) {
errh_Error("Couldn't get direct link to %s's time buffer, %m", name, sts);
ep->timeheadp = 0;
ep->timebuffp = 0;
}
else
ep->timebuffp = (char *)ep->timeheadp + pwr_AlignLW(sizeof(pwr_sClass_CircBuffHeader));
if ( o->TimeResolution == pwr_eTimeResolutionEnum_Nanosecond)
ep->time_size = 8;
else
ep->time_size = 4;
/* Get buffer size */
sts = gdh_GetAttributeCharAttrref( &o->TimeBuffer, 0, &ep->timebuff_size, 0, 0);
if ( EVEN(sts)) return sts;
ep->timebuff_size -= pwr_AlignLW(sizeof(pwr_sClass_CircBuffHeader));
}
/* Calculate number of samples */
for ( i = 0; i < 10; i++) {
if ( !ep->datap[i])
continue;
if ( o->NoOfSample > ep->buff_size[i] / ep->data_size[i])
o->NoOfSample = ep->buff_size[i] / ep->data_size[i];
}
if ( ep->timebuffp) {
if ( o->NoOfSample > ep->timebuff_size / ep->time_size)
o->NoOfSample = ep->timebuff_size / ep->time_size;
}
for ( i = 0; i < 10; i++) {
if ( !ep->datap[i])
continue;
ep->buffheadp[i]->Size = o->NoOfSample;
ep->buffheadp[i]->ElementSize = ep->data_size[i];
}
if ( ep->timebuffp) {
ep->timeheadp->Size = o->NoOfSample;
ep->timeheadp->ElementSize = ep->time_size;
}
ep->next = ctx->o_list_tc;
ctx->o_list_tc = ep;
}
if ( ctx->o_list == NULL && ctx->o_list_tc == NULL)
return DS__NOOBJECT;
else
return DS__SUCCESS;
}
virtual void OnIterStart(SActivationInfo *pActInfo)
{
const int type = GetPortInt(pActInfo, EIP_Type);
const char* area = GetPortString(pActInfo, EIP_Area);
// Find the entity
IEntitySystem *pEntitySystem = gEnv->pEntitySystem;
if (pEntitySystem)
{
IEntity *pArea = pEntitySystem->FindEntityByName(area);
if (pArea)
{
IEntityAreaProxy *pAreaProxy = (IEntityAreaProxy*)pArea->GetProxy(ENTITY_PROXY_AREA);
if (pAreaProxy)
{
Vec3 min, max, worldPos(pArea->GetWorldPos());
min.Set(0.f,0.f,0.f);
max.Set(0.f,0.f,0.f);
EEntityAreaType areaType = pAreaProxy->GetAreaType();
// Construct bounding space around area
switch (areaType)
{
case ENTITY_AREA_TYPE_BOX:
{
pAreaProxy->GetBox(min, max);
min += worldPos;
max += worldPos;
}
break;
case ENTITY_AREA_TYPE_SPHERE:
{
Vec3 center;
float radius = 0.f;
pAreaProxy->GetSphere(center, radius);
min.Set(center.x-radius, center.y-radius, center.z-radius);
max.Set(center.x+radius, center.y+radius, center.z+radius);
}
break;
case ENTITY_AREA_TYPE_SHAPE:
{
const Vec3 *points = pAreaProxy->GetPoints();
const int count = pAreaProxy->GetPointsCount();
if (count > 0)
{
Vec3 p = worldPos + points[0];
min = p;
max = p;
for (int i = 1; i < count; ++i)
{
p = worldPos + points[i];
if (p.x < min.x) min.x = p.x;
if (p.y < min.y) min.y = p.y;
if (p.z < min.z) min.z = p.z;
if (p.x > max.x) max.x = p.x;
if (p.y > max.y) max.y = p.y;
if (p.z > max.z) max.z = p.z;
}
}
}
break;
}
IPhysicalWorld *pWorld = gEnv->pPhysicalWorld;
IPhysicalEntity **ppList = NULL;
int numEnts = pWorld->GetEntitiesInBox(min,max,ppList,ent_all);
for (int i = 0; i < numEnts; ++i)
{
const EntityId id = pWorld->GetPhysicalEntityId(ppList[i]);
const EEntityType entityType = GetEntityType(id);
if (IsValidType(type, entityType))
{
// Sanity check - Test entity's position
IEntity *pEntity = pEntitySystem->GetEntity(id);
if (pEntity && pAreaProxy->CalcPointWithin(id, pEntity->GetWorldPos(), pAreaProxy->GetHeight()==0))
{
AddEntity(id);
}
}
}
}
}
}
}
bool TypedRegisterAllocator::IsTypeExcluded(Types type) const
{
return !IsValidType(type) || (mExcludedMask & (1 << type)) != 0;
}
