Charger des images PNG

Tout d'abord, nous devons ouvrir le fichier :

FILE *fp;
png_byte magic[8];
/* open image file */
fp = fopen (filename, "rb");
if (!fp)
  {
    fprintf (stderr, "error: couldn't open \"%s\"!\n", filename);
    return NULL;
  }
/* read magic number */
fread (magic, 1, sizeof (magic), fp);
/* check for valid magic number */
if (!png_check_sig (magic, sizeof (magic)))
  {
    fprintf (stderr, "error: \"%s\" is not a valid PNG image!\n",
             filename);
    fclose (fp);
    return NULL;
  }

Les huit premiers octets d'un fichier PNG contiennent un numéro magique servant à authentifier qu'il s'agit d'un fichier PNG. Si ces huit octets ne correspondent pas à la signature d'un fichier PNG, inutile de continuer. La fonction png_check_sig() de libpng permet de tester si une chaîne contient bien la signature d'un fichier PNG.

Maintenant que l'on s'est assuré qu'il s'agit bien d'un fichier PNG, on peut créer nos deux structures png_struct et png_info. Les fonctions png_create_read_struct () et png_create_info_struct () se chargent de ça :

/* create a png read struct */
png_structp png_ptr = png_create_read_struct
  (PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
if (!png_ptr)
  {
    fclose (fp);
    return NULL;
  }
/* create a png info struct */
png_infop info_ptr = png_create_info_struct (png_ptr);
if (!info_ptr)
  {
    fclose (fp);
    png_destroy_read_struct (&png_ptr, NULL, NULL);
    return NULL;
  }

Tout d'abord, vous devez remarquer que l'on utilise le type png_structp au lieu de png_struct comme je l'ai dit plus haut. En fait, png_structp est définie comme étant un pointeur sur un png_struct. png_ptr est donc un pointeur sur un png_struct. Il en est de même pour info_ptr qui est un pointeur sur un png_info.

La fonction png_create_read_struct () prend quatre paramètres. Le premier est la version de la bibliothèque. La macro PNG_LIBPNG_VER_STRING permet de passer la version de la bibliothèque avec laquelle on compile le programme. Les trois autres paramètres (optionnels) servent à définir les fonctions à utiliser pour la gestion des erreurs ; nous les verrons plus tard, en étudiant la seconde méthode de lecture d'une image PNG. Pour le moment, on peut les laisser à NULL.

La fonction png_create_info_struct () ne nécessite que notre objet png_struct en paramètre. En cas d'échec, on détruit nos structures avec png_destroy_read_struct (). Cette fonction prend en premier paramètre un png_struct (impérativement non nul) et en second un png_info. Le dernier paramètre est aussi une structure png_info que nous n'utiliserons pas ici.

Il est également temps de créer un objet de type gl_texture_t pour stocker les informations et données nécessaires à la création de notre texture :

/* create our OpenGL texture object */
gl_texture_t *texinfo = (gl_texture_t *)malloc (sizeof (gl_texture_t));

libpng utilise le mécanisme de setjmp/longjmp pour la gestion des erreurs. setjmp() et longjmp() sont des fonctions système qui proposent un mécanisme similaire aux exceptions en C++. setjmp() permet de sauvegarder le contexte de la pile à un endroit donné. longjmp() permet de faire un saut vers un contexte de pile sauvegardé par setjmp().

La fonction setjmp() renvoie 0 lorsqu'elle revient directement et une valeur non nulle lorsqu'elle revient à travers un appel à longjmp().

La structure png_struct possède une variable de type jmp_buf permettant de mémoriser un contexte (la destination d'un saut via longjmp()) pour y revenir en cas d'erreur lors de la manipulation des images. On y accède à l'aide de la fonction png_jmpbuf().

Il faut placer cette destination de saut avant le début du traitement de l'image et gérer l'interruption de la lecture en cas d'erreur  :

/* initialize the setjmp for returning properly after a libpng
   error occured */
if (setjmp (png_jmpbuf (png_ptr)))
  {
    fclose (fp);
    png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
    if (texinfo)
      {
        if (texinfo->texels)
          free (texinfo->texels);
        free (texinfo);
      }
    return NULL;
  }

Lorsque libpng rencontre une erreur, il exécute un saut via longjmp() à cet endroit et se retrouve donc à l'intérieur du bloc if. On peut ainsi détruire les structures proprement et désallouer la mémoire utilisée pour la texture.

Remarque : si vous omettez de placer le setjmp(), libpng appellera alors abord() qui procèdera à la terminaison de votre programme. Ce n'est probablement pas un comportement souhaité pour votre application.

libpng doit connaître la source de lecture du fichier. Il est possible de gérer soi-même la lecture des données, depuis une source quelconque. libpng propose par défaut de lire l'image depuis un fichier en utilisant la fonction standard fread(). Pour cela, il faut lui spécifier le pointeur de fichier avant de commencer la lecture :

/* setup libpng for using standard C fread() function
   with our FILE pointer */
png_init_io (png_ptr, fp);
/* tell libpng that we have already read the magic number */
png_set_sig_bytes (png_ptr, sizeof (magic));

La fonction png_init_io() permet de passer notre pointeur de fichier à la structure png_struct. On spécifie ensuite à libpng le nombre d'octets déjà lus dans le fichier à l'aide de la fonction png_set_sig_bytes (). Rappelez-vous, on a déjà lu huit octets pour la signature du fichier. libpng sait ainsi qu'il ne faut pas relire la signature.

Il est à présent possible de commencer à lire le fichier. Commençons par les informations stockées dans notre png_info :

/* read png info */
png_read_info (png_ptr, info_ptr);

Le format PNG peut contenir des images avec palette de couleurs, en dégradé de gris et en couleurs vraies. On utilisera les formats GL_RGB et GL_RGBA pour les textures en couleurs vraies et GL_LUMINANCE et GL_LUMINANCE_ALPHA pour les images en dégradé de couleurs. On peut spécifier à libpng un certain nombre de transformations de l'image source avant de commencer la lecture. Récupérons d'abord le nombre de bits par pixel et le type d'image stockée dans le fichier PNG (PNG_COLOR_TYPE_GRAY, PNG_COLOR_TYPE_RGB, etc.) :

int bit_depth, color_type;
/* get some usefull information from header */
bit_depth = png_get_bit_depth (png_ptr, info_ptr);
color_type = png_get_color_type (png_ptr, info_ptr);

Il est nécessaire de transformer les images en palette de couleurs en images de couleurs vraies :

/* convert index color images to RGB images */
if (color_type == PNG_COLOR_TYPE_PALETTE)
  png_set_palette_to_rgb (png_ptr);

Certaines images en dégradé de gris peuvent être codées sur 1, 2 ou 4 bits. Il faut les étendre à du 8 bits pour pouvoir ensuite les utiliser avec OpenGL avec le format GL_LUMINANCE :

/* convert 1-2-4 bits grayscale images to 8 bits
   grayscale. */
if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)
  png_set_gray_1_2_4_to_8 (png_ptr);
if (png_get_valid (png_ptr, info_ptr, PNG_INFO_tRNS))
  png_set_tRNS_to_alpha (png_ptr);

Certaines images peuvent stocker un canal de couleur sur 16 bits qu'il faut alors ramener à 8 bits. De même, certaines images en 1, 2 ou 4 bits peuvent coder plusieurs canaux sur un octet (afin de gagner en mémoire utilisée) qu'il faut étendre à un octet par canal. libpng permet d'effectuer ces opérations sans perdre d'information sur les pixels :

if (bit_depth == 16)
  png_set_strip_16 (png_ptr);
else if (bit_depth < 8)
  png_set_packing (png_ptr);

Les images avec palette sont ainsi converties en images en couleurs vraies ou en images avec dégradé de gris sans palette. Chaque canal de couleur (rouge, vert, bleu, luminance, alpha) sera codé sur 8 bits. Il reste à valider ces transformations avec la fonction png_read_update_info() :

/* update info structure to apply transformations */
png_read_update_info (png_ptr, info_ptr);

Ces transformations seront appliquées lors de la lecture de l'image depuis le fichier. L'image source (stockée dans le fichier) ne sera pas modifiée. Mais l'image résultante (que l'on aura en mémoire) ne sera donc pas forcément exactement la même.

Après avoir spécifié les transformations voulues, nous pouvons récupérer les informations sur l'image résultante afin d'initialiser les variables de notre structure gl_texture_t. La fonction png_get_IHDR() nous permet de récupérer directement les dimensions de l'image, le nombre de bits par pixel et le type d'image PNG :

/* retrieve updated information */
png_get_IHDR (png_ptr, info_ptr,
              (png_uint_32*)(&texinfo->width),
              (png_uint_32*)(&texinfo->height),
              &bit_depth, &color_type,
              NULL, NULL, NULL);

Il ne nous reste plus que le format et le nombre d'octets par pixel (le « internal format » nécessaire à glTexImage2D()) à retrouver, que l'on peut facilement déduire à partir du type d'image PNG :

switch (color_type)
  {
  case PNG_COLOR_TYPE_GRAY:
    texinfo->format = GL_LUMINANCE;
    texinfo->internalFormat = 1;
    break;
  case PNG_COLOR_TYPE_GRAY_ALPHA:
    texinfo->format = GL_LUMINANCE_ALPHA;
    texinfo->internalFormat = 2;
    break;
  case PNG_COLOR_TYPE_RGB:
    texinfo->format = GL_RGB;
    texinfo->internalFormat = 3;
    break;
  case PNG_COLOR_TYPE_RGB_ALPHA:
    texinfo->format = GL_RGBA;
    texinfo->internalFormat = 4;
    break;
  default:
    /* Badness */
    break;
  }

Nous sommes à présent prêt pour lire les données pixels de l'image. Commençons par allouer de la mémoire pour les stocker dans notre gl_texture_t :

/* we can now allocate memory for storing pixel data */
texinfo->texels = (GLubyte *)malloc (sizeof (GLubyte) * texinfo->width
             * texinfo->height * texinfo->internalFormat);

La lecture de l'image se fait à l'aide de la fonction png_read_image(). Cette fonction attend en paramètre notre objet png_struct et un tableau de pointeurs pointant sur chacune des lignes de pixels de l'image.

On accède simplement au début d'une ligne de pixels de l'image avec l'instruction suivante :

row_pointers[i] = texinfo->texels[i * texinfo->width * texinfo->internalFormat];

Cependant le format PNG n'utilise pas le même système de coordonnées 2D. Le premier pixel d'une image PNG est situé dans le coin haut gauche, tandis qu'OpenGL situe le premier pixel dans le coin bas gauche. Il faut donc inverser verticalement l'image. Ceci peut se faire pendant la lecture de l'image en modifiant un peu notre tableau de pointeurs :

row_pointers[i] = texinfo->texels[(texinfo->height - (i + 1))
          * texinfo->width * texinfo->internalFormat];

La lecture des pixels donne donc ceci :

png_bytep *row_pointers;
/* setup a pointer array.  Each one points at the begening of a row. */
row_pointers = (png_bytep *)malloc (sizeof (png_bytep) * texinfo->height);
for (i = 0; i < texinfo->height; ++i)
  {
    row_pointers[i] = (png_bytep)(texinfo->texels +
      ((texinfo->height - (i + 1)) * texinfo->width * texinfo->internalFormat));
  }
/* read pixel data using row pointers */
png_read_image (png_ptr, row_pointers);
/* we don't need row pointers anymore */
free (row_pointers);

row_pointers est de type png_bytep, qui est un pointeur sur un octet. row_pointers est donc bien un tableau de pointeurs. Il faut aussi penser à le libérer dans le bloc if de setjmp().

png_read_image() va ainsi remplir notre tableau texinfo->texels via le tableau de pointeurs.

Nous avons lu et stocké notre image dans un format qui nous permettra ensuite de créer une texture OpenGL. Il faut terminer la lecture de l'image et détruire proprement les structures allouées pour le décodage de l'image :

/* finish decompression and release memory */
png_read_end (png_ptr, NULL);
png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
fclose (fp);

On peut maintenant utiliser la structure gl_texture_t pour créer une texture OpenGL. Vous pouvez récupérer le code source complet de cette méthode de lecture depuis un fichier : png.c (9,0 Ko). Nous allons maintenant voir une autre méthode de lecture : depuis une zone mémoire où l'intégralité du fichier PNG est stockée.

Commençons par définir une structure qui contiendra les données d'un fichier en mémoire :

/* file buffer struct */
typedef struct
{
  char name[256];
  unsigned char *data;
  long length;
  long offset;
} file_buffer_t;

Cette structure contient le nom du fichier (name), ses données (data), la taille du fichier en octets (length) et une variable offset indiquant la position actuelle dans le fichier (utile pour la lecture).

Voyons rapidement la lecture d'un fichier dans une structure file_buffer_t :

file_buffer_t *
readFile (const char *filename)
{
  file_buffer_t *file;
  FILE *fp;
 
  /* open file */
  fp = fopen (filename, "rb");
  if (!fp)
    {
      fprintf (stderr, "error: couldn't open \"%s\"!\n", filename);
      return NULL;
    }
 
  /* create a file buffer */
  file = (file_buffer_t *)malloc (sizeof (file_buffer_t));
  if (!file)
    {
      fprintf (stderr, "Error: memory allocation failed "
           "for \"%s\"\n", filename);
      fclose (fp);
      return NULL;
    }
  /* copy file name */
  strncpy (file->name, filename, sizeof (file->name));
  /* get file length */
  fseek (fp, 0, SEEK_END);
  file->length = ftell (fp);
  file->offset = 0;
  fseek (fp, 0, SEEK_SET);
  /* allocate memory for file data */
  file->data = (unsigned char *)malloc (file->length);
  if (!file->data)
    {
      fprintf (stderr, "Error: memory allocation failed "
           "for \"%s\"\n", filename);
      fclose (fp);
      free (file);
      return NULL;
    }
  /* read whole file data */
  fread (file->data, 1, file->length, fp);
  fclose (fp);
  return file;
}

Cette fonction est assez simple. Elle crée une structure file_buffer_t et ouvre le fichier. Ensuite elle calcule la taille du fichier pour allouer assez d'espace afin de stocker le fichier tout entier en mémoire, puis lit le fichier. Elle retourne l'objet file_buffer_t créé et initialisé.

Nous allons modifier un peu notre fonction de lecture d'une image PNG. Voici le prototype de notre nouvelle fonction :

gl_texture_t *ReadPNGFromMemory (const file_buffer_t *file);

Le contenu de cette fonction sera sensiblement le même que celui de ReadPNGFromFile(), je ne vais donc pas tout recopier.

On peut commencer déjà par supprimer tout ce qui concerne l'ouverture du fichier, puisque nous traitons avec le contenu du fichier directement. La vérification de la signature du fichier est légèrement modifiée comme suit :

/* check for valid magic number */
if (!png_check_sig (file->data, 8))
  {
    fprintf (stderr, "error: \"%s\" is not a valid PNG image!\n",
             file->name);
    return NULL;
  }

On compare directement avec les huit premiers octets du buffer. Mais il ne s'agit pas ici d'une grosse modification, simplement d'une adaptation du code.

La seule modification réside dans la manière de lire les données de l'image source. Rappelez-vous dans ReadPNGFromFile(), on avait passé à libpng notre pointeur sur fichier afin qu'il utilise les fonctions d'entrée/sortie standards. Nous pouvons spécifier à libpng la fonction à appeler pour lire un bloc de données avec png_set_read_fn(). Cette fonction prend en paramètre un pointeur sur les données source (ici ce sera notre file_buffer_t) et un pointeur sur une fonction dont le prototype est :

void user_read_data (png_structp png_ptr, png_bytep data, png_size_t length);

Les données source que vous passez à png_set_read_fn() peuvent être ce que vous voulez, puisque c'est vous qui les manipulerez dans votre fonction « user_read_data() ».

Cette fonction user_read_data() attend que length octets soient copiés depuis la source dans data. Dans notre cas, on peut donc l'écrire ainsi :

void
png_read_from_mem (png_structp png_ptr, png_bytep data, png_size_t length)
{
  file_buffer_t *src = (file_buffer_t *)png_get_io_ptr (png_ptr);
  /* copy data from image buffer */
  memcpy (data, src->data + src->offset, length);
  /* advance in the file */
  src->offset += length;
}

La fonction png_get_io_ptr() nous permet de récupérer le pointeur sur la source de données que l'on a passée à libpng au moment d'appeler png_set_read_fn(). On copie ensuite les données demandées dans data et on met à jour le curseur de position (offset).

Retournons à ReadPNGFromMemory(). Remplacer les instructions png_init_io(…) et png_set_sig_buytes(…) par le code suivant :

/* set "png_read" callback function and give source of data */
png_set_read_fn (png_ptr, (png_voidp *)file, png_read_from_mem);

file est notre objet file_buffer_t et png_read_from_mem() la fonction définie ci-dessus. Nous ne spécifions plus à libpng la lecture des huit premiers octets contenant la signature du fichier, car nous avons passé à libpng un pointeur sur le début des données du fichier (et non plus à l'adresse de base + 8). libpng devra donc les relire lui-même.

Il s'agit de l'unique modification de code pour charger une image PNG depuis une zone mémoire, le reste n'étant qu'une adaptation du code pour remplacer le pointeur sur fichier par notre objet file_buffer_t. Le fichier png_mem.c (11,0 Ko) contient le code complet de la fonction ReadPNGFromMemory(). Il contient également un exemple de gestion des erreurs personnalisée, que nous allons voir maintenant.