comparison audioDB.cpp @ 117:e800eac265c3 endian-neutral

Towards endian-neutrality, step 2.

trackTable[x] is defined to be in network byte order on disk and in
memory, so access through ntohl() and htonl() as appropriate.

 
   // Copy the header back to the database
   memcpy (db, dbH, sizeof(dbTableHeaderT));
 
   // Update track to file index map
-  //memcpy (db+trackTableOffset+(dbH->numFiles-1)*sizeof(unsigned), &numVectors, sizeof(unsigned));  
-  //memcpy (trackTable+dbH->numFiles-1, &numVectors, sizeof(unsigned));
-  *(trackTable + ntohl(dbH->numFiles) - 1) = numVectors;
+  *(trackTable + ntohl(dbH->numFiles) - 1) = htonl(numVectors);
 
   // Update the feature database
   memcpy (db+ntohl(dbH->dataOffset)+insertoffset, indata+sizeof(int), statbuf.st_size-sizeof(int));
   
   // Norm the vectors on input if the database is already L2 normed

 	dbH->length = htonl(ntohl(dbH->length) + (statbuf.st_size-sizeof(int)));
 	// Copy the header back to the database
 	memcpy (db, dbH, sizeof(dbTableHeaderT));
   
 	// Update track to file index map
-	//memcpy (db+trackTableOffset+(dbH->numFiles-1)*sizeof(unsigned), &numVectors, sizeof(unsigned));  
-	//memcpy (trackTable+dbH->numFiles-1, &numVectors, sizeof(unsigned));
-        *(trackTable + ntohl(dbH->numFiles) - 1) = numVectors;
+        *(trackTable + ntohl(dbH->numFiles) - 1) = htonl(numVectors);
 	
 	// Update the feature database
 	memcpy (db+ntohl(dbH->dataOffset)+insertoffset, indata+sizeof(int), statbuf.st_size-sizeof(int));
 	
 	// Norm the vectors on input if the database is already L2 normed

     initTables(dbName, 0, 0);
 
   unsigned dudCount=0;
   unsigned nullCount=0;
   for(unsigned k=0; k<ntohl(dbH->numFiles); k++){
-    if(trackTable[k]<sequenceLength){
+    if(ntohl(trackTable[k])<sequenceLength){
       dudCount++;
-      if(!trackTable[k])
+      if(!ntohl(trackTable[k]))
         nullCount++;
     }
   }
   
   if(adbStatusResult == 0) {

 void audioDB::dump(const char* dbName){
   if(!dbH)
     initTables(dbName, 0, 0);
   
   for(unsigned k=0, j=0; k<ntohl(dbH->numFiles); k++){
-    cout << fileTable+k*O2_FILETABLESIZE << " " << trackTable[k] << endl;
-    j+=trackTable[k];
+    cout << fileTable+k*O2_FILETABLESIZE << " " << ntohl(trackTable[k]) << endl;
+    j+=ntohl(trackTable[k]);
   }
 
   status(dbName);
 }
 

     // Loop over nearest neighbours    
     for(k=0; k < pointNN; k++){
       // Scan for key
       unsigned cumTrack=0;
       for(l=0 ; l<ntohl(dbH->numFiles); l++){
-	cumTrack+=trackTable[l];
+	cumTrack+=ntohl(trackTable[l]);
 	if(sIndexes[k]<cumTrack){
 	  cout << fileTable+l*O2_FILETABLESIZE << " " << distances[k] << " " << qIndexes[k] << " " 
-	       << sIndexes[k]+trackTable[l]-cumTrack << endl;
+	       << sIndexes[k]+ntohl(trackTable[l])-cumTrack << endl;
 	  break;
 	}
       }
     }
   }

       adbQueryResult->Rlist[k]=new char[O2_MAXFILESTR];
       adbQueryResult->Dist[k]=distances[k];
       adbQueryResult->Qpos[k]=qIndexes[k];
       unsigned cumTrack=0;
       for(l=0 ; l<ntohl(dbH->numFiles); l++){
-	cumTrack+=trackTable[l];
+	cumTrack+=ntohl(trackTable[l]);
 	if(sIndexes[k]<cumTrack){
 	  sprintf(adbQueryResult->Rlist[k], "%s", fileTable+l*O2_FILETABLESIZE);
 	  break;
 	}
       }
-      adbQueryResult->Spos[k]=sIndexes[k]+trackTable[l]-cumTrack;
+      adbQueryResult->Spos[k]=sIndexes[k]+ntohl(trackTable[l])-cumTrack;
     }
   }
   
   // Clean up
   if(queryCopy)

     }
     meanQdur/=k;
     meanDBdur = new double[ntohl(dbH->numFiles)];
     for(k=0; k<ntohl(dbH->numFiles); k++){
       meanDBdur[k]=0.0;
-      for(j=0; j<trackTable[k]-1 ; j++)
+      for(j=0; j<ntohl(trackTable[k])-1 ; j++)
 	meanDBdur[k]+=timesTable[j+1]-timesTable[j];
       meanDBdur[k]/=j;
     }
   }
 

   unsigned *trackOffsetTable = new unsigned[ntohl(dbH->numFiles)];
   unsigned cumTrack=0;
   unsigned trackIndexOffset;
   for(k=0; k<ntohl(dbH->numFiles);k++){
     trackOffsetTable[k]=cumTrack;
-    cumTrack+=trackTable[k]*ntohl(dbH->dim);
+    cumTrack+=ntohl(trackTable[k])*ntohl(dbH->dim);
   }
 
   char nextKey[MAXSTR];
 
   gettimeofday(&tv1, NULL); 

 	break;
     }
     trackOffset=trackOffsetTable[track];     // numDoubles offset
     trackIndexOffset=trackOffset/ntohl(dbH->dim); // numVectors offset
     if(verbosity>7) {
-      cerr << track << "." << trackOffset/(ntohl(dbH->dim)) << "." << trackTable[track] << " | ";cerr.flush();
+      cerr << track << "." << trackOffset/(ntohl(dbH->dim)) << "." << ntohl(trackTable[track]) << " | ";cerr.flush();
     }
 
     if(ntohl(dbH->flags) & O2_FLAG_L2NORM)
       usingQueryPoint?query=queryCopy+queryPoint*ntohl(dbH->dim):query=queryCopy;
     else

     if(usingQueryPoint)
       j=1;
     else
       j=numVectors;
     while(j--){
-      k=trackTable[track];  // number of vectors in track
+      k=ntohl(trackTable[track]);  // number of vectors in track
       data=dataBuf+trackOffset; // data for track
       while(k--){
 	thisDist=0;
 	l=ntohl(dbH->dim);
 	double* q=query;

 		  qIndexes[l]=qIndexes[l-1];
 		  sIndexes[l]=sIndexes[l-1];	      
 		}
 		distances[n]=thisDist;
 		qIndexes[n]=numVectors-j-1;
-		sIndexes[n]=trackTable[track]-k-1;
+		sIndexes[n]=ntohl(trackTable[track])-k-1;
 		break;
 	      }
 	    }
 	    else
 	      break;

 
   // Copy the L2 norm values to core to avoid disk random access later on
   memcpy(sNorm, l2normTable, dbVectors*sizeof(double));
   double* snPtr = sNorm;
   for(i=0; i<ntohl(dbH->numFiles); i++){
-    if(trackTable[i]>=sequenceLength){
+    if(ntohl(trackTable[i])>=sequenceLength){
       tmp1=*snPtr;
       j=1;
       w=sequenceLength-1;
       while(w--)
 	*snPtr+=snPtr[j++];
       ps = snPtr+1;
-      w=trackTable[i]-sequenceLength; // +1 - 1
+      w=ntohl(trackTable[i])-sequenceLength; // +1 - 1
       while(w--){
 	tmp2=*ps;
 	*ps=*(ps-1)-tmp1+*(ps+sequenceLength-1);
 	tmp1=tmp2;
 	ps++;
       }
       ps = snPtr;
-      w=trackTable[i]-sequenceLength+1;
+      w=ntohl(trackTable[i])-sequenceLength+1;
       while(w--){
 	*ps=sqrt(*ps);
 	ps++;
       }
     }
-    snPtr+=trackTable[i];
+    snPtr+=ntohl(trackTable[i]);
   }
   
   double* pn = sMeanL2;
   w=ntohl(dbH->numFiles);
   while(w--)
     *pn++=0.0;
   ps=sNorm;
   unsigned processedTracks=0;
   for(i=0; i<ntohl(dbH->numFiles); i++){
-    if(trackTable[i]>sequenceLength-1){
-      w = trackTable[i]-sequenceLength+1;
+    if(ntohl(trackTable[i])>sequenceLength-1){
+      w = ntohl(trackTable[i])-sequenceLength+1;
       pn = sMeanL2+i;
       *pn=0;
       while(w--)
 	if(*ps>0)
 	  *pn+=*ps++;
-      *pn/=trackTable[i]-sequenceLength+1;
+      *pn/=ntohl(trackTable[i])-sequenceLength+1;
       SILENCE_THRESH+=*pn;
       processedTracks++;
     }
-    ps = sNorm + trackTable[i];
+    ps = sNorm + ntohl(trackTable[i]);
   }
   if(verbosity>1) {
     cerr << "processedTracks: " << processedTracks << endl;
   }
     

     }
     meanDBdur = new double[ntohl(dbH->numFiles)];
     assert(meanDBdur);
     for(k=0; k<ntohl(dbH->numFiles); k++){
       meanDBdur[k]=0.0;
-      for(j=0; j<trackTable[k]-1 ; j++)
+      for(j=0; j<ntohl(trackTable[k])-1 ; j++)
 	meanDBdur[k]+=timesTable[j+1]-timesTable[j];
       meanDBdur[k]/=j;
     }
   }
 

   unsigned *trackOffsetTable = new unsigned[ntohl(dbH->numFiles)];
   unsigned cumTrack=0;
   unsigned trackIndexOffset;
   for(k=0; k<ntohl(dbH->numFiles);k++){
     trackOffsetTable[k]=cumTrack;
-    cumTrack+=trackTable[k]*ntohl(dbH->dim);
+    cumTrack+=ntohl(trackTable[k])*ntohl(dbH->dim);
   }
 
   char nextKey [MAXSTR];
 
   // chi^2 statistics

     }
 
     trackOffset=trackOffsetTable[track];     // numDoubles offset
     trackIndexOffset=trackOffset/ntohl(dbH->dim); // numVectors offset
 
-    if(sequenceLength<=trackTable[track]){  // test for short sequences
+    if(sequenceLength<=ntohl(trackTable[track])){  // test for short sequences
       
       if(verbosity>7) {
-	cerr << track << "." << trackIndexOffset << "." << trackTable[track] << " | ";cerr.flush();
+	cerr << track << "." << trackIndexOffset << "." << ntohl(trackTable[track]) << " | ";cerr.flush();
       }
 		
       // Sum products matrix
       for(j=0; j<numVectors;j++){
-	D[j]=new double[trackTable[track]]; 
+	D[j]=new double[ntohl(trackTable[track])]; 
 	assert(D[j]);
 
       }
 
       // Matched filter matrix
       for(j=0; j<numVectors;j++){
-	DD[j]=new double[trackTable[track]];
+	DD[j]=new double[ntohl(trackTable[track])];
 	assert(DD[j]);
       }
 
       // Dot product
       for(j=0; j<numVectors; j++)
-	for(k=0; k<trackTable[track]; k++){
+	for(k=0; k<ntohl(trackTable[track]); k++){
 	  qp=query+j*ntohl(dbH->dim);
 	  sp=dataBuf+trackOffset+k*ntohl(dbH->dim);
 	  DD[j][k]=0.0; // Initialize matched filter array
 	  dp=&D[j][k];  // point to correlation cell j,k
 	  *dp=0.0;      // initialize correlation cell

       if(HOP_SIZE==1){ // HOP_SIZE = shingleHop
 	for(w=0; w<wL; w++)
 	  for(j=0; j<numVectors-w; j++){ 
 	    sp=DD[j];
 	    spd=D[j+w]+w;
-	    k=trackTable[track]-w;
+	    k=ntohl(trackTable[track])-w;
 	    while(k--)
 	      *sp+++=*spd++;
 	  }
       }
 
       else{ // HOP_SIZE != 1
 	for(w=0; w<wL; w++)
 	  for(j=0; j<numVectors-w; j+=HOP_SIZE){
 	    sp=DD[j];
 	    spd=D[j+w]+w;
-	    for(k=0; k<trackTable[track]-w; k+=HOP_SIZE){
+	    for(k=0; k<ntohl(trackTable[track])-w; k+=HOP_SIZE){
 	      *sp+=*spd;
 	      sp+=HOP_SIZE;
 	      spd+=HOP_SIZE;
 	    }
 	  }

 	  cerr.flush();
 	}
 
 	// Search for minimum distance by shingles (concatenated vectors)
 	for(j=0;j<=numVectors-wL;j+=HOP_SIZE)
-	  for(k=0;k<=trackTable[track]-wL;k+=HOP_SIZE){
+	  for(k=0;k<=ntohl(trackTable[track])-wL;k+=HOP_SIZE){
 	    thisDist=2-(2/(qNorm[j]*sNorm[trackIndexOffset+k]))*DD[j][k];
 	    if(verbosity>10) {
 	      cerr << thisDist << " " << qNorm[j] << " " << sNorm[trackIndexOffset+k] << endl;
             }
 	    // Gather chi^2 statistics

 
   // Copy the L2 norm values to core to avoid disk random access later on
   memcpy(sNorm, l2normTable, dbVectors*sizeof(double));
   double* snPtr = sNorm;
   for(i=0; i<ntohl(dbH->numFiles); i++){
-    if(trackTable[i]>=sequenceLength){
+    if(ntohl(trackTable[i])>=sequenceLength){
       tmp1=*snPtr;
       j=1;
       w=sequenceLength-1;
       while(w--)
 	*snPtr+=snPtr[j++];
       ps = snPtr+1;
-      w=trackTable[i]-sequenceLength; // +1 - 1
+      w=ntohl(trackTable[i])-sequenceLength; // +1 - 1
       while(w--){
 	tmp2=*ps;
 	*ps=*(ps-1)-tmp1+*(ps+sequenceLength-1);
 	tmp1=tmp2;
 	ps++;
       }
       ps = snPtr;
-      w=trackTable[i]-sequenceLength+1;
+      w=ntohl(trackTable[i])-sequenceLength+1;
       while(w--){
 	*ps=sqrt(*ps);
 	ps++;
       }
     }
-    snPtr+=trackTable[i];
+    snPtr+=ntohl(trackTable[i]);
   }
   
   double* pn = sMeanL2;
   w=ntohl(dbH->numFiles);
   while(w--)
     *pn++=0.0;
   ps=sNorm;
   unsigned processedTracks=0;
   for(i=0; i<ntohl(dbH->numFiles); i++){
-    if(trackTable[i]>sequenceLength-1){
-      w = trackTable[i]-sequenceLength+1;
+    if(ntohl(trackTable[i])>sequenceLength-1){
+      w = ntohl(trackTable[i])-sequenceLength+1;
       pn = sMeanL2+i;
       *pn=0;
       while(w--)
 	if(*ps>0)
 	  *pn+=*ps++;
-      *pn/=trackTable[i]-sequenceLength+1;
+      *pn/=ntohl(trackTable[i])-sequenceLength+1;
       SILENCE_THRESH+=*pn;
       processedTracks++;
     }
-    ps = sNorm + trackTable[i];
+    ps = sNorm + ntohl(trackTable[i]);
   }
   if(verbosity>1) {
     cerr << "processedTracks: " << processedTracks << endl;
   }
     

     }
     meanDBdur = new double[ntohl(dbH->numFiles)];
     assert(meanDBdur);
     for(k=0; k<ntohl(dbH->numFiles); k++){
       meanDBdur[k]=0.0;
-      for(j=0; j<trackTable[k]-1 ; j++)
+      for(j=0; j<ntohl(trackTable[k])-1 ; j++)
 	meanDBdur[k]+=timesTable[j+1]-timesTable[j];
       meanDBdur[k]/=j;
     }
   }
 

   unsigned *trackOffsetTable = new unsigned[ntohl(dbH->numFiles)];
   unsigned cumTrack=0;
   unsigned trackIndexOffset;
   for(k=0; k<ntohl(dbH->numFiles);k++){
     trackOffsetTable[k]=cumTrack;
-    cumTrack+=trackTable[k]*ntohl(dbH->dim);
+    cumTrack+=ntohl(trackTable[k])*ntohl(dbH->dim);
   }
 
   char nextKey [MAXSTR];
 
   // chi^2 statistics

     }
 
     trackOffset=trackOffsetTable[track];     // numDoubles offset
     trackIndexOffset=trackOffset/ntohl(dbH->dim); // numVectors offset
 
-    if(sequenceLength<=trackTable[track]){  // test for short sequences
+    if(sequenceLength<=ntohl(trackTable[track])){  // test for short sequences
       
       if(verbosity>7) {
-	cerr << track << "." << trackIndexOffset << "." << trackTable[track] << " | ";cerr.flush();
+	cerr << track << "." << trackIndexOffset << "." << ntohl(trackTable[track]) << " | ";cerr.flush();
       }
 
       // Sum products matrix
       for(j=0; j<numVectors;j++){
-	D[j]=new double[trackTable[track]]; 
+	D[j]=new double[ntohl(trackTable[track])]; 
 	assert(D[j]);
 
       }
 
       // Matched filter matrix
       for(j=0; j<numVectors;j++){
-	DD[j]=new double[trackTable[track]];
+	DD[j]=new double[ntohl(trackTable[track])];
 	assert(DD[j]);
       }
 
       // Dot product
       for(j=0; j<numVectors; j++)
-	for(k=0; k<trackTable[track]; k++){
+	for(k=0; k<ntohl(trackTable[track]); k++){
 	  qp=query+j*ntohl(dbH->dim);
 	  sp=dataBuf+trackOffset+k*ntohl(dbH->dim);
 	  DD[j][k]=0.0; // Initialize matched filter array
 	  dp=&D[j][k];  // point to correlation cell j,k
 	  *dp=0.0;      // initialize correlation cell

       if(HOP_SIZE==1){ // HOP_SIZE = shingleHop
 	for(w=0; w<wL; w++)
 	  for(j=0; j<numVectors-w; j++){ 
 	    sp=DD[j];
 	    spd=D[j+w]+w;
-	    k=trackTable[track]-w;
+	    k=ntohl(trackTable[track])-w;
 	    while(k--)
 	      *sp+++=*spd++;
 	  }
       }
 
       else{ // HOP_SIZE != 1
 	for(w=0; w<wL; w++)
 	  for(j=0; j<numVectors-w; j+=HOP_SIZE){
 	    sp=DD[j];
 	    spd=D[j+w]+w;
-	    for(k=0; k<trackTable[track]-w; k+=HOP_SIZE){
+	    for(k=0; k<ntohl(trackTable[track])-w; k+=HOP_SIZE){
 	      *sp+=*spd;
 	      sp+=HOP_SIZE;
 	      spd+=HOP_SIZE;
 	    }
 	  }

 	  cerr.flush();
 	}
 
 	// Search for minimum distance by shingles (concatenated vectors)
 	for(j=0;j<=numVectors-wL;j+=HOP_SIZE)
-	  for(k=0;k<=trackTable[track]-wL;k+=HOP_SIZE){
+	  for(k=0;k<=ntohl(trackTable[track])-wL;k+=HOP_SIZE){
 	    thisDist=2-(2/(qNorm[j]*sNorm[trackIndexOffset+k]))*DD[j][k];
 	    if(verbosity>10) {
 	      cerr << thisDist << " " << qNorm[j] << " " << sNorm[trackIndexOffset+k] << endl;
             }
 	    // Gather chi^2 statistics