Rewriting JPEG images from RGB to HSL : how can i optimize this? - c

Question

i'm on a project where i have to make a program that will draw an ASCII from a JPEG.
The program will chose a char according to the HSL value of a pixel : Hue, Saturation, Lightness
So, as a JPEG file is in RGB, i convert it into HSL.
But i find my program pretty slow and it slows my whole virtual machine lel
Do you know how i could improve it for making it a little bit faster ?
it's in my write i call the function that converts RGB into HSL
here it is :
main.c :
#include <stdio.h>
#include <stdlib.h>
#include <jpeglib.h>
#include "fonctions.h"
int main (int argc, char** argv){
int H;
int W;
int C;
FILE *fichier = NULL; //file pour l'image entrée
FILE *image = NULL; //file pou l'image à la sortie
unsigned char **buffer; //buffer où sera contenue l'image
buffer = malloc(256*(sizeof(unsigned char*)));
if (argv[1] == NULL)
fichier = fopen("cara.jpg", "r");
else
fichier = fopen(argv[1], "r");
image = fopen("cara_image_cree.jpg", "wb");
if (fichier == NULL)
printf("Probleme lecture");
printf("Cara Delevingne\n");
buffer = lire(fichier, &H, &W, &C);
/* afficher 3 sous-pixels :
printf("\nBuffer case 1 : %d", buffer[0][0]);
printf("\nBuffer case 1 : %d", buffer[0][0+1]);
printf("\nBuffer case 1 : %d\n", buffer[0][0+2]);*/
ecrire(&H, &W, &C, buffer, image);
fclose(fichier);
fclose(image);
return 0;
}
read.c :
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <jpeglib.h>
#include <jerror.h>
unsigned char** lire (FILE* file, int *H, int *W, int *C){
struct jpeg_decompress_struct cinfo;
struct jpeg_error_mgr jerr;
int n = 0;
unsigned char** buffer; // buffer qui va contenir l'image
/*printf("SHITSHITSHITSHITDEBUG\n");
fflush(stdout);*/
cinfo.err = jpeg_std_error(&jerr);
jpeg_create_decompress(&cinfo); // Initialisation de la structure
jpeg_stdio_src(&cinfo,file); // file est de type FILE * (descripteur de fichier
// sur le fichier jpega decompresser)
jpeg_read_header(&cinfo,TRUE);// lecture des infos sur l'image jpeg
jpeg_start_decompress(&cinfo);// lancement du processus de decompression
*H = cinfo.output_height; // on récupère la hauteur
*W = cinfo.output_width; // on récupère la largeur
*C = cinfo.output_components; // on regarde si l'image est en couleurs ou N&B
buffer=malloc( (*H) *sizeof(unsigned char*) ); // on alloue de la mémoire au buffer selon le nb de lignes de pixels qu'il va devoir prendre
while (n < *H) // tant que le compteur n'a pas dépassé l'image
{
buffer[n] = (unsigned char*) malloc( (*W) * (*C) *sizeof(unsigned char *) ); // on alloue à chaque ligne, la taille de la largeur
jpeg_read_scanlines(&cinfo,buffer+n,1); // lecture des n lignes suivantes de l'image
// dans le buffer (de type unsigned char *)
n++;
}
jpeg_finish_decompress(&cinfo);
jpeg_destroy_decompress(&cinfo);
return buffer;
}
write.c :
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <jpeglib.h>
#include <jerror.h>
void ecrire (int *H, int *W, int *C, unsigned char **buffer, FILE *file){
struct jpeg_compress_struct cinfo;
struct jpeg_error_mgr jerr;
float** bufferHSL;
int n = 0; // parcoureurs pour écrire l'image
int i = 0; // parcoureurs pour transformer en HSL
int j = 0;
float h = 0; // variables pour stocker le résultat HSL
float s = 0;
float l = 0;
int r, g, b;
cinfo.err = jpeg_std_error(&jerr);
jpeg_create_compress(&cinfo); // Initialisation de la structure
jpeg_stdio_dest(&cinfo,file); // file est de type FILE * (descripteur de fichier
// sur le fichier jpeg compressé final)
cinfo.image_width= *W; // nombre de ligne de l'image
cinfo.image_height= *H; // nombre de pixel par ligne
cinfo.input_components = *C; // 3 pour une image couleur, 1 pour une N&B
cinfo.in_color_space= JCS_RGB;
// JCS_GRAYSCALE pour une image N&B
jpeg_set_defaults(&cinfo); // initialisation des paramètres de compression
jpeg_start_compress(&cinfo,TRUE); // lancement du processus de decompression
bufferHSL = (float **) malloc( (*H) *sizeof(long int*) );
while (i < *H){ // lecture des lignes pour transformation HSL
j = 0;
while (j < *W){
/*printf("i : %d /t j : %d \n",i , j);
fflush(stdout);*/
bufferHSL[i] = (float*)malloc( (*W) *sizeof(long int*) );
r = buffer[i][j];
g = buffer[i][j+1];
b = buffer[i][j+2];
rgbToHsl(r, g, b, &h, &s, &l);
bufferHSL[i][j] = h;
bufferHSL[i][j+1] = s;
bufferHSL[i][j+2] = l;
j++;
/*printf("TESTTEST\n");
fflush(stdout);*/
}
i++;
}
while (n < *H)
{
jpeg_write_scanlines(&cinfo,buffer+n,1);// écriture des n lignes suivantes de l'image
// stockées dans le buffer (de type unsigned char *)
n++;
}
jpeg_finish_compress(&cinfo);
jpeg_destroy_compress(&cinfo);
}
RGB_to_HSL.c :
void rgbToHsl(int r, int g, int b, int *h, int *s, int *l){
r/=255; g /= 255; b/=255;
int max = maximum(r, g, b);
int min = minimum(r, g, b);
*l = (max + min)/2;
if (max == min)
*h = *s = 0; // achromatique
else{
int d = max - min;
*s = *l > 0.5 ? d / (2 - max - min) : d / (max + min);
if (max == r)
*h = (g-b) / d + (g < b ? 6 : 0);
if (max == g)
*h = (b-r) / d + 2;
if (max == b)
*h = (r-g) / d + 4;
/*case r: *h = r;
case g: *h = g;
case b: *h = b; */
}
*h /= 6;
}
int maximum (int a, int b, int c){
if (a > b){
if (a > c)
return a;
else
return c;
}
else{
if (b > c)
return b;
if (c > b)
return c;
}
}
int minimum (int a, int b, int c){
if (a < b){
if (a < c)
return a;
else
return c;
}
else{
if (b < c)
return b;
if (c < b)
return c;
}
}

Answer 1

You should run some profiling tool to see exactly which parts take how long to execute and optimize that.
Without that, a quick look shows you are calling malloc a lot in an inner loop, here:
bufferHSL = (float **) malloc( (*H) *sizeof(long int*) );
while (i < *H){ // lecture des lignes pour transformation HSL
j = 0;
while (j < *W){
bufferHSL[i] = (float*)malloc( (*W) *sizeof(long int*) );
Actually, that seems just wrong - You are calling it for every j < *W iteration, but you only need it once per i. You are leaking the allocation, and only doing anything on it in the last iteration - are you sure your output is correct?
As a first step, I recommend moving that line out of the inner while loop.
There is room for several other microoptimizations, but I don't think you need to do them. Just make sure the code is first correct, and then find the part that is slow (usually it is the innermost loop), and focus just on that.