changeset 425:d65410f4bb85 api-inversion

Begin pushing information through.

Create and initialize an adb_query_refine_t struct in audioDB::query,
and pass it through to various callees, which can then use it instead of
the automagic class member variables.

This allows conversion of some routines into ordinary static C
functions.  Begin doing so.

--- a/audioDB-internals.h	Wed Dec 24 10:55:12 2008 +0000
+++ b/audioDB-internals.h	Wed Dec 24 10:55:16 2008 +0000
@@ -102,3 +102,11 @@
  error:
   return 1;
 }
+
+static inline double audiodb_dot_product(double *p, double *q, size_t count) {
+  double result = 0;
+  while(count--) {
+    result += *p++ * *q++;
+  }
+  return result;
+}

--- a/audioDB.h	Wed Dec 24 10:55:12 2008 +0000
+++ b/audioDB.h	Wed Dec 24 10:55:16 2008 +0000
@@ -333,9 +333,8 @@
   void set_up_query(double **qp, double **vqp, double **qnp, double **vqnp, double **qpp, double **vqpp, double *mqdp, unsigned int *nvp);
   void set_up_query_from_key(double **qp, double **vqp, double **qnp, double **vqnp, double **qpp, double **vqpp, double *mqdp, unsigned *nvp, Uns32T queryIndex);
   void set_up_db(double **snp, double **vsnp, double **spp, double **vspp, double **mddp, unsigned int *dvp);
-  void query_loop(const char* dbName, Uns32T queryIndex);
-  void query_loop_points(double* query, double* qnPtr, double* qpPtr, double meanQdur, Uns32T numVectors);
-  double dot_product_points(double* q, double* p, Uns32T  L);
+  void query_loop(adb_query_refine_t *refine, Uns32T queryIndex);
+  void query_loop_points(double* query, double* qnPtr, double* qpPtr, double meanQdur, Uns32T numVectors, adb_query_refine_t *refine);
   void initRNG();
   void initDBHeader(const char *dbName);
   void initInputFile(const char *inFile, bool loadData = true);
@@ -369,7 +368,6 @@
   void sample(const char *dbName);
   void l2norm(const char* dbName);
   void power_flag(const char *dbName);
-  bool powers_acceptable(double p1, double p2);
   void dump(const char* dbName);
   void liszt(const char* dbName, unsigned offset, unsigned numLines, adb__lisztResponse* adbLisztResponse=0);
 
@@ -400,7 +398,7 @@
   Uns32T index_insert_shingles(vector<vector<float> >*, Uns32T trackID, double* spp);
   void index_make_shingle(vector<vector<float> >*, Uns32T idx, double* fvp, Uns32T dim, Uns32T seqLen);
   int index_norm_shingles(vector<vector<float> >*, double* snp, double* spp);
-  int index_query_loop(const char* dbName, Uns32T queryIndex);
+  int index_query_loop(adb_query_refine_t *refine, const char* dbName, Uns32T queryIndex);
   vector<vector<float> >* index_initialize_shingles(Uns32T sz);
   int index_init_query(const char* dbName);
   int index_exists(const char* dbName, double radius, Uns32T sequenceLength);

--- a/index.cpp	Wed Dec 24 10:55:12 2008 +0000
+++ b/index.cpp	Wed Dec 24 10:55:16 2008 +0000
@@ -575,7 +575,7 @@
 
 // return 0: if index does not exist
 // return nqv: if index exists
-int audioDB::index_query_loop(const char* dbName, Uns32T queryIndex) {
+int audioDB::index_query_loop(adb_query_refine_t *refine, const char* dbName, Uns32T queryIndex) {
   
   unsigned int numVectors = 0;
   double *query = 0, *query_data = 0;
@@ -640,7 +640,7 @@
 
   if(lsh_exact)
     // Perform exact distance computation on point pairs in exact_evaluation_queue
-    query_loop_points(query, qnPtr, qpPtr, meanQdur, numVectors); 
+    query_loop_points(query, qnPtr, qpPtr, meanQdur, numVectors, refine); 
   
   gettimeofday(&tv2,NULL);
   VERB_LOG(1,"elapsed time: %ld msec\n",

--- a/query.cpp	Wed Dec 24 10:55:12 2008 +0000
+++ b/query.cpp	Wed Dec 24 10:55:16 2008 +0000
@@ -4,14 +4,14 @@
 #include "audioDB-internals.h"
 #include "accumulators.h"
 
-bool audioDB::powers_acceptable(double p1, double p2) {
-  if (use_absolute_threshold) {
-    if ((p1 < absolute_threshold) || (p2 < absolute_threshold)) {
+static bool audiodb_powers_acceptable(adb_query_refine_t *r, double p1, double p2) {
+  if (r->flags & ADB_REFINE_ABSOLUTE_THRESHOLD) {
+    if ((p1 < r->absolute_threshold) || (p2 < r->absolute_threshold)) {
       return false;
     }
   }
-  if (use_relative_threshold) {
-    if (fabs(p1-p2) > fabs(relative_threshold)) {
+  if (r->flags & ADB_REFINE_RELATIVE_THRESHOLD) {
+    if (fabs(p1-p2) > fabs(r->relative_threshold)) {
       return false;
     }
   }
@@ -19,6 +19,32 @@
 }
 
 void audioDB::query(const char* dbName, const char* inFile, adb__queryResponse *adbQueryResponse) {
+
+  adb_query_refine_t refine;
+  refine.flags = 0;
+  /* FIXME: trackFile / ADB_REFINE_KEYLIST */
+  if(radius) {
+    refine.flags |= ADB_REFINE_RADIUS;
+    refine.radius = radius;
+  }
+  if(use_absolute_threshold) {
+    refine.flags |= ADB_REFINE_ABSOLUTE_THRESHOLD;
+    refine.absolute_threshold = absolute_threshold;
+  }
+  if(use_relative_threshold) {
+    refine.flags |= ADB_REFINE_RELATIVE_THRESHOLD;
+    refine.relative_threshold = relative_threshold;
+  }
+  if(usingTimes) {
+    refine.flags |= ADB_REFINE_DURATION_RATIO;
+    refine.duration_ratio = timesTol;
+  }
+  /* FIXME: not sure about this any more; maybe it belongs in query_id */
+  if(sequenceHop != 1) {
+    refine.flags |= ADB_REFINE_HOP_SIZE;
+    refine.hopsize = sequenceHop;
+  }
+
   // init database tables and dbH first
   if(query_from_key)
     initTables(dbName);
@@ -46,7 +72,7 @@
     if(no_unit_norming)
       normalizedDistance = false;
     accumulator = new PerTrackAccumulator<adb_result_dist_lt>(pointNN, trackNN);
-    if(radius == 0) {
+    if(!(refine.flags & ADB_REFINE_RADIUS)) {
       reporter = new trackAveragingReporter< std::less< NNresult > >(pointNN, trackNN, dbH->numFiles);
     } else {
       if(index_exists(dbName, radius, sequenceLength)){
@@ -63,7 +89,7 @@
     if(no_unit_norming)
       normalizedDistance = false;
     accumulator = new PerTrackAccumulator<adb_result_dist_lt>(pointNN, trackNN);
-    if(radius == 0) {
+    if(!(refine.flags & ADB_REFINE_RADIUS)) {
       reporter = new trackSequenceQueryNNReporter< std::less < NNresult > >(pointNN, trackNN, dbH->numFiles);
     } else {
       if(index_exists(dbName, radius, sequenceLength)){
@@ -78,7 +104,7 @@
     break;
   case O2_ONE_TO_ONE_N_SEQUENCE_QUERY :
     accumulator = new NearestAccumulator<adb_result_dist_lt>();
-    if(radius == 0) {
+    if(!(refine.flags & ADB_REFINE_RADIUS)) {
       error("query-type not yet supported");
     } else {
       reporter = new trackSequenceQueryRadNNReporterOneToOne(pointNN,trackNN, dbH->numFiles);
@@ -89,13 +115,13 @@
   }  
 
   // Test for index (again) here
-  if(radius && index_exists(dbName, radius, sequenceLength)){ 
+  if((refine.flags & ADB_REFINE_RADIUS) && index_exists(dbName, radius, sequenceLength)){ 
     VERB_LOG(1, "Calling indexed query on database %s, radius=%f, sequenceLength=%d\n", dbName, radius, sequenceLength);
-    index_query_loop(dbName, query_from_key_index);
+    index_query_loop(&refine, dbName, query_from_key_index);
   }
   else{
     VERB_LOG(1, "Calling brute-force query on database %s\n", dbName);
-    query_loop(dbName, query_from_key_index);
+    query_loop(&refine, query_from_key_index);
   }
 
   adb_query_results_t *rs = accumulator->get_points();
@@ -550,7 +576,7 @@
 // Postconditions:
 // reporter contains the points and distances that meet the reporter constraints 
 
-void audioDB::query_loop_points(double* query, double* qnPtr, double* qpPtr, double meanQdur, Uns32T numVectors){ 
+void audioDB::query_loop_points(double* query, double* qnPtr, double* qpPtr, double meanQdur, Uns32T numVectors, adb_query_refine_t *refine){ 
   unsigned int dbVectors;
   double *sNorm = 0, *snPtr, *sPower = 0, *spPtr = 0;
   double *meanDBdur = 0;
@@ -619,7 +645,7 @@
     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 || powers_acceptable(qpPtr[qPos], sPower[sPos])) &&
+    if( ( !usingPower || audiodb_powers_acceptable(refine, qpPtr[qPos], sPower[sPos])) &&
 	( qPos<numVectors-sequenceLength+1 && pp.spos<trackTable[pp.trackID]-sequenceLength+1 ) ){
       // Non-large ADB track data is loaded inside power test for efficiency
       if( !(dbH->flags & O2_FLAG_LARGE_ADB) && (currentTrack!=pp.trackID) ){
@@ -629,7 +655,7 @@
 	read_data(dbfid, currentTrack, &data_buffer, &data_buffer_size);
       }
       // Compute distance
-      dist = dot_product_points(query+qPos*dbH->dim, data_buffer+pp.spos*dbH->dim, dbH->dim*sequenceLength);
+      dist = audiodb_dot_product(query+qPos*dbH->dim, data_buffer+pp.spos*dbH->dim, dbH->dim*sequenceLength);
       double qn = qnPtr[qPos];
       double sn = sNorm[sPos];
       if(normalizedDistance) 
@@ -656,16 +682,7 @@
   SAFE_DELETE_ARRAY(meanDBdur);
 }
 
-// A completely unprotected dot-product method
-// Caller is responsible for ensuring that memory is within bounds
-inline double audioDB::dot_product_points(double* q, double* p, Uns32T  L){
-  double dist = 0.0;
-  while(L--)
-    dist += *q++ * *p++;
-  return dist;
-}
-
-void audioDB::query_loop(const char* dbName, Uns32T queryIndex) {
+void audioDB::query_loop(adb_query_refine_t *refine, Uns32T queryIndex) {
   
   unsigned int numVectors;
   double *query, *query_data;
@@ -745,12 +762,12 @@
       
       initialize_arrays(track, numVectors, query, data_buffer, D, DD);
 
-      if(usingTimes) {
+      if(refine->flags & ADB_REFINE_DURATION_RATIO) {
         VERB_LOG(3,"meanQdur=%f meanDBdur=%f\n", meanQdur, meanDBdur[track]);
       }
 
-      if((!usingTimes) || fabs(meanDBdur[track]-meanQdur) < meanQdur*timesTol) {
-        if(usingTimes) {
+      if((!(refine->flags & ADB_REFINE_DURATION_RATIO)) || fabs(meanDBdur[track]-meanQdur) < meanQdur*refine->duration_ratio) {
+        if(refine->flags & ADB_REFINE_DURATION_RATIO) {
           VERB_LOG(3,"within duration tolerance.\n");
         }
 
@@ -767,9 +784,10 @@
 		thisDist = DD[j][k];
 
 	    // Power test
-	    if ((!usingPower) || powers_acceptable(qpPtr[j], sPower[trackIndexOffset + k])) {
+	    if ((!usingPower) || audiodb_powers_acceptable(refine, qpPtr[j], sPower[trackIndexOffset + k])) {
               // radius test
-              if((!radius) || thisDist <= (radius+O2_DISTANCE_TOLERANCE)) {
+              if((!(refine->flags & ADB_REFINE_RADIUS)) || 
+                 thisDist <= (refine->radius+O2_DISTANCE_TOLERANCE)) {
                 adb_result_t r;
                 r.key = fileTable + track * O2_FILETABLE_ENTRY_SIZE;
                 r.dist = thisDist;
@@ -832,5 +850,3 @@
   }
   VERB_LOG(2, "done.\n");
 }
-
-