J'ai fais une fonction pour copier des bmp de 320*240*24 bpp NON COMPRESSES
dans cette fonction, je copie les deux entetes, puis je fais une boucle pour recupérer dans un tableau chaque pixel :
palette tab[320][240]; // structure de 3 unsigned char
for(int j = 0;j < 240; j++)
{
  for(int i = 0; i < 320; i++)
  {
     fread(&tab[i][j],sizeof(tab[i][j]),1,F); // F = fichier
                                              //     source
     fwrite(&tab[i][j],sizeof(tab[i][j],1,P); // destination
  }
}
ca parait bete, mais ca marche pour les bmp créés sous paint, mais pas sous photoshop ou les autres logiciel,(il n'y a aucune compression qui n'intervient) la copie obtenue n'est pas complete, je n'obtient que les 1/4 du bas de l'image
Je comprend pas peut on m'aidr ?

tu démarré le chargement à un offset fixe, ou par rapport aux infos du header ????? (y a ptet une palette optionnelle ???, t'as zieuté le MSDN pour voir tous les cas de figure)

attention, il y a une magouille. En fait chaque ligne d'une fichier bmp a une longueur qui doit etre un multiple de 4. si la ligne : "BVRBVRBVRBVRBVR" fait 15 octets donc il y a un octet qui sera ajouté à la fin.
 
mais bon normalement c'est bon puisque 320*3/4=240 donc y'a rien a ajouter.
 
c'est louche ton histoire

ce qui est plus louche c'est que le fichier crée avec paint et l'autre avec photoshop ont la meme taille à 2 octets près, je comprend pas...

Et alors, qu'est-ce que tu as contre paint, c'est bien et ca permet de faire de belle image paint
(beeuuuuuuaaaaaaaarrrrrrrrrrrrrrrrrrrrrkkkkkk)

c'est bizarre ton histoire, je te file les fonctions que j'utilise et qui marche. L'image chargé zst enregistré dans un tampon au format OpenGL RGBA.
 
chargement :
 
// -----------------------------------------------------------------------------
// charge les textures en mémoire à partir de fichiers bmp 24bits non compressés dans Texture_TMP qui est une variable globale
// retourne 1 ou 0
int Load_BMP_Ex(char* nom_fichier) {
 // Fichier bmp non compressé 24bits
  FILE*         fichier;
  unsigned char entete[54];
  int         position_donnees=0;
  int           nb_pixels=0;
  int           taille_donnees_24=0;
  int           taille_donnees_32=0;
  int           taille_donnees_fichier=0;
  int           complement=0;
  GLubyte*      Image_TMP=(GLubyte*)NULL; // image de la texture en chargement
 
 // Ouverture du fichier
  fichier = fopen(nom_fichier,"rb" );
  if (fichier==(FILE*)NULL) {
    return(0);
    }
 
 // Lit l'entete du fichier
  fseek(fichier,0,0);
  if (fread(entete,1,54,fichier)!=54) {
    return(0);
    }
  if (entete[0]!='B' || entete[1]!='M') {
    return(0);
    }
 
 // Récupère les infos de l'image
  largeur_texture = entete[21]<<24 | entete[20]<<16 | entete[19]<<8 | entete[18];
  hauteur_texture = entete[25]<<24 | entete[24]<<16 | entete[23]<<8 | entete[22];
 
  nb_pixels=largeur_texture*hauteur_texture;
  taille_donnees_24=nb_pixels*3;
  taille_donnees_32=nb_pixels*4;
  taille_donnees_fichier=largeur_texture*3;
  complement=taille_donnees_fichier & 3;
  if (complement>0) {
    complement=4-complement;
    taille_donnees_fichier=taille_donnees_fichier + complement; // pour une ligne
    }
  taille_donnees_fichier=taille_donnees_fichier * hauteur_texture; // pour toutes les lignes
 
  position_donnees=54;
 
 // Charge l'image
  if (Image_TMP!=(GLubyte*)NULL) {
    free(Image_TMP);
    }
  if (Image_TMP!=(GLubyte*)NULL) {
    return(0);
    }
  Image_TMP=(GLubyte*)malloc(sizeof(GLubyte)*taille_donnees_24);
  if (Image_TMP==(GLubyte*)NULL) {
    return(0);
    }
 
  fseek(fichier,position_donnees,0);
  if (fread(Image_TMP,1,taille_donnees_24,fichier)!=taille_donnees_24) {
    free(Image_TMP);
    fclose(fichier);
    return(0);
    }
 
  fclose(fichier);
 
 // prépare la texture [tampon]
  if (Texture_TMP!=(GLubyte*)NULL) {
    free(Texture_TMP);
 Texture_TMP=(GLubyte*)NULL;
    }
 // free ne fonctionne pas !!!
  if (Texture_TMP!=(GLubyte*)NULL) {
    return(0);
    }
  Texture_TMP=(GLubyte*)malloc(sizeof(GLubyte)*taille_donnees_32);
  if (Texture_TMP==(GLubyte*)NULL) {
    return(0);
    }
 
 // transfert du format bmp au rgba : BGR -> RGBA
 // attention chaque ligne du fichier bmp a une longueur multiple de 4
 // si ce n'est pas le cas de l'image des octets sont ajoutés en fin
  int taille_ligne=(largeur_texture*3)+complement;
  int position_TMP=taille_ligne*(hauteur_texture-1); // dernière ligne
  int position=0;
  int position_pixels=0;
  int nb_ligne=2;
 
  for (int i=0;i<nb_pixels;i++) {
    Texture_TMP[position  ]=Image_TMP[position_TMP+2];
    Texture_TMP[position+1]=Image_TMP[position_TMP+1];
    Texture_TMP[position+2]=Image_TMP[position_TMP  ];
    Texture_TMP[position+3]=255;
    position=position+4;
    position_TMP=position_TMP+3;
    position_pixels++;
    if (position_pixels>=largeur_texture) {
      position_TMP=taille_ligne*(hauteur_texture-nb_ligne);
      nb_ligne++;
      position_pixels=0;
      }
    }
 
 // fin
  free(Image_TMP);
  return(1);
}
// -----------------------------------------------------------------------------
 
sauvegarde :
 
// -----------------------------------------------------------------------------
// Enregistre une image dans un fichier : format bmp
int Save_BMP_Ex(char* nom_fichier,int largeur,int hauteur,GLubyte* mem) {
 // Fichier bmp non compressé 24bits
  FILE*         fichier;
  int           position_tampon=54;
  int           position_image=0;
  int           taille_donnees_fichier=0;
  int           complement=0;
  GLubyte*      tampon=(GLubyte*)NULL;
 
 // initialisation des données
  complement=(largeur*3)%4;
  if (complement>0) {
    complement=4-complement;
    }
  taille_donnees_fichier=54+((largeur*3)+complement)*hauteur;
 
 // création du tampon
  tampon=(GLubyte*)malloc(sizeof(GLubyte)*taille_donnees_fichier);
  if (tampon==(GLubyte*)NULL) {
    return(0);
    }
 
 // remlissage du tampon
 // entete
  tampon[ 0]='B';
  tampon[ 1]='M';
 // taille du fichier
  tampon[ 2]=taille_donnees_fichier & 255;
  tampon[ 3]=(taille_donnees_fichier >> 8) & 255;
  tampon[ 4]=(taille_donnees_fichier >> 16) & 255;
  tampon[ 5]=(taille_donnees_fichier >> 24) & 255;
 // inutilisé
  tampon[ 6]=0;
  tampon[ 7]=0;
  tampon[ 8]=0;
  tampon[ 9]=0;
 // adresse des données
  tampon[10]=54;
  tampon[11]=0;
  tampon[12]=0;
  tampon[13]=0;
 // taille de l'entete
  tampon[14]=40;
  tampon[15]=0;
  tampon[16]=0;
  tampon[17]=0;
 // taille image : largeur et hauteur
  tampon[18]=largeur & 255;
  tampon[19]=(largeur >> 8) & 255;
  tampon[20]=(largeur >> 16) & 255;
  tampon[21]=(largeur >> 24) & 255;
  tampon[22]=hauteur & 255;
  tampon[23]=(hauteur >> 8) & 255;
  tampon[24]=(hauteur >> 16) & 255;
  tampon[25]=(hauteur >> 24) & 255;
 // nombre de plan
  tampon[26]=1;
  tampon[27]=0;
 // nombre de couleur
  tampon[28]=24; // 24 bits
  tampon[29]=0;
 // format de compression (aucune=0)
  tampon[30]=0;
  tampon[31]=0;
  tampon[32]=0;
  tampon[33]=0;
 // taille de l'image : ta mère
  tampon[34]=0;
  tampon[35]=0;
  tampon[36]=0;
  tampon[37]=0;
 // resolution horizontale : 2834ppm
  tampon[38]=18;
  tampon[39]=11;
  tampon[40]=0;
  tampon[41]=0;
 // resolution verticale : 2834ppm
  tampon[42]=18;
  tampon[43]=11;
  tampon[44]=0;
  tampon[45]=0;
 // nombre de couleurs utilisées : ?
  tampon[46]=0;
  tampon[47]=0;
  tampon[48]=0;
  tampon[49]=0;
 // nombre de couleurs importantes : ?
  tampon[50]=0;
  tampon[51]=0;
  tampon[52]=0;
  tampon[53]=0;
 // image
  for (int i=0;i<hauteur;i++) {
    for (int j=0;j<largeur;j++) {
      tampon[position_tampon  ]=mem[position_image+2];
      tampon[position_tampon+1]=mem[position_image+1];
      tampon[position_tampon+2]=mem[position_image  ];
      position_tampon=position_tampon+3;
      position_image=position_image+3;
      }
    position_tampon=position_tampon+complement;
    }
 
 // Ouverture du fichier
  fichier = fopen(nom_fichier,"wb" );
  if (fichier==(FILE*)NULL) {
    free(tampon);
    return(0);
    }
 
 // Ecriture du fichier
  fseek(fichier,0,0);
  if (fwrite(tampon,1,taille_donnees_fichier,fichier)!=taille_donnees_fichier) {
    free(tampon);
    return(0);
    }
 
 // fin
  free(tampon);
  fclose(fichier);
  return(1);
}
//------------------------------------------------------------------------------
 
voila ca ca marche j'ai testé

http://philgauthier.free.fr/filtre.zip
J'ai fais une fonction qui lit les bmp 24bits noncompressé.
Attention suivant les dimentions de l'image, il y a un nombre variable d'octets qui délimitent les lignes varie, ce qui produit un décalage à chaque ligne si on en tient pas compte.
T'as qu'a tester mon prog sur les 2 images voir s'il y a le même bug. Si mon prog marche correct tu regardes les sources.