UINT GenerateWpsPinCode(
IN PRTMP_ADAPTER pAd,
IN BOOLEAN bFromApcli,
IN UCHAR apidx)
{
UCHAR macAddr[MAC_ADDR_LEN];
UINT iPin;
UINT checksum;
NdisZeroMemory(macAddr, MAC_ADDR_LEN);
#ifdef CONFIG_AP_SUPPORT
IF_DEV_CONFIG_OPMODE_ON_AP(pAd)
{
#ifdef APCLI_SUPPORT
if (bFromApcli)
NdisMoveMemory(&macAddr[0], pAd->ApCfg.ApCliTab[apidx].wdev.if_addr, MAC_ADDR_LEN);
else
#endif /* APCLI_SUPPORT */
NdisMoveMemory(&macAddr[0], pAd->ApCfg.MBSSID[apidx].wdev.if_addr, MAC_ADDR_LEN);
}
#endif /* CONFIG_AP_SUPPORT */
iPin = macAddr[3] * 256 * 256 + macAddr[4] * 256 + macAddr[5];
iPin = iPin % 10000000;
checksum = ComputeChecksum( iPin );
iPin = iPin*10 + checksum;
return iPin;
}
UINT GenerateWpsPinCode(
IN PRTMP_ADAPTER pAd,
IN BOOLEAN bFromApcli,
IN UCHAR apidx)
{
UCHAR macAddr[MAC_ADDR_LEN];
UINT iPin;
UINT checksum;
NdisZeroMemory(macAddr, MAC_ADDR_LEN);
#ifdef CONFIG_STA_SUPPORT
IF_DEV_CONFIG_OPMODE_ON_STA(pAd)
NdisMoveMemory(&macAddr[0], pAd->CurrentAddress, MAC_ADDR_LEN);
#endif /* CONFIG_STA_SUPPORT */
iPin = macAddr[3] * 256 * 256 + macAddr[4] * 256 + macAddr[5];
iPin = iPin % 10000000;
checksum = ComputeChecksum( iPin );
iPin = iPin*10 + checksum;
return iPin;
}
void link_mcu_restart(void) {
ComputeChecksum(link_mcu_from_fbw_msg);
link_mcu_from_fbw_msg.checksum = crc;
// wait for the next transaction
spi_slave_wait(&(LINK_MCU_SPI_DEV));
}
bool IsCorrupted(struct pkt packet)
{
if (packet.checksum == ComputeChecksum(packet))
return (false);
else
return (true);
}
BOOL CDataIndex::UpdateChecksum(LPCTSTR DataFileName)
{
BOOL retcode = FALSE;
// build index filename
CFileSpec fs(DataFileName);
fs.SetExt(".ldx");
// build cell starts filename
CFileSpec ifs(DataFileName);
ifs.SetExt(".ldi");
// update the checksum for the index file
FILE* f = fopen(fs.GetFullSpec(), "rb+");
if (f) {
if (ReadHeader(f)) {
// make sure we have a valid data index file
if (strcmp(m_Header.Signature, "LDAindex") == 0) {
m_Header.Checksum = ComputeChecksum(DataFileName);
m_Header.Version = 1.1f;
WriteHeader(f);
fclose(f);
retcode = TRUE;
}
}
}
// update the checksum for the starts file
if (retcode) {
f = fopen(ifs.GetFullSpec(), "rb+");
if (f) {
if (ReadHeader(f)) {
if (strcmp(m_Header.Signature, "LDAstarts") == 0) {
m_Header.Checksum = ComputeChecksum(DataFileName);
m_Header.Version = 1.1f;
WriteHeader(f);
fclose(f);
}
}
}
}
return(retcode);
}
void NmeaConverter_pi::SendNMEASentence(wxString sentence)
{
sentence.Trim();
wxString Checksum = ComputeChecksum(sentence);
sentence = sentence.Append(wxT("*"));
sentence = sentence.Append(Checksum);
sentence = sentence.Append(wxT("\r\n"));
PushNMEABuffer(sentence);
}
void SENTENCE::Finish( void )
{
// ASSERT_VALID( this );
unsigned char checksum = ComputeChecksum();
wxString temp_string;
temp_string.Printf(_T("*%02X%c%c"), (int) checksum, CARRIAGE_RETURN, LINE_FEED );
Sentence += temp_string;
}
// -----------------------------------------------------------------------------
// CTransactionIDGenerator::AddSystemInfo
// -----------------------------------------------------------------------------
//
void CTransactionIDGenerator::AddSystemInfo( TDes8& aBuf ) const
{
TInt biggestBlock = 0;
TInt totalAvailable = User::Available( biggestBlock );
TInt value = biggestBlock + totalAvailable - User::CountAllocCells();
ComputeChecksum( aBuf, &value, sizeof( value ) );
TTimeIntervalSeconds inactivity = User::InactivityTime();
if ( inactivity.Int() > 0 )
{
TUint8 byteVal = static_cast<TUint8>( inactivity.Int() & 0xff );
aBuf.Append( &byteVal, sizeof( byteVal ) );
}
}
uint32 CRegProtocol::NewPIN()
{
uint32 pwd;
char devPwd[32];
RAND_bytes((unsigned char *) & pwd, 4);
sprintf( devPwd, "%08u", pwd );
// Compute the checksum
devPwd[7] = '\0'; // null out the 8th byte
uint32 val = strtoul( devPwd, NULL, 10 );
uint32 checksum = ComputeChecksum( val );
val = val*10 + checksum;
return val;
}
void link_mcu_event_task( void ) {
if (link_mcu_trans.status == SPITransSuccess) {
/* Got a message on SPI. */
link_mcu_trans.status = SPITransDone;
/* A message has been received */
ComputeChecksum(link_mcu_from_fbw_msg);
if (link_mcu_from_fbw_msg.checksum == crc)
inter_mcu_received_fbw = TRUE;
else
link_mcu_nb_err++;
}
if (link_mcu_trans.status == SPITransFailed) {
link_mcu_trans.status = SPITransDone;
link_mcu_received = TRUE;
link_mcu_nb_err++;
}
}
/* called from layer 3, when a packet arrives for layer 4 at B*/
void B_input(struct pkt packet)
{
struct pkt sendpkt;
int i;
/* if not corrupted and received packet is in order */
if ( (!IsCorrupted(packet)) && (packet.seqnum == expectedseqnum) ) {
if (TRACE > 0)
printf("----B: packet %d is correctly received, send ACK!\n",packet.seqnum);
packets_received++;
/* deliver to receiving application */
tolayer5(B, packet.payload);
/* send an ACK for the received packet */
sendpkt.acknum = expectedseqnum;
/* update state variables */
expectedseqnum = (expectedseqnum + 1) % SEQSPACE;
}
else {
/* packet is corrupted or out of order resend last ACK */
if (TRACE > 0)
printf("----B: packet corrupted or not expected sequence number, resend ACK!\n");
if (expectedseqnum == 0)
sendpkt.acknum = SEQSPACE - 1;
else
sendpkt.acknum = expectedseqnum - 1;
}
/* create packet */
sendpkt.seqnum = B_nextseqnum;
B_nextseqnum = (B_nextseqnum + 1) % 2;
/* we don't have any data to send. fill payload with 0's */
for ( i=0; i<20 ; i++ )
sendpkt.payload[i] = '0';
/* computer checksum */
sendpkt.checksum = ComputeChecksum(sendpkt);
/* send out packet */
tolayer3 (B, sendpkt);
}
// ---------------------------------------------------------------------------
// CTransactionIDGenerator::BuildInputDataL
// ---------------------------------------------------------------------------
//
HBufC8* CTransactionIDGenerator::BuildInputDataLC( TAny* aObject,
TInt aObjectSize )
{
const TInt KAmountOfRandomNbrsToFill = 10;
//Size of the input data buffer. It contains the following items:
//
//item item's size
//---- -----------
//iCounter sizeof( iCounter )
//aObject's state aObjectSize
//checksum of this sizeof( TUint16 )
//clock info sizeof( TInt64 ) + sizeof( TUint )
//system info sizeof( TUint16 ) + sizeof( TUint8 )
//KAmountOfRandomNbrsToFill
//random integer values KAmountOfRandomNbrsToFill * sizeof( TInt )
TInt dataSize = sizeof( iCounter ) + aObjectSize +
sizeof( TUint16 ) + sizeof( TInt64 ) + sizeof( TUint ) +
sizeof( TUint16 ) + sizeof( TUint8 ) +
KAmountOfRandomNbrsToFill * sizeof( TInt );
HBufC8* buf = HBufC8::NewLC( dataSize );
TPtr8 ptr = buf->Des();
ptr.Append( reinterpret_cast<const TUint8*>( &iCounter ),
sizeof( iCounter ) );
ptr.Append( reinterpret_cast<const TUint8*>( aObject ), aObjectSize );
ComputeChecksum( ptr, this, sizeof( this ) );
AddClockInfo( ptr );
AddSystemInfo( ptr );
TInt random = 0;
TInt randomNumberSize = sizeof( random );
while ( ptr.Size() <= ( ptr.MaxSize() - randomNumberSize ) )
{
random = Math::Rand( iSeed );
ptr.Append( reinterpret_cast<const TUint8*>( &random ),
sizeof( random ) );
}
return buf;
}
bool NmeaConverter_pi::nmeaIsValid( wxString &sentence)
{
bool r = false;
wxString s = sentence;
wxString checksum;
if ( s.Mid( s.Length() -3,1 ) == _("*") )
{
checksum = s.Right(2);
s = s.Left( s.Length() -3 );
if ( ComputeChecksum( s ) == checksum )
{
r = true;
}
}
else
r = true; // if no checksum available then result is also true
sentence = s;
return r;
}
/* called from layer 5 (application layer), passed the message to be sent to other side */
void A_output(struct msg message)
{
struct pkt sendpkt;
int i;
/* if not blocked waiting on ACK */
if ( windowcount < WINDOWSIZE) {
if (TRACE > 1)
printf("----A: New message arrives, send window is not full, send new messge to layer3!\n");
/* create packet */
sendpkt.seqnum = A_nextseqnum;
sendpkt.acknum = NOTINUSE;
for ( i=0; i<20 ; i++ )
sendpkt.payload[i] = message.data[i];
sendpkt.checksum = ComputeChecksum(sendpkt);
/* put packet in window buffer */
/* windowlast will always be 0 for alternating bit; but not for GoBackN */
windowlast = (windowlast + 1) % WINDOWSIZE;
buffer[windowlast] = sendpkt;
windowcount++;
/* send out packet */
if (TRACE > 0)
printf("Sending packet %d to layer 3\n", sendpkt.seqnum);
tolayer3 (A, sendpkt);
/* start timer if first packet in window */
if (windowcount == 1)
starttimer(A,RTT);
/* get next sequence number, wrap back to 0 */
A_nextseqnum = (A_nextseqnum + 1) % SEQSPACE;
}
/* if blocked, window is full */
else {
if (TRACE > 0)
printf("----A: New message arrives, send window is full\n");
window_full++;
}
}
/****************************************************************************
Function
AssemblePacket
Description
Creates a packet for XBee using data from parameter.
****************************************************************************/
static bool AssemblePacket(uint8_t *transmitData, uint8_t SizeOfData, uint16_t destAddress) {
*outgoingMessage = 0x7E;
*(outgoingMessage+1) = 0x00;
*(outgoingMessage+2) = SizeOfData+5;
*(outgoingMessage+3) = TX_API_IDENTIFIER;
*(outgoingMessage+4) = frameID;
*(outgoingMessage+5) = destAddress>>8;
*(outgoingMessage+6) = destAddress;
*(outgoingMessage+7) = 0x00;
for(int i = 0; i < SizeOfData; i++){
*(outgoingMessage+8+i) = *(transmitData + i);
}
uint8_t checkSum = ComputeChecksum(outgoingMessage, SizeOfData + 8);
printf("\r\nChecksum = %d", checkSum);
*(outgoingMessage+SizeOfData+8) = checkSum;
return true;
}
static bool ValidateTable(const AcpiTable* table, const char* signature = 0)
{
if(!table)
return false;
// caller knowns the signature; make sure it matches
if(signature)
{
if(memcmp(table->signature, signature, 4) != 0)
return false;
}
// no specific signature is called for, just validate the characters.
else
{
for(size_t i = 0; i < 4; i++)
{
const char c = table->signature[i];
// "ASF!" and "____" have been encountered
if(!isalpha(c) && c != '_' && c != '!')
return false;
}
}
// must be at least as large as the common header
if(table->size < sizeof(AcpiTable))
return false;
// checksum of table must be 0
// .. AMIBIOS OEMB table has an incorrect checksum (off-by-one),
// so don't complain about any OEM tables (ignored anyway).
const bool isOemTable = (memcmp(table->signature, "OEM", 3) == 0);
if(!isOemTable)
{
if(ComputeChecksum((PCV_u8)table, table->size) != 0)
return false;
}
return true;
}
uint8_t CheckForErrors(uint8_t *inputMessage, uint8_t sizeOfMessage){
// See if we had a checksum error
uint8_t checkSum = ComputeChecksum(inputMessage,sizeOfMessage-1); // Pass packet (w/o checksum) to compute checksum
printf("Checksum : %d", checkSum);
if(checkSum != *(inputMessage + sizeOfMessage - 1)){ // -1 acconts for checksum being at index size-1 (array starts at 0 index)
return CHECKSUM_FAILURE;
}
// See if we're looking at a transmit result message
if(*(inputMessage + API_IDENTIFIER) == TX_RESULT_API){
if(*(inputMessage + TRANSMIT_RESULT_STATUS) == STATUS_SUCCESS){
return TX_SUCCESS;
}else if(*(inputMessage + TRANSMIT_RESULT_STATUS) == STATUS_NO_ACK){
return NO_ACK_FAILURE;
}else if(*(inputMessage + TRANSMIT_RESULT_STATUS) == STATUS_CCA_FAILURE){
return CCA_FAILURE;
}
}
// Return a success if a receive packet made it this far
return RX_SUCCESS;
}
NMEA0183_BOOLEAN SENTENCE::IsChecksumBad( int checksum_field_number ) const
{
// ASSERT_VALID( this );
/*
** Checksums are optional, return TRUE if an existing checksum is known to be bad
*/
wxString checksum_in_sentence = Field( checksum_field_number );
if ( checksum_in_sentence == _T("") )
{
return( Unknown0183 );
}
if ( ComputeChecksum() != HexValue( checksum_in_sentence ) )
{
return( NTrue );
}
return( NFalse );
}
unsigned int CSoundCombiner::CheckSumWork( IFileSystem *filesystem, CUtlVector< CombinerEntry >& info )
{
if ( info.Count() <= 0 )
{
Warning( "CSoundCombiner::CheckSumWork: work item count is zero\n" );
return 0;
}
if ( !VerifyFilesExist( filesystem, info ) )
{
return 0;
}
if ( !CreateWorkList( filesystem, info ) )
{
return 0;
}
// Checkum work items
unsigned int checksum = ComputeChecksum();
return checksum;
}
void link_mcu_send(void) {
ComputeChecksum(link_mcu_from_ap_msg);
link_mcu_from_ap_msg.checksum = crc;
spi_submit(&(LINK_MCU_SPI_DEV), &link_mcu_trans);
}
EFI_STATUS
Main(
VOID
)
{
EFI_ACPI_SUPPORT_PROTOCOL *AcpiSupportProtocol;
EFI_LEGACY_BIOS_PROTOCOL *LegacyBiosProtocol;
UINT64 Handel = 0;
UINTN DataSize = 0;
EFI_TPL OldTpl;
EFI_STATUS Status = EFI_UNSUPPORTED;
Rsdp20Tbl_t *RsdpTable = 0;
Rsdp20Tbl_t *LegacyRsdpTable = 0;
RsdtTbl_t *RsdtTable = 0;
XsdtTbl_t *XsdtTable = 0;
SlicTbl_t *SlicTable = 0;
AcpiTbl_t *AcpiTable = 0;
VOID *LegacyAddress = 0;
UINT8 SlpString[0x20] = { 0 };
UINTN i = 0;
//=========================================================================//
// code starts //
//=========================================================================//
SlicTable = (SlicTbl_t *)SLIC;
//=========================================================================//
// add Marker and Public Key to empty SLIC //
//=========================================================================//
DataSize = sizeof(Marker_t);
if (RS->GetVariable(OaMarkerName, &OaMarkerGuid, 0, &DataSize, &SlicTable->Marker) != EFI_SUCCESS ||
DataSize != sizeof(Marker_t)) {
return EFI_NOT_FOUND;
}
DataSize = sizeof(PublicKey_t);
if (RS->GetVariable(OaPublicKeyName, &OaPublicKeyGuid, 0, &DataSize, &SlicTable->PublicKey) != EFI_SUCCESS ||
DataSize != sizeof(PublicKey_t)) {
return EFI_NOT_FOUND;
}
//=========================================================================//
// copy OemId, OemTableId from Marker to SLIC ACPI header //
//=========================================================================//
BS->CopyMem(SlicTable->Header.OemId, SlicTable->Marker.OemId, 6);
BS->CopyMem(SlicTable->Header.OemTableId, SlicTable->Marker.OemTableId, 8);
//=========================================================================//
// add SLIC to ACPI tables //
//=========================================================================//
if(BS->LocateProtocol(&AcpiProtocolGuid, NULL, (VOID **) &AcpiSupportProtocol) == EFI_SUCCESS) {
Status = AcpiSupportProtocol->SetAcpiTable(AcpiSupportProtocol, (VOID *)SLIC, TRUE,
EFI_ACPI_TABLE_VERSION_1_0B|EFI_ACPI_TABLE_VERSION_2_0|EFI_ACPI_TABLE_VERSION_3_0, &Handel);
}
if (Status != EFI_SUCCESS) {
return Status;
}
#if SLP_INJECT == 1
//=========================================================================//
// add SLP 1.0 string to legacy region //
//=========================================================================//
DataSize = sizeof(SlpString);
if (RS->GetVariable(OaSlpName, &OaSlpGuid, 0, &DataSize, SlpString) == EFI_SUCCESS) {
if (BS->LocateProtocol(&LegacyBiosGuid, NULL, (VOID **)&LegacyBiosProtocol) == EFI_SUCCESS) {
if (LegacyBiosProtocol->GetLegacyRegion(LegacyBiosProtocol, sizeof(SlpString), 1, 2, &LegacyAddress) == EFI_SUCCESS) {
Status = LegacyBiosProtocol->CopyLegacyRegion(LegacyBiosProtocol, DataSize, LegacyAddress, SlpString);
}
}
}
#endif
//=========================================================================//
// find ACPI tables //
//=========================================================================//
OldTpl = BS->RaiseTPL(TPL_HIGH_LEVEL);
Status = GetSystemConfigurationTable (&EfiAcpi20TableGuid, (VOID **)&RsdpTable);
if (EFI_ERROR (Status)) {
Status = GetSystemConfigurationTable (&EfiAcpiTableGuid, (VOID **)&RsdpTable);
}
if (Status == EFI_SUCCESS) {
if (RsdpTable->Revision == 0) {
RsdtTable = (RsdtTbl_t *) RsdpTable->RSDTAddress;
}
else if (RsdpTable->Revision == 2) {
RsdtTable = (RsdtTbl_t *) RsdpTable->RSDTAddress;
XsdtTable = (XsdtTbl_t *) RsdpTable->XSDTAddress;
}
else {
return EFI_UNSUPPORTED;
}
}
else {
return EFI_NOT_FOUND;
}
//=========================================================================//
// copy SLIC OemId, OemTableId to RSDP, RSDT, XSDT //
//=========================================================================//
#if PATCH_TABLES == 1
DataSize = (RsdtTable->Header.Length - sizeof(AcpiHeader_t)) << 2;
for(i = 0 ; i < DataSize; i++) {
AcpiTable = (AcpiTbl_t *) RsdtTable->Entry[i];
if (AcpiTable != NULL) {
if (CompareMem(AcpiTable->Header.OemId, RsdtTable->Header.OemId, 6) == 0 &&
CompareMem(AcpiTable->Header.OemTableId, RsdtTable->Header.OemTableId, 8) == 0) {
BS->CopyMem(AcpiTable->Header.OemId, SlicTable->Header.OemId, 6);
BS->CopyMem(AcpiTable->Header.OemTableId, SlicTable->Header.OemTableId, 8);
AcpiTable->Header.Checksum = 0;
AcpiTable->Header.Checksum = ComputeChecksum((UINT8 *) AcpiTable, AcpiTable->Header.Length);
}
}
}
#endif
BS->CopyMem(RsdtTable->Header.OemId, SlicTable->Header.OemId, 6);
BS->CopyMem(RsdtTable->Header.OemTableId, SlicTable->Header.OemTableId, 8);
RsdtTable->Header.Checksum = 0;
RsdtTable->Header.Checksum = ComputeChecksum((UINT8 *) RsdtTable, RsdtTable->Header.Length);
BS->CopyMem(RsdpTable->OemId, SlicTable->Header.OemId, 6);
RsdpTable->Checksum = 0;
RsdpTable->Checksum = ComputeChecksum((UINT8 *) RsdpTable, 0x14);
if(RsdpTable->Revision == 2) {
#if PATCH_TABLES == 1
DataSize = (XsdtTable->Header.Length - sizeof(AcpiHeader_t)) << 3;
for(i = 0 ; i < DataSize; i++) {
AcpiTable = (AcpiTbl_t *) (XsdtTable->Entry[i] & 0xFFFFFFFF);
if (AcpiTable != NULL) {
if (CompareMem(AcpiTable->Header.OemId, XsdtTable->Header.OemId, 6) == 0 &&
CompareMem(AcpiTable->Header.OemTableId, XsdtTable->Header.OemTableId, 8) == 0) {
BS->CopyMem(AcpiTable->Header.OemId, SlicTable->Header.OemId, 6);
BS->CopyMem(AcpiTable->Header.OemTableId, SlicTable->Header.OemTableId, 8);
AcpiTable->Header.Checksum = 0;
AcpiTable->Header.Checksum = ComputeChecksum((UINT8 *) AcpiTable, AcpiTable->Header.Length);
}
}
}
#endif
RsdpTable->ExtendedChecksum = 0;
RsdpTable->ExtendedChecksum = ComputeChecksum((UINT8 *) RsdpTable, RsdpTable->Length);
BS->CopyMem(XsdtTable->Header.OemId, SlicTable->Header.OemId, 6);
BS->CopyMem(XsdtTable->Header.OemTableId, SlicTable->Header.OemTableId, 8);
XsdtTable->Header.Checksum = 0;
XsdtTable->Header.Checksum = ComputeChecksum((UINT8 *) XsdtTable, XsdtTable->Header.Length);
}
//=========================================================================//
// copy OemId to RSDP in legacy region //
//=========================================================================//
LegacyRsdpTable = (Rsdp20Tbl_t *) FindAcpiRsdPtr();
if (LegacyRsdpTable != NULL && LegacyUnlock() == EFI_SUCCESS)
{
BS->CopyMem(LegacyRsdpTable->OemId, SlicTable->Header.OemId, 6);
LegacyRsdpTable->RSDTAddress = RsdpTable->RSDTAddress;
LegacyRsdpTable->Checksum = 0;
LegacyRsdpTable->Checksum = ComputeChecksum((UINT8 *) LegacyRsdpTable, 0x14);
if(LegacyRsdpTable->Revision == 2) {
LegacyRsdpTable->XSDTAddress = RsdpTable->XSDTAddress;
LegacyRsdpTable->ExtendedChecksum = 0;
LegacyRsdpTable->ExtendedChecksum = ComputeChecksum((UINT8 *) LegacyRsdpTable, LegacyRsdpTable->Length);
}
LegacyLock();
}
BS->RestoreTPL(OldTpl);
return Status;
}
BOOL CDataIndex::CreateIndex(LPCTSTR DataFileName, int Format, int Width, int Height, int NumberOfPoints, double MinX, double MaxX, double MinY, double MaxY, double MinZ, double MaxZ, BOOL Optimize)
{
if (m_HaveStarts) {
delete [] m_CellStarts;
m_HaveStarts = FALSE;
}
// create index for the given data file
m_DataFileName = _T(DataFileName);
// build index filename
CFileSpec fs(DataFileName);
fs.SetExt(".ldx");
// populate header values
strcpy(m_Header.Signature, "LDAindex");
m_Header.Version = 1.1f;
m_Header.Checksum = ComputeChecksum(DataFileName);
m_Header.Format = Format;
m_Header.MinX = 9999999999.0;
m_Header.MinY = 9999999999.0;
m_Header.MinZ = 9999999999.0;
m_Header.MaxX = -9999999999.0;
m_Header.MaxY = -9999999999.0;
m_Header.MaxZ = -9999999999.0;
m_Header.GridCellsAcross = Width;
m_Header.GridCellsUp = Height;
m_Header.TotalPointsIndexed = 0;
// open data file
CLidarData dat(DataFileName);
LIDARRETURN pt;
if (dat.IsValid()) {
// create index file and write header
m_FileHandle = fopen(fs.GetFullSpec(), "wb+");
if (m_FileHandle) {
if (WriteHeader()) {
if (MinX + MaxX + MinY + MaxY + MinZ + MaxZ == 0.0) {
// scan data file for min/max values
while (dat.ReadNextRecord(&pt)) {
m_Header.MinX = std::min(m_Header.MinX, pt.X);
m_Header.MinY = std::min(m_Header.MinY, pt.Y);
m_Header.MinZ = std::min(m_Header.MinZ, double(pt.Elevation));
m_Header.MaxX = std::max(m_Header.MaxX, pt.X);
m_Header.MaxY = std::max(m_Header.MaxY, pt.Y);
m_Header.MaxZ = std::max(m_Header.MaxZ, double(pt.Elevation));
m_Header.TotalPointsIndexed ++;
}
dat.Rewind();
}
else {
// use values passed in
m_Header.MinX = MinX;
m_Header.MinY = MinY;
m_Header.MinZ = MinZ;
m_Header.MaxX = MaxX;
m_Header.MaxY = MaxY;
m_Header.MaxZ = MaxZ;
m_Header.TotalPointsIndexed = NumberOfPoints;
}
// add 0.1 to max values to make sure we have a range that works for cell calculation
// removed addition of 0.1 to header max values 3/21/2006
// m_Header.MaxX += 0.1;
// m_Header.MaxY += 0.1;
// m_Header.MaxZ += 0.1;
// modified cell size calculation to add 0.1 to max data values 3/21/2006
double cellw = ((m_Header.MaxX + 0.1) - m_Header.MinX) / (double) m_Header.GridCellsAcross;
double cellh = ((m_Header.MaxY + 0.1) - m_Header.MinY) / (double) m_Header.GridCellsUp;
// read data file lines and build index
int ptnum = 0;
long offset = dat.GetPosition();
while (dat.ReadNextRecord(&pt)) {
ptnum ++;
m_Point.Offset = offset;
m_Point.Column = (unsigned char) ((pt.X - m_Header.MinX) / cellw);
m_Point.Row = (unsigned char) ((pt.Y - m_Header.MinY) / cellh);
// m_Point.PointNumber = ptnum;
WritePoint();
offset = dat.GetPosition();
}
// rewrite the header to get min/max values and number of points
WriteHeader();
// improve the index
if (m_Header.TotalPointsIndexed && Optimize) {
// allocate space for entire index
INDEXENTRY* list = new INDEXENTRY[m_Header.TotalPointsIndexed];
if (list) {
// rewind to start of index entries
fseek(m_FileHandle, 128, SEEK_SET);
for (int i = 0; i < m_Header.TotalPointsIndexed; i ++) {
ReadPoint();
list[i].Column = m_Point.Column;
list[i].Row = m_Point.Row;
list[i].Offset = m_Point.Offset;
}
// sort list
qsort(list, m_Header.TotalPointsIndexed, sizeof(INDEXENTRY), CompareIndexEntries);
// re-write
// rewind to start of index entries
fseek(m_FileHandle, 128, SEEK_SET);
for (int i = 0; i < m_Header.TotalPointsIndexed; i ++) {
m_Point.Column = list[i].Column;
m_Point.Row = list[i].Row;
m_Point.Offset = list[i].Offset;
WritePoint();
}
// create cell starting point file
int colrow;
m_CellStarts = new long[m_Header.GridCellsAcross * m_Header.GridCellsUp];
if (m_CellStarts) {
// initialize starting points
for (int i = 0; i < m_Header.GridCellsAcross * m_Header.GridCellsUp; i ++)
m_CellStarts[i] = -1;
for (int i = 0; i < m_Header.TotalPointsIndexed; i ++) {
colrow = list[i].Column * m_Header.GridCellsUp + list[i].Row;
if (m_CellStarts[colrow] < 0)
m_CellStarts[colrow] = i;
}
// write file
CFileSpec ifs(fs.GetFullSpec());
ifs.SetExt(".ldi");
FILE* f = fopen(ifs.GetFullSpec(), "wb");
if (f) {
// use same header as index with slightly different signature
strcpy(m_Header.Signature, "LDAstarts");
fwrite(&m_Header, sizeof(header), 1, f);
// seek to end of header area
fseek(f, 128, SEEK_SET);
// write starting points
fwrite(m_CellStarts, sizeof(long), m_Header.GridCellsAcross * m_Header.GridCellsUp, f);
fclose(f);
// reset header to correct signature
strcpy(m_Header.Signature, "LDAindex");
}
m_HaveStarts = TRUE;
}
delete [] list;
}
}
fclose(m_FileHandle);
// reopen in read mode and go to start of points
m_FileHandle = fopen(fs.GetFullSpec(), "rb");
fseek(m_FileHandle, 128, SEEK_SET);
m_Valid = TRUE;
}
}
dat.Close();
}
else {
m_Valid = FALSE;
}
return(m_Valid);
}
BOOL CDataIndex::VerifyChecksum(LPCTSTR DataFileName, int UseOldMethod)
{
// test checksum to see if data file has changed since index was created
return(m_Header.Checksum == ComputeChecksum(DataFileName, UseOldMethod));
}
