bool BaseAtom::CheckBounds(uint64_t size) {
if (CurrentPosition() + size > _start + _size) {
FATAL("Reached the end of the atom: Current pos: %"PRIu64"; Wanted size: %"PRIu64"; atom start: %"PRIu64"; atom size: %"PRIu64,
CurrentPosition(), size, _start, _size);
return false;
}
return true;
}
void OsmAnd::ObfTransportSectionReader_P::read( const ObfReader_P& reader, const std::shared_ptr<ObfTransportSectionInfo>& section )
{
const auto cis = reader.getCodedInputStream().get();
for(;;)
{
const auto tag = cis->ReadTag();
switch(gpb::internal::WireFormatLite::GetTagFieldNumber(tag))
{
case 0:
if (!ObfReaderUtilities::reachedDataEnd(cis))
return;
return;
case OBF::OsmAndTransportIndex::kRoutesFieldNumber:
ObfReaderUtilities::skipUnknownField(cis, tag);
break;
case OBF::OsmAndTransportIndex::kNameFieldNumber:
ObfReaderUtilities::readQString(cis, section->name);
break;
case OBF::OsmAndTransportIndex::kStopsFieldNumber:
{
section->_stopsLength = ObfReaderUtilities::readBigEndianInt(cis);
section->_stopsOffset = cis->CurrentPosition();
auto oldLimit = cis->PushLimit(section->_stopsLength);
readTransportStopsBounds(reader, section);
ObfReaderUtilities::ensureAllDataWasRead(cis);
cis->PopLimit(oldLimit);
}
break;
case OBF::OsmAndTransportIndex::kStringTableFieldNumber:
{
gpb::uint32 length;
cis->ReadVarint32(&length);
auto offset = cis->CurrentPosition();
cis->Seek(offset + length);
}
//TODO:
/*IndexStringTable st = new IndexStringTable();
st.length = codedIS.readRawVarint32();
st.fileOffset = codedIS.getTotalBytesRead();
// Do not cache for now save memory
// readStringTable(st, 0, 20, true);
ind.stringTable = st;
codedIS.seek(st.length + st.fileOffset);*/
break;
default:
ObfReaderUtilities::skipUnknownField(cis, tag);
break;
}
}
}
bool File::Seek(std::size_t offset, DataStream::SeekType seekType)
{
std::size_t seekPosition = 0;
switch (seekType)
{
case SeekType::Beginning:
seekPosition = offset;
break;
case SeekType::Current:
seekPosition = CurrentPosition() + offset;
break;
case SeekType::End:
{
std::size_t sizeInBytes = SizeInBytes();
if (offset > sizeInBytes)
{
return false;
}
seekPosition = (sizeInBytes - offset);
}
break;
default:
return false;
}
return (PHYSFS_seek(impl->physfsFileHandle, seekPosition) != 0);
}
void OsmAnd::ObfMapSectionReader_P::readTreeNodeChildren(
const std::unique_ptr<ObfReader_P>& reader, const std::shared_ptr<const ObfMapSectionInfo>& section,
const std::shared_ptr<ObfMapSectionLevelTreeNode>& treeNode,
MapFoundationType& foundation,
QList< std::shared_ptr<ObfMapSectionLevelTreeNode> >* nodesWithData,
const AreaI* bbox31,
IQueryController* controller)
{
auto cis = reader->_codedInputStream.get();
for(;;)
{
auto tag = cis->ReadTag();
switch(gpb::internal::WireFormatLite::GetTagFieldNumber(tag))
{
case 0:
return;
case OBF::OsmAndMapIndex_MapDataBox::kBoxesFieldNumber:
{
auto length = ObfReaderUtilities::readBigEndianInt(cis);
auto offset = cis->CurrentPosition();
auto oldLimit = cis->PushLimit(length);
std::shared_ptr<ObfMapSectionLevelTreeNode> childNode(new ObfMapSectionLevelTreeNode());
childNode->_foundation = treeNode->_foundation;
childNode->_offset = offset;
childNode->_length = length;
readTreeNode(reader, section, treeNode->_area31, childNode);
if(bbox31 && !bbox31->intersects(childNode->_area31))
{
cis->Skip(cis->BytesUntilLimit());
cis->PopLimit(oldLimit);
break;
}
cis->PopLimit(oldLimit);
if(childNode->_foundation != MapFoundationType::Undefined)
{
if(foundation == MapFoundationType::Undefined)
foundation = childNode->_foundation;
else if(foundation != childNode->_foundation)
foundation = MapFoundationType::Mixed;
}
if(nodesWithData && childNode->_dataOffset > 0)
nodesWithData->push_back(childNode);
cis->Seek(offset);
oldLimit = cis->PushLimit(length);
cis->Skip(childNode->_childrenInnerOffset);
readTreeNodeChildren(reader, section, childNode, foundation, nodesWithData, bbox31, controller);
assert(cis->BytesUntilLimit() == 0);
cis->PopLimit(oldLimit);
}
break;
default:
ObfReaderUtilities::skipUnknownField(cis, tag);
break;
}
}
}
bool
MediaSourceDecoder::CanPlayThrough()
{
MOZ_ASSERT(NS_IsMainThread());
if (NextFrameBufferedStatus() == MediaDecoderOwner::NEXT_FRAME_UNAVAILABLE) {
return false;
}
if (IsNaN(mMediaSource->Duration())) {
// Don't have any data yet.
return false;
}
TimeUnit duration = TimeUnit::FromSeconds(mMediaSource->Duration());
TimeUnit currentPosition = TimeUnit::FromMicroseconds(CurrentPosition());
if (duration.IsInfinite()) {
// We can't make an informed decision and just assume that it's a live stream
return true;
} else if (duration <= currentPosition) {
return true;
}
// If we have data up to the mediasource's duration or 30s ahead, we can
// assume that we can play without interruption.
TimeUnit timeAhead =
std::min(duration, currentPosition + TimeUnit::FromSeconds(30));
TimeInterval interval(currentPosition,
timeAhead,
MediaSourceDemuxer::EOS_FUZZ);
return GetBuffered().Contains(ClampIntervalToEnd(interval));
}
wxRect GuiderOneStar::GetBoundingBox(void)
{
enum { SUBFRAME_BOUNDARY_PX = 0 };
GUIDER_STATE state = GetState();
bool subframe;
PHD_Point pos;
switch (state) {
case STATE_SELECTED:
case STATE_CALIBRATING_PRIMARY:
case STATE_CALIBRATING_SECONDARY:
subframe = m_star.WasFound();
pos = CurrentPosition();
break;
case STATE_GUIDING: {
subframe = m_star.WasFound(); // true;
// As long as the star is close to the lock position, keep the subframe
// at the lock position. Otherwise, follow the star.
double dist = CurrentPosition().Distance(LockPosition());
if ((int) dist > m_searchRegion / 3)
pos = CurrentPosition();
else
pos = LockPosition();
break;
}
default:
subframe = false;
}
if (m_forceFullFrame)
{
subframe = false;
}
if (subframe)
{
wxRect box(SubframeRect(pos, m_searchRegion + SUBFRAME_BOUNDARY_PX));
box.Intersect(wxRect(0, 0, pCamera->FullSize.x, pCamera->FullSize.y));
return box;
}
else
{
return wxRect(0, 0, 0, 0);
}
}
void Mob::CalculateNewFearpoint()
{
if(RuleB(Pathing, Fear) && zone->pathing)
{
int Node = zone->pathing->GetRandomPathNode();
VERTEX Loc = zone->pathing->GetPathNodeCoordinates(Node);
++Loc.z;
VERTEX CurrentPosition(GetX(), GetY(), GetZ());
list<int> Route = zone->pathing->FindRoute(CurrentPosition, Loc);
if(Route.size() > 0)
{
fear_walkto_x = Loc.x;
fear_walkto_y = Loc.y;
fear_walkto_z = Loc.z;
curfp = true;
mlog(PATHING__DEBUG, "Feared to node %i (%8.3f, %8.3f, %8.3f)", Node, Loc.x, Loc.y, Loc.z);
return;
}
mlog(PATHING__DEBUG, "No path found to selected node. Falling through to old fear point selection.");
}
int loop = 0;
float ranx, rany, ranz;
curfp = false;
while (loop < 100) //Max 100 tries
{
int ran = 250 - (loop*2);
loop++;
ranx = GetX()+MakeRandomInt(0, ran-1)-MakeRandomInt(0, ran-1);
rany = GetY()+MakeRandomInt(0, ran-1)-MakeRandomInt(0, ran-1);
ranz = FindGroundZ(ranx,rany);
if (ranz == -999999)
continue;
float fdist = ranz - GetZ();
if (fdist >= -12 && fdist <= 12 && CheckCoordLosNoZLeaps(GetX(),GetY(),GetZ(),ranx,rany,ranz))
{
curfp = true;
break;
}
}
if (curfp)
{
fear_walkto_x = ranx;
fear_walkto_y = rany;
fear_walkto_z = ranz;
}
else //Break fear
{
BuffFadeByEffect(SE_Fear);
}
}
void OsmAnd::ObfAddressSectionReader_P::read( const ObfReader_P& reader, const std::shared_ptr<ObfAddressSectionInfo>& section )
{
auto cis = reader._codedInputStream.get();
for(;;)
{
auto tag = cis->ReadTag();
switch(gpb::internal::WireFormatLite::GetTagFieldNumber(tag))
{
case 0:
if (section->_latinName.isEmpty())
section->_latinName = ICU::transliterateToLatin(section->_name);
return;
case OBF::OsmAndAddressIndex::kNameFieldNumber:
ObfReaderUtilities::readQString(cis, section->_name);
break;
case OBF::OsmAndAddressIndex::kNameEnFieldNumber:
ObfReaderUtilities::readQString(cis, section->_latinName);
break;
case OBF::OsmAndAddressIndex::kCitiesFieldNumber:
{
const std::shared_ptr<ObfAddressBlocksSectionInfo> addressBlocksSection(new ObfAddressBlocksSectionInfo(section, section->owner));
addressBlocksSection->_length = ObfReaderUtilities::readBigEndianInt(cis);
addressBlocksSection->_offset = cis->CurrentPosition();
readAddressBlocksSectionHeader(reader, addressBlocksSection);
cis->Seek(addressBlocksSection->_offset + addressBlocksSection->_length);
section->_addressBlocksSections.push_back(qMove(addressBlocksSection));
}
break;
case OBF::OsmAndAddressIndex::kNameIndexFieldNumber:
{
auto indexNameOffset = cis->CurrentPosition();
auto length = ObfReaderUtilities::readBigEndianInt(cis);
cis->Seek(indexNameOffset + length + 4);
}
break;
default:
ObfReaderUtilities::skipUnknownField(cis, tag);
break;
}
}
}
void OsmAnd::ObfRoutingSectionReader_P::readSubsectionChildrenHeaders(
const std::unique_ptr<ObfReader_P>& reader, const std::shared_ptr<ObfRoutingSubsectionInfo>& subsection,
uint32_t depth /*= std::numeric_limits<uint32_t>::max()*/ )
{
if(!subsection->_subsectionsOffset)
return;
const auto shouldReadSubsections = (depth > 0 || subsection->_dataOffset != 0);
if(!shouldReadSubsections)
return;
auto cis = reader->_codedInputStream.get();
for(;;)
{
auto lastPos = cis->CurrentPosition();
auto tag = cis->ReadTag();
switch(gpb::internal::WireFormatLite::GetTagFieldNumber(tag))
{
case 0:
return;
case OBF::OsmAndRoutingIndex_RouteDataBox::kBoxesFieldNumber:
{
if(!shouldReadSubsections)
{
cis->Skip(cis->BytesUntilLimit());
break;
}
const std::shared_ptr<ObfRoutingSubsectionInfo> childSubsection(new ObfRoutingSubsectionInfo(subsection));
childSubsection->_length = ObfReaderUtilities::readBigEndianInt(cis);
childSubsection->_offset = cis->CurrentPosition();
auto oldLimit = cis->PushLimit(childSubsection->_length);
readSubsectionHeader(reader, childSubsection, subsection, depth - 1);
cis->PopLimit(oldLimit);
subsection->_subsections.push_back(qMove(childSubsection));
}
break;
default:
ObfReaderUtilities::skipUnknownField(cis, tag);
break;
}
}
}
void OsmAnd::ObfAddressSection::read( ObfReader* reader, ObfAddressSection* section )
{
auto cis = reader->_codedInputStream.get();
for(;;)
{
auto tag = cis->ReadTag();
switch(gpb::internal::WireFormatLite::GetTagFieldNumber(tag))
{
case 0:
if(section->_latinName.isEmpty())
section->_latinName = reader->transliterate(section->_name);
return;
case OBF::OsmAndAddressIndex::kNameFieldNumber:
ObfReader::readQString(cis, section->_name);
break;
case OBF::OsmAndAddressIndex::kNameEnFieldNumber:
ObfReader::readQString(cis, section->_latinName);
break;
case OBF::OsmAndAddressIndex::kCitiesFieldNumber:
{
std::shared_ptr<AddressBlocksSection> entry(new AddressBlocksSection(section->owner));
entry->_length = ObfReader::readBigEndianInt(cis);
entry->_offset = cis->CurrentPosition();
AddressBlocksSection::read(reader, entry.get());
cis->Seek(entry->_offset + entry->_length);
section->_blocksSections.push_back(entry);
}
break;
case OBF::OsmAndAddressIndex::kNameIndexFieldNumber:
{
section->_indexNameOffset = cis->CurrentPosition();
auto length = ObfReader::readBigEndianInt(cis);
cis->Seek(section->_indexNameOffset + length + 4);
}
break;
default:
ObfReader::skipUnknownField(cis, tag);
break;
}
}
}
void OsmAnd::ObfRoutingSectionReader_P::readBorderBoxLinesHeaders(const std::unique_ptr<ObfReader_P>& reader,
QList< std::shared_ptr<const ObfRoutingBorderLineHeader> >* resultOut /*= nullptr*/,
IQueryFilter* filter /*= nullptr*/,
std::function<bool (const std::shared_ptr<const ObfRoutingBorderLineHeader>&)> visitor /*= nullptr*/)
{
auto cis = reader->_codedInputStream.get();
for(;;)
{
auto tag = cis->ReadTag();
switch(gpb::internal::WireFormatLite::GetTagFieldNumber(tag))
{
case 0:
return;
case OBF::OsmAndRoutingIndex_RouteBorderBox::kBorderLinesFieldNumber:
{
auto offset = cis->CurrentPosition();
gpb::uint32 length;
cis->ReadVarint32(&length);
auto oldLimit = cis->PushLimit(length);
const std::shared_ptr<ObfRoutingBorderLineHeader> line(new ObfRoutingBorderLineHeader());
readBorderLineHeader(reader, line, offset);
cis->PopLimit(oldLimit);
bool isValid = true;
if(filter)
{
if(line->_x2present)
isValid = filter->acceptsArea(AreaI(line->_x, line->_y, line->_x2, line->_y));
else
isValid = false;
/*FIXME: borders approach
else if(ln.hasToy())
isValid = req.intersects(ln.getX(), ln.getY(), ln.getX(), ln.getToy());*/
}
if(isValid)
{
if(!visitor || (visitor && visitor(line)))
{
if(resultOut)
resultOut->push_back(qMove(line));
}
}
}
break;
case OBF::OsmAndRoutingIndex_RouteBorderBox::kBlocksFieldNumber:
return;
default:
ObfReaderUtilities::skipUnknownField(cis, tag);
break;
}
}
}
void OsmAnd::ObfAddressSectionReader_P::readBuildingsFromStreet(
const ObfReader_P& reader, const std::shared_ptr<const Model::Street>& street,
QList< std::shared_ptr<const Model::Building> >* resultOut,
std::function<bool (const std::shared_ptr<const OsmAnd::Model::Building>&)> visitor,
const IQueryController* const controller)
{
auto cis = reader._codedInputStream.get();
for(;;)
{
if (controller && controller->isAborted())
return;
auto tag = cis->ReadTag();
switch(gpb::internal::WireFormatLite::GetTagFieldNumber(tag))
{
case 0:
return;
case OBF::StreetIndex::kIntersectionsFieldNumber:
{
gpb::uint32 length;
cis->ReadVarint32(&length);
cis->Skip(length);
}
break;
case OBF::StreetIndex::kBuildingsFieldNumber:
{
auto offset = cis->CurrentPosition();
gpb::uint32 length;
cis->ReadVarint32(&length);
auto oldLimit = cis->PushLimit(length);
std::shared_ptr<Model::Building> building(new Model::Building());
building->_offset = offset;
readBuilding(reader, street, building);
cis->PopLimit(oldLimit);
if (!visitor || visitor(building))
{
if (resultOut)
resultOut->push_back(qMove(building));
}
}
break;
default:
ObfReaderUtilities::skipUnknownField(cis, tag);
break;
}
}
}
void Mob::CalculateNewFearpoint()
{
if(RuleB(Pathing, Fear) && zone->pathing)
{
int Node = zone->pathing->GetRandomPathNode();
glm::vec3 Loc = zone->pathing->GetPathNodeCoordinates(Node);
++Loc.z;
glm::vec3 CurrentPosition(GetX(), GetY(), GetZ());
std::deque<int> Route = zone->pathing->FindRoute(CurrentPosition, Loc);
if(Route.size() > 0)
{
m_FearWalkTarget = glm::vec3(Loc.x, Loc.y, Loc.z);
curfp = true;
Log.Out(Logs::Detail, Logs::None, "Feared to node %i (%8.3f, %8.3f, %8.3f)", Node, Loc.x, Loc.y, Loc.z);
return;
}
Log.Out(Logs::Detail, Logs::None, "No path found to selected node. Falling through to old fear point selection.");
}
int loop = 0;
float ranx, rany, ranz;
curfp = false;
while (loop < 100) //Max 100 tries
{
int ran = 250 - (loop*2);
loop++;
ranx = GetX()+zone->random.Int(0, ran-1)-zone->random.Int(0, ran-1);
rany = GetY()+zone->random.Int(0, ran-1)-zone->random.Int(0, ran-1);
ranz = FindGroundZ(ranx,rany);
if (ranz == -999999)
continue;
float fdist = ranz - GetZ();
if (fdist >= -12 && fdist <= 12 && CheckCoordLosNoZLeaps(GetX(),GetY(),GetZ(),ranx,rany,ranz))
{
curfp = true;
break;
}
}
if (curfp)
m_FearWalkTarget = glm::vec3(ranx, rany, ranz);
else //Break fear
BuffFadeByEffect(SE_Fear);
}
void OsmAnd::ObfMapSectionReader_P::read(
const ObfReader_P& reader,
const std::shared_ptr<ObfMapSectionInfo>& section)
{
const auto cis = reader.getCodedInputStream().get();
for (;;)
{
const auto tag = cis->ReadTag();
switch (gpb::internal::WireFormatLite::GetTagFieldNumber(tag))
{
case 0:
if (!ObfReaderUtilities::reachedDataEnd(cis))
return;
return;
case OBF::OsmAndMapIndex::kNameFieldNumber:
{
ObfReaderUtilities::readQString(cis, section->name);
section->isBasemap = section->name.contains(QLatin1String("basemap"), Qt::CaseInsensitive);
section->isBasemapWithCoastlines = section->name == QLatin1String("basemap");
break;
}
case OBF::OsmAndMapIndex::kRulesFieldNumber:
ObfReaderUtilities::skipBlockWithLength(cis);
break;
case OBF::OsmAndMapIndex::kLevelsFieldNumber:
{
auto length = ObfReaderUtilities::readBigEndianInt(cis);
auto offset = cis->CurrentPosition();
auto oldLimit = cis->PushLimit(length);
Ref<ObfMapSectionLevel> levelRoot(new ObfMapSectionLevel());
levelRoot->length = length;
levelRoot->offset = offset;
readMapLevelHeader(reader, levelRoot);
ObfReaderUtilities::ensureAllDataWasRead(cis);
cis->PopLimit(oldLimit);
section->levels.push_back(qMove(levelRoot));
break;
}
default:
ObfReaderUtilities::skipUnknownField(cis, tag);
break;
}
}
}
bool StepGuider::WouldHitLimit(GUIDE_DIRECTION direction, int steps)
{
bool bReturn = false;
assert(steps >= 0);
if (CurrentPosition(direction) + steps >= MaxPosition(direction))
{
bReturn = true;
}
Debug.AddLine(wxString::Format("WouldHitLimit=%d current=%d, steps=%d, max=%d", bReturn, CurrentPosition(direction), steps, MaxPosition(direction)));
return bReturn;
}
void OsmAnd::ObfMapSectionReader_P::readMapLevelHeader(
const std::unique_ptr<ObfReader_P>& reader, const std::shared_ptr<const ObfMapSectionInfo>& section,
const std::shared_ptr<ObfMapSectionLevel>& level )
{
auto cis = reader->_codedInputStream.get();
for(;;)
{
const auto tagPos = cis->CurrentPosition();
const auto tag = cis->ReadTag();
switch(gpb::internal::WireFormatLite::GetTagFieldNumber(tag))
{
case 0:
return;
case OBF::OsmAndMapIndex_MapRootLevel::kMaxZoomFieldNumber:
cis->ReadVarint32(reinterpret_cast<gpb::uint32*>(&level->_maxZoom));
break;
case OBF::OsmAndMapIndex_MapRootLevel::kMinZoomFieldNumber:
cis->ReadVarint32(reinterpret_cast<gpb::uint32*>(&level->_minZoom));
break;
case OBF::OsmAndMapIndex_MapRootLevel::kLeftFieldNumber:
cis->ReadVarint32(reinterpret_cast<gpb::uint32*>(&level->_area31.left));
break;
case OBF::OsmAndMapIndex_MapRootLevel::kRightFieldNumber:
cis->ReadVarint32(reinterpret_cast<gpb::uint32*>(&level->_area31.right));
break;
case OBF::OsmAndMapIndex_MapRootLevel::kTopFieldNumber:
cis->ReadVarint32(reinterpret_cast<gpb::uint32*>(&level->_area31.top));
break;
case OBF::OsmAndMapIndex_MapRootLevel::kBottomFieldNumber:
cis->ReadVarint32(reinterpret_cast<gpb::uint32*>(&level->_area31.bottom));
break;
case OBF::OsmAndMapIndex_MapRootLevel::kBoxesFieldNumber:
{
// Save boxes offset
level->_boxesInnerOffset = tagPos - level->_offset;
// Skip reading boxes and surely, following blocks
cis->Skip(cis->BytesUntilLimit());
}
return;
default:
ObfReaderUtilities::skipUnknownField(cis, tag);
break;
}
}
}
void OsmAnd::ObfMapSectionReader_P::readMapLevelTreeNodes(
const ObfReader_P& reader,
const std::shared_ptr<const ObfMapSectionInfo>& section,
const std::shared_ptr<const ObfMapSectionLevel>& level,
QList< std::shared_ptr<const ObfMapSectionLevelTreeNode> >& trees)
{
const auto cis = reader.getCodedInputStream().get();
bool atLeastOneMapRootLevelRead = false;
for (;;)
{
gpb::uint32 tag = cis->ReadTag();
switch (gpb::internal::WireFormatLite::GetTagFieldNumber(tag))
{
case 0:
if (!ObfReaderUtilities::reachedDataEnd(cis))
return;
return;
case OBF::OsmAndMapIndex_MapRootLevel::kBoxesFieldNumber:
{
const auto length = ObfReaderUtilities::readBigEndianInt(cis);
const auto offset = cis->CurrentPosition();
const auto oldLimit = cis->PushLimit(length);
const std::shared_ptr<ObfMapSectionLevelTreeNode> levelTree(new ObfMapSectionLevelTreeNode(level));
levelTree->offset = offset;
levelTree->length = length;
readTreeNode(reader, section, level->area31, levelTree);
ObfReaderUtilities::ensureAllDataWasRead(cis);
cis->PopLimit(oldLimit);
trees.push_back(qMove(levelTree));
atLeastOneMapRootLevelRead = true;
break;
}
default:
if (atLeastOneMapRootLevelRead)
return;
ObfReaderUtilities::skipUnknownField(cis, tag);
break;
}
}
}
void OsmAnd::ObfMapSectionReader_P::readAttributeMapping(
const ObfReader_P& reader,
const std::shared_ptr<const ObfMapSectionInfo>& section,
const std::shared_ptr<ObfMapSectionAttributeMapping>& attributeMapping)
{
const auto cis = reader.getCodedInputStream().get();
bool atLeastOneRuleWasRead = false;
uint32_t naturalId = 1;
for (;;)
{
gpb::uint32 tag = cis->ReadTag();
switch (gpb::internal::WireFormatLite::GetTagFieldNumber(tag))
{
case 0:
if (!ObfReaderUtilities::reachedDataEnd(cis))
return;
attributeMapping->verifyRequiredMappingRegistered();
return;
case OBF::OsmAndMapIndex::kRulesFieldNumber:
{
gpb::uint32 length;
cis->ReadVarint32(&length);
const auto offset = cis->CurrentPosition();
auto oldLimit = cis->PushLimit(length);
readAttributeMappingEntry(reader, naturalId++, attributeMapping);
ObfReaderUtilities::ensureAllDataWasRead(cis);
cis->PopLimit(oldLimit);
atLeastOneRuleWasRead = true;
break;
}
default:
if (atLeastOneRuleWasRead)
{
attributeMapping->verifyRequiredMappingRegistered();
return;
}
ObfReaderUtilities::skipUnknownField(cis, tag);
break;
}
}
}
void OsmAnd::ObfAddressSectionReader_P::readStreetGroupsFromAddressBlocksSection(
const ObfReader_P& reader, const std::shared_ptr<const ObfAddressBlocksSectionInfo>& section,
QList< std::shared_ptr<const Model::StreetGroup> >* resultOut,
std::function<bool (const std::shared_ptr<const OsmAnd::Model::StreetGroup>&)> visitor, const IQueryController* const controller )
{
auto cis = reader._codedInputStream.get();
for(;;)
{
if (controller && controller->isAborted())
break;
auto tag = cis->ReadTag();
switch(gpb::internal::WireFormatLite::GetTagFieldNumber(tag))
{
case 0:
return;
case OBF::OsmAndAddressIndex_CitiesIndex::kCitiesFieldNumber:
{
auto offset = cis->CurrentPosition();
gpb::uint32 length;
cis->ReadVarint32(&length);
auto oldLimit = cis->PushLimit(length);
std::shared_ptr<OsmAnd::Model::StreetGroup> streetGroup;
readStreetGroupHeader(reader, section, offset, streetGroup);
cis->PopLimit(oldLimit);
if (streetGroup)
{
if (!visitor || visitor(streetGroup))
{
if (resultOut)
resultOut->push_back(qMove(streetGroup));
}
}
}
break;
default:
ObfReaderUtilities::skipUnknownField(cis, tag);
break;
}
}
}
void OsmAnd::ObfAddressSectionReader_P::readStreetsFromGroup(
const ObfReader_P& reader, const std::shared_ptr<const Model::StreetGroup>& group,
QList< std::shared_ptr<const Model::Street> >* resultOut,
std::function<bool (const std::shared_ptr<const OsmAnd::Model::Street>&)> visitor,
const IQueryController* const controller)
{
auto cis = reader._codedInputStream.get();
for(;;)
{
if (controller && controller->isAborted())
return;
auto tag = cis->ReadTag();
switch(gpb::internal::WireFormatLite::GetTagFieldNumber(tag))
{
case 0:
return;
case OBF::CityBlockIndex::kStreetsFieldNumber:
{
std::shared_ptr<Model::Street> street(new Model::Street(/*TODO:group*/));
street->_offset = cis->CurrentPosition();
gpb::uint32 length;
cis->ReadVarint32(&length);
auto oldLimit = cis->PushLimit(length);
readStreet(reader, group, street);
cis->PopLimit(oldLimit);
if (!visitor || visitor(street))
{
if (resultOut)
resultOut->push_back(qMove(street));
}
}
break;
case OBF::CityBlockIndex::kBuildingsFieldNumber:
// buildings for the town are not used now
default:
ObfReaderUtilities::skipUnknownField(cis, tag);
break;
}
}
}
void OsmAnd::ObfMapSectionReader_P::read(
const std::unique_ptr<ObfReader_P>& reader, const std::shared_ptr<ObfMapSectionInfo>& section )
{
auto cis = reader->_codedInputStream.get();
for(;;)
{
auto tag = cis->ReadTag();
switch(gpb::internal::WireFormatLite::GetTagFieldNumber(tag))
{
case 0:
return;
case OBF::OsmAndMapIndex::kNameFieldNumber:
{
ObfReaderUtilities::readQString(cis, section->_name);
section->_isBasemap = (QString::compare(section->_name, QLatin1String("basemap"), Qt::CaseInsensitive) == 0);
}
break;
case OBF::OsmAndMapIndex::kRulesFieldNumber:
ObfReaderUtilities::skipUnknownField(cis, tag);
break;
case OBF::OsmAndMapIndex::kLevelsFieldNumber:
{
auto length = ObfReaderUtilities::readBigEndianInt(cis);
auto offset = cis->CurrentPosition();
auto oldLimit = cis->PushLimit(length);
const std::shared_ptr<ObfMapSectionLevel> levelRoot(new ObfMapSectionLevel());
levelRoot->_length = length;
levelRoot->_offset = offset;
readMapLevelHeader(reader, section, levelRoot);
cis->PopLimit(oldLimit);
section->_levels.push_back(qMove(levelRoot));
}
break;
default:
ObfReaderUtilities::skipUnknownField(cis, tag);
break;
}
}
}
bool BoxAtom::Read() {
while (CurrentPosition() != _start + _size) {
BaseAtom *pAtom = GetDoc()->ReadAtom(this);
if (pAtom == NULL) {
FATAL("Unable to read atom. Parent atom is %s",
STR(GetTypeString()));
return false;
}
if (!pAtom->IsIgnored()) {
if (!AtomCreated(pAtom)) {
FATAL("Unable to signal AtomCreated for atom %s (%"PRIx64")",
STR(GetTypeString()), _start);
return false;
}
}
ADD_VECTOR_END(_subAtoms, pAtom);
}
return true;
}
MediaDecoderOwner::NextFrameStatus
MediaSourceDecoder::NextFrameBufferedStatus()
{
MOZ_ASSERT(NS_IsMainThread());
if (!mMediaSource ||
mMediaSource->ReadyState() == dom::MediaSourceReadyState::Closed) {
return MediaDecoderOwner::NEXT_FRAME_UNAVAILABLE;
}
// Next frame hasn't been decoded yet.
// Use the buffered range to consider if we have the next frame available.
TimeUnit currentPosition = TimeUnit::FromMicroseconds(CurrentPosition());
TimeInterval interval(currentPosition,
currentPosition + media::TimeUnit::FromMicroseconds(DEFAULT_NEXT_FRAME_AVAILABLE_BUFFERED),
MediaSourceDemuxer::EOS_FUZZ);
return GetBuffered().Contains(ClampIntervalToEnd(interval))
? MediaDecoderOwner::NEXT_FRAME_AVAILABLE
: MediaDecoderOwner::NEXT_FRAME_UNAVAILABLE;
}
void CWaveReader::SetSmoothingPeriod(int period)
{
if (_smoothingBuffer!=NULL)
{
delete [] _smoothingBuffer;
_smoothingBuffer=NULL;
}
_smoothingPeriod = period;
if (_smoothingPeriod!=0)
{
_smoothingBuffer = new int[_smoothingPeriod];
memset(_smoothingBuffer, 0, sizeof(int) * _smoothingPeriod);
_smoothingBufferPos=0;
_smoothingBufferTotal=0;
}
Seek(CurrentPosition());
}
void OsmAnd::ObfPoiSectionReader_P::readCategories(
const ObfReader_P& reader, const std::shared_ptr<const ObfPoiSectionInfo>& section,
QList< std::shared_ptr<const AmenityCategory> >& categories )
{
const auto cis = reader.getCodedInputStream().get();
for(;;)
{
const auto tag = cis->ReadTag();
switch(gpb::internal::WireFormatLite::GetTagFieldNumber(tag))
{
case 0:
if (!ObfReaderUtilities::reachedDataEnd(cis))
return;
return;
case OBF::OsmAndPoiIndex::kCategoriesTableFieldNumber:
{
gpb::uint32 length;
cis->ReadVarint32(&length);
const auto offset = cis->CurrentPosition();
auto oldLimit = cis->PushLimit(length);
std::shared_ptr<AmenityCategory> category(new AmenityCategory());
readCategory(reader, category);
ObfReaderUtilities::ensureAllDataWasRead(cis);
cis->PopLimit(oldLimit);
categories.push_back(qMove(category));
}
break;
case OBF::OsmAndPoiIndex::kNameIndexFieldNumber:
cis->Skip(cis->BytesUntilLimit());
return;
default:
ObfReaderUtilities::skipUnknownField(cis, tag);
break;
}
}
}
void CWaveReader::Seek(int sampleNumber)
{
// Go back by size of smoothing buffer
int startAtSampleNumber = sampleNumber - (_smoothingPeriod+1);
if (startAtSampleNumber<0)
startAtSampleNumber = 0;
// Seek to sample
SeekRaw(startAtSampleNumber);
// Reset and refill the smoothing buffer
memset(_smoothingBuffer, 0, _smoothingPeriod * sizeof(int));
_smoothingBufferPos=0;
_smoothingBufferTotal=0;
while (CurrentPosition() < sampleNumber)
{
if (!NextSample())
break;
}
}
void OsmAnd::ObfMapSectionReader_P::readMapLevelTreeNodes(
const std::unique_ptr<ObfReader_P>& reader, const std::shared_ptr<const ObfMapSectionInfo>& section,
const std::shared_ptr<const ObfMapSectionLevel>& level, QList< std::shared_ptr<ObfMapSectionLevelTreeNode> >& trees )
{
auto cis = reader->_codedInputStream.get();
for(;;)
{
gpb::uint32 tag = cis->ReadTag();
switch(gpb::internal::WireFormatLite::GetTagFieldNumber(tag))
{
case 0:
return;
case OBF::OsmAndMapIndex_MapRootLevel::kBoxesFieldNumber:
{
const auto length = ObfReaderUtilities::readBigEndianInt(cis);
const auto offset = cis->CurrentPosition();
const auto oldLimit = cis->PushLimit(length);
std::shared_ptr<ObfMapSectionLevelTreeNode> levelTree(new ObfMapSectionLevelTreeNode(level));
levelTree->_offset = offset;
levelTree->_length = length;
readTreeNode(reader, section, level->area31, levelTree);
cis->PopLimit(oldLimit);
trees.push_back(qMove(levelTree));
}
break;
case OBF::OsmAndMapIndex_MapRootLevel::kBlocksFieldNumber:
cis->Skip(cis->BytesUntilLimit());
return;
default:
ObfReaderUtilities::skipUnknownField(cis, tag);
break;
}
}
}
bool OsmAnd::ObfReader_P::readInfo(const ObfReader_P& reader, std::shared_ptr<const ObfInfo>& info_)
{
auto cis = reader._codedInputStream.get();
std::shared_ptr<ObfInfo> info(new ObfInfo());
bool loadedCorrectly = false;
for(;;)
{
auto tag = cis->ReadTag();
switch(gpb::internal::WireFormatLite::GetTagFieldNumber(tag))
{
case 0:
if(loadedCorrectly)
info_ = info;
return loadedCorrectly;
case OBF::OsmAndStructure::kVersionFieldNumber:
cis->ReadVarint32(reinterpret_cast<gpb::uint32*>(&info->_version));
break;
case OBF::OsmAndStructure::kDateCreatedFieldNumber:
cis->ReadVarint64(reinterpret_cast<gpb::uint64*>(&info->_creationTimestamp));
break;
case OBF::OsmAndStructure::kMapIndexFieldNumber:
{
const std::shared_ptr<ObfMapSectionInfo> section(new ObfMapSectionInfo(info));
section->_length = ObfReaderUtilities::readBigEndianInt(cis);
section->_offset = cis->CurrentPosition();
auto oldLimit = cis->PushLimit(section->_length);
ObfMapSectionReader_P::read(reader, section);
info->_isBasemap = info->_isBasemap || section->isBasemap;
cis->PopLimit(oldLimit);
cis->Seek(section->_offset + section->_length);
info->_mapSections.push_back(qMove(section));
}
break;
case OBF::OsmAndStructure::kAddressIndexFieldNumber:
{
const std::shared_ptr<ObfAddressSectionInfo> section(new ObfAddressSectionInfo(info));
section->_length = ObfReaderUtilities::readBigEndianInt(cis);
section->_offset = cis->CurrentPosition();
auto oldLimit = cis->PushLimit(section->_length);
ObfAddressSectionReader_P::read(reader, section);
cis->PopLimit(oldLimit);
cis->Seek(section->_offset + section->_length);
info->_addressSections.push_back(qMove(section));
}
break;
case OBF::OsmAndStructure::kTransportIndexFieldNumber:
{
const std::shared_ptr<ObfTransportSectionInfo> section(new ObfTransportSectionInfo(info));
section->_length = ObfReaderUtilities::readBigEndianInt(cis);
section->_offset = cis->CurrentPosition();
auto oldLimit = cis->PushLimit(section->_length);
ObfTransportSectionReader_P::read(reader, section);
cis->PopLimit(oldLimit);
cis->Seek(section->_offset + section->_length);
info->_transportSections.push_back(qMove(section));
}
break;
case OBF::OsmAndStructure::kRoutingIndexFieldNumber:
{
const std::shared_ptr<ObfRoutingSectionInfo> section(new ObfRoutingSectionInfo(info));
section->_length = ObfReaderUtilities::readBigEndianInt(cis);
section->_offset = cis->CurrentPosition();
auto oldLimit = cis->PushLimit(section->_length);
ObfRoutingSectionReader_P::read(reader, section);
cis->PopLimit(oldLimit);
cis->Seek(section->_offset + section->_length);
info->_routingSections.push_back(qMove(section));
}
break;
case OBF::OsmAndStructure::kPoiIndexFieldNumber:
{
const std::shared_ptr<ObfPoiSectionInfo> section(new ObfPoiSectionInfo(info));
section->_length = ObfReaderUtilities::readBigEndianInt(cis);
section->_offset = cis->CurrentPosition();
auto oldLimit = cis->PushLimit(section->_length);
ObfPoiSectionReader_P::read(reader, section);
cis->PopLimit(oldLimit);
cis->Seek(section->_offset + section->_length);
info->_poiSections.push_back(qMove(section));
}
break;
case OBF::OsmAndStructure::kVersionConfirmFieldNumber:
{
gpb::uint32 controlVersion;
cis->ReadVarint32(&controlVersion);
loadedCorrectly = (controlVersion == info->_version);
if(!loadedCorrectly)
break;
}
break;
default:
ObfReaderUtilities::skipUnknownField(cis, tag);
break;
}
}
return false;
}
Mount::MOVE_RESULT StepGuider::Move(const PHD_Point& cameraVectorEndpoint, bool normalMove)
{
MOVE_RESULT result = MOVE_OK;
try
{
MOVE_RESULT mountResult = Mount::Move(cameraVectorEndpoint, normalMove);
if (mountResult != MOVE_OK)
Debug.AddLine("StepGuider::Move: Mount::Move failed!");
if (!m_guidingEnabled)
{
throw THROW_INFO("Guiding disabled");
}
// keep a moving average of the AO position
if (m_avgOffset.IsValid())
{
static double const alpha = .33; // moderately high weighting for latest sample
m_avgOffset.X += alpha * (m_xOffset - m_avgOffset.X);
m_avgOffset.Y += alpha * (m_yOffset - m_avgOffset.Y);
}
else
{
m_avgOffset.SetXY((double) m_xOffset, (double) m_yOffset);
}
pFrame->pStepGuiderGraph->AppendData(m_xOffset, m_yOffset, m_avgOffset);
// consider bumping the secondary mount if this is a normal move
if (normalMove && pSecondaryMount && pSecondaryMount->IsConnected())
{
int absX = abs(CurrentPosition(RIGHT));
int absY = abs(CurrentPosition(UP));
bool isOutside = absX > m_xBumpPos1 || absY > m_yBumpPos1;
bool forceStartBump = false;
if (m_forceStartBump)
{
Debug.Write("stepguider::Move: will start forced bump\n");
forceStartBump = true;
m_forceStartBump = false;
}
// if the current bump has not brought us in, increase the bump size
if (isOutside && m_bumpInProgress)
{
if (absX > m_xBumpPos2 || absY > m_yBumpPos2)
{
Debug.AddLine("FAR outside bump range, increase bump weight %.2f => %.2f", m_bumpStepWeight, m_bumpStepWeight + 1.0);
m_bumpStepWeight += 1.0;
}
else
{
Debug.AddLine("outside bump range, increase bump weight %.2f => %.2f", m_bumpStepWeight, m_bumpStepWeight + 1./6.);
m_bumpStepWeight += 1./6.;
}
}
// if we are back inside, decrease the bump weight
if (!isOutside && m_bumpStepWeight > 1.0)
{
double prior = m_bumpStepWeight;
m_bumpStepWeight *= 0.5;
if (m_bumpStepWeight < 1.0)
m_bumpStepWeight = 1.0;
Debug.AddLine("back inside bump range: decrease bump weight %.2f => %.2f", prior, m_bumpStepWeight);
}
if (m_bumpInProgress && !m_bumpTimeoutAlertSent)
{
long now = ::wxGetUTCTime();
if (now - m_bumpStartTime > BumpWarnTime)
{
pFrame->Alert(_("A mount \"bump\" was needed to bring the AO back to its center position,\n"
"but the bump did not complete in a reasonable amount of time.\n"
"You probably need to increase the AO Bump Step setting."), wxICON_INFORMATION);
m_bumpTimeoutAlertSent = true;
}
}
if ((isOutside || forceStartBump) && !m_bumpInProgress)
{
// start a new bump
m_bumpInProgress = true;
m_bumpStartTime = ::wxGetUTCTime();
m_bumpTimeoutAlertSent = false;
Debug.AddLine("starting a new bump");
}
// stop the bump if we are "close enough" to the center position
if ((!isOutside || forceStartBump) && m_bumpInProgress)
{
int minDist = m_bumpCenterTolerance;
if (m_avgOffset.X * m_avgOffset.X + m_avgOffset.Y * m_avgOffset.Y <= minDist * minDist)
{
Debug.AddLine("Stop bumping, close enough to center -- clearing m_bumpInProgress");
m_bumpInProgress = false;
pFrame->pStepGuiderGraph->ShowBump(PHD_Point());
}
}
}
if (m_bumpInProgress && pSecondaryMount->IsBusy())
Debug.AddLine("secondary mount is busy, cannot bump");
// if we have a bump in progress and the secondary mount is not moving,
// schedule another move
if (m_bumpInProgress && !pSecondaryMount->IsBusy())
{
// compute incremental bump based on average position
PHD_Point vectorEndpoint(xRate() * -m_avgOffset.X, yRate() * -m_avgOffset.Y);
// we have to transform our notion of where we are (which is in "AO Coordinates")
// into "Camera Coordinates" so we can bump the secondary mount to put us closer
// to the center of the AO
PHD_Point bumpVec;
if (TransformMountCoordinatesToCameraCoordinates(vectorEndpoint, bumpVec))
{
throw ERROR_INFO("MountToCamera failed");
}
Debug.AddLine("incremental bump (%.3f, %.3f) isValid = %d", bumpVec.X, bumpVec.Y, bumpVec.IsValid());
double maxBumpPixelsX = m_calibration.xRate * m_bumpMaxStepsPerCycle * m_bumpStepWeight;
double maxBumpPixelsY = m_calibration.yRate * m_bumpMaxStepsPerCycle * m_bumpStepWeight;
double len = bumpVec.Distance();
double xBumpSize = bumpVec.X * maxBumpPixelsX / len;
double yBumpSize = bumpVec.Y * maxBumpPixelsY / len;
PHD_Point thisBump(xBumpSize, yBumpSize);
// display the current bump vector on the stepguider graph
{
PHD_Point tcur;
TransformCameraCoordinatesToMountCoordinates(thisBump, tcur);
tcur.X /= xRate();
tcur.Y /= yRate();
pFrame->pStepGuiderGraph->ShowBump(tcur);
}
Debug.AddLine("Scheduling Mount bump of (%.3f, %.3f)", thisBump.X, thisBump.Y);
pFrame->ScheduleSecondaryMove(pSecondaryMount, thisBump, false);
}
}
catch (wxString Msg)
{
POSSIBLY_UNUSED(Msg);
result = MOVE_ERROR;
}
return result;
}
Mount::MOVE_RESULT StepGuider::Move(GUIDE_DIRECTION direction, int steps, bool normalMove, MoveResultInfo *moveResult)
{
MOVE_RESULT result = MOVE_OK;
bool limitReached = false;
try
{
Debug.AddLine(wxString::Format("Move(%d, %d, %d)", direction, steps, normalMove));
// Compute the required guide steps
if (!m_guidingEnabled)
{
throw THROW_INFO("Guiding disabled");
}
// Acutally do the guide
assert(steps >= 0);
if (steps > 0)
{
int yDirection = 0;
int xDirection = 0;
switch (direction)
{
case UP:
yDirection = 1;
break;
case DOWN:
yDirection = -1;
break;
case RIGHT:
xDirection = 1;
break;
case LEFT:
xDirection = -1;
break;
default:
throw ERROR_INFO("StepGuider::Move(): invalid direction");
break;
}
assert(yDirection == 0 || xDirection == 0);
assert(yDirection != 0 || xDirection != 0);
Debug.AddLine(wxString::Format("stepping direction=%d steps=%d xDirection=%d yDirection=%d", direction, steps, xDirection, yDirection));
if (WouldHitLimit(direction, steps))
{
int new_steps = MaxPosition(direction) - 1 - CurrentPosition(direction);
Debug.AddLine(wxString::Format("StepGuider step would hit limit: truncate move direction=%d steps=%d => %d", direction, steps, new_steps));
steps = new_steps;
limitReached = true;
}
if (steps > 0)
{
if (Step(direction, steps))
{
throw ERROR_INFO("step failed");
}
m_xOffset += xDirection * steps;
m_yOffset += yDirection * steps;
Debug.AddLine(wxString::Format("stepped: xOffset=%d yOffset=%d", m_xOffset, m_yOffset));
}
}
}
catch (const wxString& Msg)
{
POSSIBLY_UNUSED(Msg);
steps = 0;
result = MOVE_ERROR;
}
if (moveResult)
{
moveResult->amountMoved = steps;
moveResult->limited = limitReached;
}
return result;
}