bool IsInfoEmpty(const Dump& info)
{
assert(info.size() == 53);
//28 is fixed
//25 is title
const Dump::const_iterator titleStart = info.begin() + 28;
return info.end() == std::find_if(titleStart, info.end(), std::bind2nd(std::greater<Char>(), Char(' ')));
}
void ApplyInsertions(Dump& result) const
{
if (0 == SizeAddon)
{
return;
}
Dump tmp(result.size() + SizeAddon);
Dump::const_iterator src = result.begin();
const Dump::const_iterator srcEnd = result.end();
auto dst = tmp.begin();
std::size_t oldOffset = 0;
for (const auto& ins : Insertions)
{
if (const std::size_t toCopy = ins.first - oldOffset)
{
const Dump::const_iterator nextEnd = src + toCopy;
dst = std::copy(src, nextEnd, dst);
src = nextEnd;
oldOffset += toCopy;
}
dst = std::copy(ins.second.begin(), ins.second.end(), dst);
}
std::copy(src, srcEnd, dst);
result.swap(tmp);
}
bool DecodeData()
{
const uint8_t* const rawData = static_cast<const uint8_t*>(Header.ID);
const std::size_t dataOffset = fromLE(Header.DataOffset);
const uint_t cylinders = fromLE(Header.Cylinders);
const uint_t sides = fromLE(Header.Sides);
Dump result;
result.reserve(FDI_MAX_SIZE);
std::size_t trackInfoOffset = sizeof(Header) + fromLE(Header.InfoSize);
std::size_t rawSize = dataOffset;
for (uint_t cyl = 0; cyl != cylinders; ++cyl)
{
for (uint_t sid = 0; sid != sides; ++sid)
{
if (trackInfoOffset + sizeof(RawTrack) > Limit)
{
return false;
}
const RawTrack* const trackInfo = safe_ptr_cast<const RawTrack*>(rawData + trackInfoOffset);
typedef std::vector<SectorDescr> SectorDescrs;
//collect sectors reference
SectorDescrs sectors;
sectors.reserve(trackInfo->SectorsCount);
for (std::size_t secNum = 0; secNum != trackInfo->SectorsCount; ++secNum)
{
const RawTrack::Sector* const sector = trackInfo->Sectors + secNum;
const std::size_t secSize = 128 << sector->Size;
//since there's no information about head number (always 0), do not check it
//assert(sector->Head == sid);
if (sector->Cylinder != cyl)
{
return false;
}
const std::size_t offset = dataOffset + fromLE(sector->Offset) + fromLE(trackInfo->Offset);
if (offset + secSize > Limit)
{
return false;
}
sectors.push_back(SectorDescr(sector->Number, rawData + offset, rawData + offset + secSize));
rawSize = std::max(rawSize, offset + secSize);
}
//sort by number
std::sort(sectors.begin(), sectors.end());
//and gather data
for (SectorDescrs::const_iterator it = sectors.begin(), lim = sectors.end(); it != lim; ++it)
{
result.insert(result.end(), it->Begin, it->End);
}
//calculate next track by offset
trackInfoOffset += sizeof(*trackInfo) + (trackInfo->SectorsCount - 1) * sizeof(trackInfo->Sectors);
}
}
UsedSize = rawSize;
Decoded.swap(result);
return true;
}
void AddData(const Dump& str)
{
std::copy(str.begin(), str.end(), std::back_inserter(Data));
}
