Modifier une image pixel par pixel

#include <stdlib.h>
#include <stdio.h>
#include <SDL/SDL.h>
/* ********************************************************************* */
//Prototypes
//Les commentaires sont dans les corps de fonction.
void waitAndQuit(void);
void BalanceDesCouleurs(SDL_Surface* surface, int rAjout, int gAjout, int bAjout);
Uint8 addVal(Uint8 composante,int);
Uint32 getPixel(SDL_Surface* surface, int x, int y);
void setPixel(SDL_Surface* surface, int x, int y, Uint32 pixel);
/* ********************************************************************* */
//Fonction principale
int main(int argc, char** argv)
{
        //On créé les deux surfaces qui vont nous servir :
        //L'écran, et l'image à afficher
        SDL_Surface *ecran = NULL, *image = NULL;

        //Pour positionner les images
        SDL_Rect position;

        //On initialise la SDL.
        SDL_Init(SDL_INIT_VIDEO);

        //On initialise l'écran
        ecran = SDL_SetVideoMode(600, 200, 32,  SDL_ANYFORMAT |
                                            SDL_HWSURFACE );

        //On change le titre de la fenêtre
        SDL_WM_SetCaption("Modification d'une image pixel par pixel : balance des couleurs", NULL);

        //On charge notre image
        image = SDL_LoadBMP("image.bmp");

        //Position de l'image originale dans l'écran.
        position.x = 0;
        position.y = 0;
        //On copie l'image originale dans l'écran
        SDL_BlitSurface(image, NULL, ecran, &position);

        //On modifie l'image originale
        BalanceDesCouleurs(image, -50, 20, 0);
        //Position de la nouvelle image, pour ne pas être collée par dessus l'originale
        position.x = 200;
        position.y = 0;
        //On copie la nouvelle image dans l'écran
        SDL_BlitSurface(image, NULL, ecran, &position);

        //On remodifie encore l'image déjà modifiée
        BalanceDesCouleurs(image, 0, -80, 100);
        position.x = 400;
        position.y = 0;
        SDL_BlitSurface(image, NULL, ecran, &position);

        SDL_Flip(ecran);/* Force l'affichage. Facultatif ici, mais on ne sait jamais.*/

        waitAndQuit(); //Permet de voir le résultat de nos efforts

        return EXIT_SUCCESS; //Jamais atteint car waitAndQuit(); fait quitter le programme.
}
/* ********************************************************************* */
//Fonction permettant d'attendre que l'utilisateur quitte le programme
void waitAndQuit(void)
{
        SDL_Event event;

        while (SDL_WaitEvent (&event)) //Boucle infinie
        {
                switch(event.type)
                {
                        case SDL_QUIT :
                                SDL_Quit();
                                exit(0); //On quitte le programme.
                                //Bon, j'ai pas utilisé FreeSurface, donc c'est pas propre.
                                //Mais c'est un exemple :)
                }
        }
}

/* ********************************************************************* */
/*Balance des couleurs : permet d'ajouter ou d'enlever de la couleur à toute l'image.
Paramètres :
SDL_Surface *surface : la surface à modifier
int rAjout : La quantité de rouge que l'on veut ajouter ou soustraire (entre -255 et +255)
int gAjout : La quantité de vert que l'on veut ajouter ou soustraire (entre -255 et +255)
int bAjout : La quantité de bleu que l'on veut ajouter ou soustraire (entre -255 et +255)
*/
void BalanceDesCouleurs(SDL_Surface* surface, int rAjout, int gAjout, int bAjout)
{
        /*x et y sont les index permettant de se déplacer dans l'image*/
        int x, y;
        /* r,g,b,a vont stocker les composantes d'un pixel*/
        Uint8 r, g, b, a;
        /* pixel stocke le code couleur d'un pixel*/
        Uint32 pixel;

        /* On bloque la surface pour pouvoir travailler dessus */
        SDL_LockSurface(surface);
        //Double boucle pour parcourir l'intégralité de l'image.
        for (y=0 ; y < surface->h ; y++)
        {
                for (x=0 ; x < surface->w ; x++)
                {
                        //On récupère le code couleur du pixel.
                        pixel=getPixel(surface, x, y);
                        //On extrait les composantes rouge, vert, bleu et alpha
                        SDL_GetRGBA(pixel, surface->format, &r, &g, &b, &a);

                        //On ajoute/soustrait la quantité voulue aux 3 composantes rouge, vert, bleu.
                        r = addVal(r, rAjout);
                        g = addVal(g, gAjout);
                        b = addVal(b, bAjout);

                        /* On rétransforme les 4 composantes en un seul code couleur dans pixel */
                        pixel=SDL_MapRGBA(surface->format, r, g, b, a);
                        /* On injecte le code couleur pixel dans le pixel correspondant*/
                        setPixel(surface, x, y, pixel);
                }
        }
        /* La surface peut désormais être réutilisée pour autre chose*/
        SDL_UnlockSurface(surface);
}
/* ********************************************************************* */
//Pour ajouter une certaine valeur à une composante
//En restant dans l'intervalle [0,255]
Uint8 addVal(Uint8 composante, int valeur)
{
        int tampon; //Variable entière qui sert de tampon
        tampon = composante + valeur;

        /* On fait en sorte que tampon reste dans l'intervalle [0,255] */
        if (tampon > 255)
        {
                tampon = 255;
        }
        else if (tampon < 0)
        {
                tampon = 0;
        }
        /* Avec l'opérateur cast (Uint8) on tranforme tampon en un entier de type Uint8*/
        return composante = (Uint8) tampon;
}
/* ********************************************************************* */
//Pour récupérer la couleur d'un pixel
//Ce code n'est pas commenté car trop complexe.
Uint32 getPixel(SDL_Surface* surface, int x, int y)
{
        int bpp = surface->format->BytesPerPixel;
        /* Ici p est l'adresse du pixel que l'on veut connaitre */
        Uint8 *p = (Uint8*) surface->pixels + y * surface->pitch + x * bpp;


        switch(bpp)
        {
                case 1:
                        return *p;

                case 2:
                        return (Uint16) *p;

                case 3:
                        if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
                                return p[0] << 16 | p[1] << 8 | p[2];
                        else
                                return p[0] | p[1] << 8 | p[2] << 16;

                        case 4:
                                return (Uint32) *p;

                        default:
                                return 0; /* Ne devrait pas arriver, mais évite les erreurs */
        }
 }
/* ********************************************************************* */
//Pour modifier la couleur d'un pixel
//Ce code n'est pas commenté car trop complexe.
void setPixel(SDL_Surface* surface, int x, int y, Uint32 pixel)
{
        int bpp = surface->format->BytesPerPixel;
        /* Ici p est l'adresse du pixel que l'on veut modifier */
        Uint8 *p = (Uint8*) surface->pixels + y * surface->pitch + x * bpp;


        switch(bpp)
        {
                case 1:
                        *p = pixel;
                        break;

                case 2:
                        (Uint16) *p = pixel;
                        break;

                case 3:
                        if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
                        {
                                p[0] = (pixel >> 16) & 0xff;
                                p[1] = (pixel >> 8) & 0xff;
                                p[2] = pixel & 0xff;
                        }
                        else
                        {
                                p[0] = pixel & 0xff;
                                p[1] = (pixel >> 8) & 0xff;
                                p[2] = (pixel >> 16) & 0xff;
                        }
                        break;

                case 4:
                        (Uint32) *p = pixel;
                        break;
        }
 }

/* on donne en argument le pointeur vers l'image que l'on a chargé
   et on récupère le pointeur vers la nouvelle image redimensionnée */
SDL_Surface* resize(SDL_Surface* image)
{
    int i,j,x,y = 0;
    Uint32 pixel;
    // je crée ma surface aux bonnes dimensions
    SDL_Surface* img = SDL_CreateRGBSurface(SDL_SWSURFACE,image->w/2,image->h/2,32,0,0,0,0);
   
    // je bloque les deux images
    SDL_LockSurface(image);
    SDL_LockSurface(img);
   
    // je prend une ligne et une colonne sur deux
    for (j=0;j < image->h;j = j+2) {
        x=0;
        for (i=0;i < image->w;i = i+2) {
            pixel = getPixel(image,i,j);
            setPixel(img,x,y,pixel);
            x++;
        }
        y++;
    }
   
    // je débloque les images
    SDL_UnlockSurface(img);
    SDL_UnlockSurface(image);
    // je libère la surface initiale
    SDL_FreeSurface(image);

    return img;
}