comparison query.cpp @ 437:9a065b8db769 api-inversion

Hey, who let audioDB::set_up_query into the room?

audioDB::set_up_query and audioDB::set_up_db both do all sorts of
horrible pointer manipulation.  Define a structure to contain all the
pointers, rather than having the hideous argument lists full of double
**, and use it in audioDB::set_up_query and
audioDB::set_up_query_from_key.  (Those two functions are desperately
close to becoming one function, incidentally, or possibly even no
functions given the existence of adb_datum_t...)

 
 // These names deserve some unpicking.  The names starting with a "q"
 // are pointers to the query, norm and power vectors; the names
 // starting with "v" are things that will end up pointing to the
 // actual query point's information.  -- CSR, 2007-12-05
-void audioDB::set_up_query(adb_query_spec_t *spec, double **qp, double **vqp, double **qnp, double **vqnp, double **qpp, double **vqpp, double *mqdp, unsigned *nvp) {
-  *nvp = (statbuf.st_size - sizeof(int)) / (dbH->dim * sizeof(double));
+void audioDB::set_up_query(adb_query_spec_t *spec, double **qp, double **vqp, adb_qpointers_internal_t *qpointers) {
+  uint32_t nvectors = (statbuf.st_size - sizeof(int)) / (dbH->dim * sizeof(double));
+  qpointers->nvectors = nvectors;
 
   uint32_t sequence_length = spec->qid.sequence_length;
   if(!(dbH->flags & O2_FLAG_L2NORM)) {
     error("Database must be L2 normed for sequence query","use -L2NORM");
   }
 
-  if(*nvp < sequence_length) {
+  if(nvectors < sequence_length) {
     error("Query shorter than requested sequence length", "maybe use -l");
   }
   
   VERB_LOG(1, "performing norms... ");
 
-  *qp = new double[*nvp * dbH->dim];
-  memcpy(*qp, indata+sizeof(int), *nvp * dbH->dim * sizeof(double));
-  *qnp = new double[*nvp];
-  audiodb_l2norm_buffer(*qp, dbH->dim, *nvp, *qnp);
-
-  audiodb_sequence_sum(*qnp, *nvp, sequence_length);
-  audiodb_sequence_sqrt(*qnp, *nvp, sequence_length);
+  *qp = new double[nvectors * dbH->dim];
+  memcpy(*qp, indata+sizeof(int), nvectors * dbH->dim * sizeof(double));
+  qpointers->l2norm_data = new double[nvectors];
+  audiodb_l2norm_buffer(*qp, dbH->dim, nvectors, qpointers->l2norm_data);
+
+  audiodb_sequence_sum(qpointers->l2norm_data, nvectors, sequence_length);
+  audiodb_sequence_sqrt(qpointers->l2norm_data, nvectors, sequence_length);
 
   if (usingPower) {
-    *qpp = new double[*nvp];
+    qpointers->power_data = new double[nvectors];
     if (lseek(powerfd, sizeof(int), SEEK_SET) == (off_t) -1) {
       error("error seeking to data", powerFileName, "lseek");
     }
-    int count = read(powerfd, *qpp, *nvp * sizeof(double));
+    int count = read(powerfd, qpointers->power_data, nvectors * sizeof(double));
     if (count == -1) {
       error("error reading data", powerFileName, "read");
     }
-    if ((unsigned) count != *nvp * sizeof(double)) {
+    if ((unsigned) count != nvectors * sizeof(double)) {
       error("short read", powerFileName);
     }
 
-    audiodb_sequence_sum(*qpp, *nvp, sequence_length);
-    audiodb_sequence_average(*qpp, *nvp, sequence_length);
+    audiodb_sequence_sum(qpointers->power_data, nvectors, sequence_length);
+    audiodb_sequence_average(qpointers->power_data, nvectors, sequence_length);
   }
 
   if (usingTimes) {
     unsigned int k;
-    *mqdp = 0.0;
-    double *querydurs = new double[*nvp];
-    double *timesdata = new double[*nvp*2];
-    insertTimeStamps(*nvp, timesFile, timesdata);
-    for(k = 0; k < *nvp; k++) {
+    qpointers->mean_duration = new double[1];
+    *qpointers->mean_duration = 0.0;
+    double *querydurs = new double[nvectors];
+    double *timesdata = new double[2*nvectors];
+    insertTimeStamps(nvectors, timesFile, timesdata);
+    for(k = 0; k < nvectors; k++) {
       querydurs[k] = timesdata[2*k+1] - timesdata[2*k];
-      *mqdp += querydurs[k];
-    }
-    *mqdp /= k;
-
-    VERB_LOG(1, "mean query file duration: %f\n", *mqdp);
+      *qpointers->mean_duration += querydurs[k];
+    }
+    *qpointers->mean_duration /= k;
+
+    VERB_LOG(1, "mean query file duration: %f\n", *qpointers->mean_duration);
 
     delete [] querydurs;
     delete [] timesdata;
   }
 
   // Defaults, for exhaustive search (!usingQueryPoint)
   *vqp = *qp;
-  *vqnp = *qnp;
-  *vqpp = *qpp;
+  qpointers->l2norm = qpointers->l2norm_data;
+  qpointers->power = qpointers->power_data;
 
   if(usingQueryPoint) {
-    if( !(queryPoint < *nvp && queryPoint < *nvp - sequence_length + 1) ) {
-      error("queryPoint >= numVectors-sequence_length+1 in query");
+    if( !(queryPoint < nvectors && queryPoint < nvectors - sequence_length + 1) ) {
+      error("queryPoint >= nvectors-sequence_length+1 in query");
     } else {
       VERB_LOG(1, "query point: %u\n", queryPoint);
       *vqp = *qp + queryPoint * dbH->dim;
-      *vqnp = *qnp + queryPoint;
+      qpointers->l2norm = qpointers->l2norm_data + queryPoint;
       if (usingPower) {
-        *vqpp = *qpp + queryPoint;
-      }
-      *nvp = sequence_length;
+        qpointers->power = qpointers->power_data + queryPoint;
+      }
+      qpointers->nvectors = sequence_length;
     }
   }
 }
 
 // Does the same as set_up_query(...) but from database features instead of from a file
 // Constructs the same outputs as set_up_query
-void audioDB::set_up_query_from_key(adb_query_spec_t *spec, double **qp, double **vqp, double **qnp, double **vqnp, double **qpp, double **vqpp, double *mqdp, unsigned *nvp, Uns32T queryIndex) {
+void audioDB::set_up_query_from_key(adb_query_spec_t *spec, double **qp, double **vqp, adb_qpointers_internal_t *qpointers, Uns32T queryIndex) {
   uint32_t sequence_length = spec->qid.sequence_length;
   if(!trackTable)
     error("trackTable not initialized","set_up_query_from_key");
 
   if(!(dbH->flags & O2_FLAG_L2NORM)) {

     usingPower = true;
   
   if(dbH->flags & O2_FLAG_TIMES)
     usingTimes = true;
 
-  *nvp = trackTable[queryIndex];  
-  if(*nvp < sequence_length) {
+  uint32_t nvectors = trackTable[queryIndex];
+  qpointers->nvectors = nvectors;
+  if(nvectors < sequence_length) {
     error("Query shorter than requested sequence length", "maybe use -l");
   }
   
   VERB_LOG(1, "performing norms... ");
 

     initInputFile(prefixedString, false); // nommap, file pointer at correct position
     size_t allocatedSize = 0;
     if(audiodb_read_data(adb, infid, queryIndex, qp, &allocatedSize))
       error("failed to read data"); // over-writes qp and allocatedSize
     // Consistency check on allocated memory and query feature size
-    if(*nvp*sizeof(double)*dbH->dim != allocatedSize)
+    if(nvectors*sizeof(double)*dbH->dim != allocatedSize)
       error("Query memory allocation failed consitency check","set_up_query_from_key");
     // Allocated and calculate auxillary sequences: l2norm and power
-    init_track_aux_data(queryIndex, *qp, qnp, vqnp, qpp, vqpp);
+    init_track_aux_data(queryIndex, *qp, &qpointers->l2norm_data, &qpointers->l2norm, &qpointers->power_data, &qpointers->power);
   }
   else{ // Load from self-contained ADB database
     // Read query feature vectors from database
     *qp = NULL;
     lseek(dbfid, dbH->dataOffset + trackOffsetTable[queryIndex] * sizeof(double), SEEK_SET);
     size_t allocatedSize = 0;
     if(audiodb_read_data(adb, dbfid, queryIndex, qp, &allocatedSize))
       error("failed to read data");
     // Consistency check on allocated memory and query feature size
-    if(*nvp*sizeof(double)*dbH->dim != allocatedSize)
+    if(nvectors*sizeof(double)*dbH->dim != allocatedSize)
       error("Query memory allocation failed consitency check","set_up_query_from_key");
     
     Uns32T trackIndexOffset = trackOffsetTable[queryIndex]/dbH->dim; // Convert num data elements to num vectors
     // Copy L2 norm partial-sum coefficients
-    assert(*qnp = new double[*nvp]);
-    memcpy(*qnp, l2normTable+trackIndexOffset, *nvp*sizeof(double));
-    audiodb_sequence_sum(*qnp, *nvp, sequence_length);
-    audiodb_sequence_sqrt(*qnp, *nvp, sequence_length);
+    assert(qpointers->l2norm_data = new double[nvectors]);
+    memcpy(qpointers->l2norm_data, l2normTable+trackIndexOffset, nvectors*sizeof(double));
+    audiodb_sequence_sum(qpointers->l2norm_data, nvectors, sequence_length);
+    audiodb_sequence_sqrt(qpointers->l2norm_data, nvectors, sequence_length);
     
     if( usingPower ){
       // Copy Power partial-sum coefficients
-      assert(*qpp = new double[*nvp]);
-      memcpy(*qpp, powerTable+trackIndexOffset, *nvp*sizeof(double));
-      audiodb_sequence_sum(*qpp, *nvp, sequence_length);
-      audiodb_sequence_average(*qpp, *nvp, sequence_length);
+      assert(qpointers->power_data = new double[nvectors]);
+      memcpy(qpointers->power_data, powerTable+trackIndexOffset, nvectors*sizeof(double));
+      audiodb_sequence_sum(qpointers->power_data, nvectors, sequence_length);
+      audiodb_sequence_average(qpointers->power_data, nvectors, sequence_length);
     }
     
     if (usingTimes) {
       unsigned int k;
-      *mqdp = 0.0;
-      double *querydurs = new double[*nvp];
-      double *timesdata = new double[*nvp*2];
+      qpointers->mean_duration = new double[1];
+      *qpointers->mean_duration = 0.0;
+      double *querydurs = new double[nvectors];
+      double *timesdata = new double[nvectors*2];
       assert(querydurs && timesdata);
-      memcpy(timesdata, timesTable+trackIndexOffset, *nvp*sizeof(double));    
-      for(k = 0; k < *nvp; k++) {
+      memcpy(timesdata, timesTable+trackIndexOffset, nvectors*sizeof(double));    
+      for(k = 0; k < nvectors; k++) {
 	querydurs[k] = timesdata[2*k+1] - timesdata[2*k];
-	*mqdp += querydurs[k];
-      }
-      *mqdp /= k;
+	*qpointers->mean_duration += querydurs[k];
+      }
+      *qpointers->mean_duration /= k;
       
-      VERB_LOG(1, "mean query file duration: %f\n", *mqdp);
+      VERB_LOG(1, "mean query file duration: %f\n", *qpointers->mean_duration);
       
       delete [] querydurs;
       delete [] timesdata;
     }
   }
 
   // Defaults, for exhaustive search (!usingQueryPoint)
   *vqp = *qp;
-  *vqnp = *qnp;
-  *vqpp = *qpp;
+  qpointers->l2norm = qpointers->l2norm_data;
+  qpointers->power = qpointers->power_data;
 
   if(usingQueryPoint) {
-    if( !(queryPoint < *nvp && queryPoint < *nvp - sequence_length + 1) ) {
-      error("queryPoint >= numVectors-sequence_length+1 in query");
+    if( !(queryPoint < nvectors && queryPoint < nvectors - sequence_length + 1) ) {
+      error("queryPoint >= nvectors-sequence_length+1 in query");
     } else {
       VERB_LOG(1, "query point: %u\n", queryPoint);
       *vqp = *qp + queryPoint * dbH->dim;
-      *vqnp = *qnp + queryPoint;
+      qpointers->l2norm = qpointers->l2norm_data + queryPoint;
       if (usingPower) {
-        *vqpp = *qpp + queryPoint;
-      }
-      *nvp = sequence_length;
+        qpointers->power = qpointers->power_data + queryPoint;
+      }
+      qpointers->nvectors = sequence_length;
     }
   }
 }
 
 
 // FIXME: this is not the right name; we're not actually setting up
 // the database, but copying various bits of it out of mmap()ed tables
 // in order to reduce seeks.
-int audioDB::set_up_db(adb_t *adb, adb_query_spec_t *spec, double **snp, double **vsnp, double **spp, double **vspp, double **mddp, unsigned int *dvp) {
+static int audiodb_set_up_db(adb_t *adb, adb_query_spec_t *spec, double **snp, double **vsnp, double **spp, double **vspp, double **mddp, unsigned int *dvp) {
   uint32_t sequence_length = spec->qid.sequence_length;
+  bool using_power = spec->refine.flags & (ADB_REFINE_ABSOLUTE_THRESHOLD|ADB_REFINE_RELATIVE_THRESHOLD);
+  bool using_times = spec->refine.flags & ADB_REFINE_DURATION_RATIO;
+  double *times_table = NULL;
 
   *dvp = adb->header->length / (adb->header->dim * sizeof(double));
   *snp = new double[*dvp];
 
   double *snpp = *snp, *sppp = 0;
   lseek(adb->fd, adb->header->l2normTableOffset, SEEK_SET);
   read_or_goto_error(adb->fd, *snp, *dvp * sizeof(double));
 
-  if (usingPower) {
+  if (using_power) {
     if (!(adb->header->flags & O2_FLAG_POWER)) {
       goto error;
     }
     *spp = new double[*dvp];
     sppp = *spp;

   for(unsigned int i = 0; i < adb->header->numFiles; i++){
     size_t track_length = (*adb->track_lengths)[i];
     if(track_length >= sequence_length) {
       audiodb_sequence_sum(snpp, track_length, sequence_length);
       audiodb_sequence_sqrt(snpp, track_length, sequence_length);
-      if (usingPower) {
+      if (using_power) {
 	audiodb_sequence_sum(sppp, track_length, sequence_length);
         audiodb_sequence_average(sppp, track_length, sequence_length);
       }
     }
     snpp += track_length;
-    if (usingPower) {
+    if (using_power) {
       sppp += track_length;
     }
   }
 
-  if (usingTimes) {
+  if (using_times) {
     if(!(adb->header->flags & O2_FLAG_TIMES)) {
-      error("query timestamps provided for non-timed database", dbName);
+      goto error;
     }
 
     *mddp = new double[adb->header->numFiles];
 
+    times_table = (double *) malloc(2 * *dvp * sizeof(double));
+    if(!times_table) {
+      goto error;
+    }
+    lseek(adb->fd, adb->header->timesTableOffset, SEEK_SET);
+    read_or_goto_error(adb->fd, times_table, 2 * *dvp * sizeof(double));
     for(unsigned int k = 0; k < adb->header->numFiles; k++) {
       size_t track_length = (*adb->track_lengths)[k];
       unsigned int j;
       (*mddp)[k] = 0.0;
       for(j = 0; j < track_length; j++) {
-	(*mddp)[k] += timesTable[2*j+1] - timesTable[2*j];
+	(*mddp)[k] += times_table[2*j+1] - times_table[2*j];
       }
       (*mddp)[k] /= j;
     }
+
+    free(times_table);
+    times_table = NULL;
   }
 
   *vsnp = *snp;
   *vspp = *spp;
   return 0;

   if(*spp) {
     delete [] *spp;
   }
   if(*mddp) {
     delete [] *mddp;
+  }
+  if(times_table) {
+    free(times_table);
   }
   return 1;
   
 }
 

 // A reporter has been allocated
 //
 // Postconditions:
 // reporter contains the points and distances that meet the reporter constraints 
 
-void audioDB::query_loop_points(adb_query_spec_t *spec, double* query, double* qnPtr, double* qpPtr, double meanQdur, Uns32T numVectors){ 
+void audioDB::query_loop_points(adb_query_spec_t *spec, double* query, adb_qpointers_internal_t *qpointers) {
   unsigned int dbVectors;
   double *sNorm = 0, *snPtr, *sPower = 0, *spPtr = 0;
   double *meanDBdur = 0;
 
   uint32_t sequence_length = spec->qid.sequence_length;
+  bool power_refine = spec->refine.flags & (ADB_REFINE_ABSOLUTE_THRESHOLD|ADB_REFINE_RELATIVE_THRESHOLD);
 
   // check pre-conditions
   assert(exact_evaluation_queue&&reporter);
   if(!exact_evaluation_queue->size()) // Exit if no points to evaluate
     return;
 
   // Compute database info
   // FIXME: we more than likely don't need very much of the database
   // so make a new method to build these values per-track or, even better, per-point
   if( !( dbH->flags & O2_FLAG_LARGE_ADB) )
-    if(set_up_db(adb, spec, &sNorm, &snPtr, &sPower, &spPtr, &meanDBdur, &dbVectors)) {
+    if(audiodb_set_up_db(adb, spec, &sNorm, &snPtr, &sPower, &spPtr, &meanDBdur, &dbVectors)) {
       error("failed to set up db");
     }
 
   VERB_LOG(1, "matching points...");
 

       trackIndexOffset=trackOffset/dbH->dim;    // num vectors offset
     }    
     Uns32T qPos = usingQueryPoint?0:pp.qpos;// index for query point
     Uns32T sPos = trackIndexOffset+pp.spos; // index into l2norm table
     // Test power thresholds before computing distance
-    if( ( !usingPower || audiodb_powers_acceptable(&spec->refine, qpPtr[qPos], sPower[sPos])) &&
-	( qPos<numVectors-sequence_length+1 && pp.spos<trackTable[pp.trackID]-sequence_length+1 ) ){
+    if( ( (!power_refine) || audiodb_powers_acceptable(&spec->refine, qpointers->power[qPos], sPower[sPos])) &&
+	( qPos<qpointers->nvectors-sequence_length+1 && pp.spos<trackTable[pp.trackID]-sequence_length+1 ) ){
       // Non-large ADB track data is loaded inside power test for efficiency
       if( !(dbH->flags & O2_FLAG_LARGE_ADB) && (currentTrack!=pp.trackID) ){
 	// On currentTrack change, allocate and load track data
 	currentTrack=pp.trackID;
 	lseek(dbfid, dbH->dataOffset + trackOffset * sizeof(double), SEEK_SET);
 	if(audiodb_read_data(adb, dbfid, currentTrack, &data_buffer, &data_buffer_size))
           error("failed to read data");
       }
       // Compute distance
       dist = audiodb_dot_product(query+qPos*dbH->dim, data_buffer+pp.spos*dbH->dim, dbH->dim*sequence_length);
-      double qn = qnPtr[qPos];
+      double qn = qpointers->l2norm[qPos];
       double sn = sNorm[sPos];
       switch(spec->params.distance) {
       case ADB_DISTANCE_EUCLIDEAN_NORMED:
 	dist = 2 - (2/(qn*sn))*dist;
         break;

   SAFE_DELETE_ARRAY(meanDBdur);
 }
 
 void audioDB::query_loop(adb_query_spec_t *spec, Uns32T queryIndex) {
   
-  unsigned int numVectors;
   double *query, *query_data;
-  double *qNorm, *qnPtr, *qPower = 0, *qpPtr = 0;
-  double meanQdur;
+  adb_qpointers_internal_t qpointers = {0};
+
+  bool power_refine = spec->refine.flags & (ADB_REFINE_ABSOLUTE_THRESHOLD|ADB_REFINE_RELATIVE_THRESHOLD);
 
   if( dbH->flags & O2_FLAG_LARGE_ADB )
     error("error: LARGE_ADB requires indexed query");
 
   if(query_from_key)
-    set_up_query_from_key(spec, &query_data, &query, &qNorm, &qnPtr, &qPower, &qpPtr, &meanQdur, &numVectors, queryIndex);
+    set_up_query_from_key(spec, &query_data, &query, &qpointers, queryIndex);
   else
-    set_up_query(spec, &query_data, &query, &qNorm, &qnPtr, &qPower, &qpPtr, &meanQdur, &numVectors);
+    set_up_query(spec, &query_data, &query, &qpointers);
 
   unsigned int dbVectors;
   double *sNorm, *snPtr, *sPower = 0, *spPtr = 0;
   double *meanDBdur = 0;
 
-  if(set_up_db(adb, spec, &sNorm, &snPtr, &sPower, &spPtr, &meanDBdur, &dbVectors)) {
+  if(audiodb_set_up_db(adb, spec, &sNorm, &snPtr, &sPower, &spPtr, &meanDBdur, &dbVectors)) {
     error("failed to set up db");
   }
 
   VERB_LOG(1, "matching tracks...");
   
   unsigned j,k,track,trackOffset=0, HOP_SIZE=sequenceHop;
   unsigned wL = spec->qid.sequence_length;
   double **D = 0;    // Differences query and target 
   double **DD = 0;   // Matched filter distance
 
-  D = new double*[numVectors]; // pre-allocate 
-  DD = new double*[numVectors];
+  D = new double*[qpointers.nvectors]; // pre-allocate 
+  DD = new double*[qpointers.nvectors];
 
   gettimeofday(&tv1, NULL); 
   unsigned processedTracks = 0;
   off_t trackIndexOffset;
   char nextKey[MAXSTR];

       else{
 	break;
       }
     }
 
-    trackIndexOffset=trackOffset/dbH->dim; // numVectors offset
+    trackIndexOffset=trackOffset/dbH->dim; // qpointers.nvectors offset
 
     if(audiodb_read_data(adb, dbfid, track, &data_buffer, &data_buffer_size))
       error("failed to read data");
     if(wL <= trackTable[track]) {  // test for short sequences
       
       VERB_LOG(7,"%u.%jd.%u | ", track, (intmax_t) trackIndexOffset, trackTable[track]);
       
-      initialize_arrays(adb, spec, track, numVectors, query, data_buffer, D, DD);
+      initialize_arrays(adb, spec, track, qpointers.nvectors, query, data_buffer, D, DD);
 
       if(spec->refine.flags & ADB_REFINE_DURATION_RATIO) {
-        VERB_LOG(3,"meanQdur=%f meanDBdur=%f\n", meanQdur, meanDBdur[track]);
-      }
-
-      if((!(spec->refine.flags & ADB_REFINE_DURATION_RATIO)) || fabs(meanDBdur[track]-meanQdur) < meanQdur*spec->refine.duration_ratio) {
+        VERB_LOG(3,"meanQdur=%f meanDBdur=%f\n", qpointers.mean_duration[0], meanDBdur[track]);
+      }
+
+      if((!(spec->refine.flags & ADB_REFINE_DURATION_RATIO)) || 
+         fabs(meanDBdur[track]-qpointers.mean_duration[0]) < qpointers.mean_duration[0]*spec->refine.duration_ratio) {
         if(spec->refine.flags & ADB_REFINE_DURATION_RATIO) {
           VERB_LOG(3,"within duration tolerance.\n");
         }
 
 	// Search for minimum distance by shingles (concatenated vectors)
-	for(j = 0; j <= numVectors - wL; j += HOP_SIZE) {
+	for(j = 0; j <= qpointers.nvectors - wL; j += HOP_SIZE) {
 	  for(k = 0; k <= trackTable[track] - wL; k += HOP_SIZE) {
             double thisDist = 0;
             switch(spec->params.distance) {
             case ADB_DISTANCE_EUCLIDEAN_NORMED:
-              thisDist = 2-(2/(qnPtr[j]*sNorm[trackIndexOffset+k]))*DD[j][k];
+              thisDist = 2-(2/(qpointers.l2norm[j]*sNorm[trackIndexOffset+k]))*DD[j][k];
               break;
             case ADB_DISTANCE_EUCLIDEAN:
-              thisDist = qnPtr[j]*qnPtr[j]+sNorm[trackIndexOffset+k]*sNorm[trackIndexOffset+k] - 2*DD[j][k];
+              thisDist = qpointers.l2norm[j]*qpointers.l2norm[j]+sNorm[trackIndexOffset+k]*sNorm[trackIndexOffset+k] - 2*DD[j][k];
               break;
             case ADB_DISTANCE_DOT_PRODUCT:
               thisDist = DD[j][k];
               break;
             }
 	    // Power test
-	    if ((!usingPower) || audiodb_powers_acceptable(&spec->refine, qpPtr[j], sPower[trackIndexOffset + k])) {
+	    if ((!power_refine) || audiodb_powers_acceptable(&spec->refine, qpointers.power[j], sPower[trackIndexOffset + k])) {
               // radius test
               if((!(spec->refine.flags & ADB_REFINE_RADIUS)) || 
                  thisDist <= (spec->refine.radius+O2_DISTANCE_TOLERANCE)) {
                 adb_result_t r;
                 r.key = fileTable + track * O2_FILETABLE_ENTRY_SIZE;

               }
             }
           }
         }
       } // Duration match            
-      audiodb_delete_arrays(track, numVectors, D, DD);
+      audiodb_delete_arrays(track, qpointers.nvectors, D, DD);
     }
   }
 
   free(data_buffer);
 

            (tv1.tv_sec*1000 + tv1.tv_usec/1000))
 
   // Clean up
   if(query_data)
     delete[] query_data;
-  if(qNorm)
-    delete[] qNorm;
+  if(qpointers.l2norm_data)
+    delete[] qpointers.l2norm_data;
+  if(qpointers.power_data)
+    delete[] qpointers.power_data;
+  if(qpointers.mean_duration)
+    delete[] qpointers.mean_duration;
   if(sNorm)
     delete[] sNorm;
-  if(qPower)
-    delete[] qPower;
   if(sPower)
     delete[] sPower;
   if(D)
     delete[] D;
   if(DD)