Made Haar transform multithreaded

Author: gurushida

fingerprinting.c

@@ -7,8 +7,6 @@
 #include "spectralimages.h"
 #include "wav.h"
 
-
-
 int generate_fingerprint(const char* wav, struct signatures* *fingerprint,
                             char* *artist, char* *track_title, char* *album_title) {
     // Let's make sure we have a wave file we can read
@@ -57,8 +55,10 @@ int generate_fingerprint(const char* wav, struct signatures* *fingerprint,
     }
 
     fprintf(stderr, "Got %d spectral images\n", spectral_images->n_images);
+    fprintf(stderr, "Applying Haar transform to spectral images\n");
     apply_Haar_transform(spectral_images);
 
+    fprintf(stderr, "Building raw fingerprints\n");
     struct rawfingerprints* rawfingerprints = build_raw_fingerprints(spectral_images);
     free_spectral_images(spectral_images);
     if (rawfingerprints == NULL) {

haar.c

@@ -1,8 +1,18 @@
 #include <math.h>
+#include <pthread.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include "haar.h"
 
+#define N_THREADS 8
+
+
+struct haar_transform_job {
+    struct spectral_image* images;
+    unsigned int first_image;
+    unsigned int last_image;
+};
+
 
 /**
  * Applies in place the 1-dimension Haar transform.
@@ -34,11 +44,8 @@ static void transform_array(float* data, unsigned int size) {
 
 /**
  * Transforms in place a spectral image.
- *
- * @param data The frame buffer
- * @param image_index The index of the image to transform
  */
-static void transform_image(struct spectral_image* image) {
+void transform_image(struct spectral_image* image) {
     // The 2D standard Haar transform consists of applying
     // the 1D Haar transform to each row of the image and then
     // to each column of the result
@@ -66,8 +73,33 @@ static void transform_image(struct spectral_image* image) {
 }
 
 
-void apply_Haar_transform(struct spectral_images* images) {
-    for (unsigned int i = 0 ; i < images->n_images ; i++) {
-        transform_image(&(images->images[i]));
+static void* launch_Haar_job(struct haar_transform_job* job) {
+    for (unsigned int i = job->first_image ; i <= job->last_image ; i++) {
+        transform_image(&(job->images[i]));
     }
+
+    return NULL;
 }
+
+
+void apply_Haar_transform(struct spectral_images* spectral_images) {
+    pthread_t thread[N_THREADS];
+    struct haar_transform_job haar_job[N_THREADS];
+    unsigned int images_per_thread = spectral_images->n_images / N_THREADS;
+
+    for (unsigned int k = 0 ; k < N_THREADS ; k++) {
+        unsigned int start = k * images_per_thread;
+        unsigned int end = (k == N_THREADS - 1)
+                        ? spectral_images->n_images - 1
+                        : (k + 1) * images_per_thread - 1;
+        haar_job[k].images = spectral_images->images;
+        haar_job[k].first_image = start;
+        haar_job[k].last_image = end;
+
+        pthread_create(&(thread[k]), NULL, (void* (*)(void*))launch_Haar_job, &(haar_job[k]));
+    }
+    for (unsigned int k = 0 ; k < N_THREADS ; k++) {
+        pthread_join(thread[k], NULL);
+    }
+}
+

haar.h

@@ -22,11 +22,10 @@
  * getting a smaller image by using the same color for parts that
  * are very similar).
  *
- * The function applies the Haar transform to each spectral image to make
+ * The function applies the Haar transform to the given spectral images to make
  * it suitable for further compression. Since the Haar transform produces
  * for each image an output of the same size, this function will modify the
- * given data in place. If the number of frames is not divisible by 128,
- * the remaining frames at the end are left unmodified.
+ * given data in place.
  */
 void apply_Haar_transform(struct spectral_images* images);