Les entrées/sorties GD2
La gestion du format GD2 par LibGD permet de manipuler des images dans un format natif, compact et optimisé pour un entreposage et une récupération rapide. Le format GD2 est une version améliorée du format GD, introduisant des fonctionnalités supplémentaires comme la gestion des sous-images, ce qui est utile pour travailler avec des images très larges ou des régions spécifiques. Le format GD2 est principalement utilisé dans des contextes où l'efficacité est une priorité, comme les systèmes embarqués ou les environnements à ressources limitées.
La fonction gdImageCreateFromGd2 permet de charger une image au format GD2 à partir d'un fichier. Elle lit les données d'un fichier GD2 existant, crée une nouvelle image dans LibGD et permet ainsi de manipuler ou de convertir l'image dans d'autres formats. Ce type d'opération est particulièrement utile lorsqu'un système repose sur ce format pour stocker ses images tout en souhaitant les transformer ou les exporter vers des formats standards comme PNG ou JPEG.
De manière similaire, la fonction gdImageCreateFromGd2Ptr permet de charger une image au format GD2 directement à partir de données en mémoire. Cela peut être pratique pour traiter des données transmises via un réseau ou provenant de sources non traditionnelles, sans avoir besoin de passer par un fichier intermédiaire. La manipulation en mémoire est souvent utilisée pour optimiser les performances dans des applications Web ou des API de traitement d'images.
Pour enregistrer des images au format GD2, LibGD fournit la fonction gdImageGd2. Celle-ci écrit une image dans un fichier au format GD2, en permettant de spécifier le niveau de compression et la taille des blocs utilisés. Ces options permettent d'ajuster le format à des besoins spécifiques, comme réduire la taille des fichiers ou améliorer la rapidité d'accès. En résumé, les fonctionnalités GD2 IO de LibGD offrent une solution puissante et flexible pour manipuler des images dans un format compact, tout en assurant une compatibilité avec les fonctionnalités avancées de la bibliothèque.
Le format d'image GD2 est un format d'image propriétaire de libgd. Il doit être considéré comme obsolète et ne doit être utilisé qu'à des fins de développement et de test.
Structure d'un fichier image GD2
- Entête de fichier
- entêtes de bloc (uniquement pour les données compressées)
- entête de couleur (en couleurs vraies ou en palette)
- blocs de données d'image (bloc-ligne-majeur, de haut en bas, de gauche à droite)
Tous les nombres sont entreposés au format big-endian.
Structure de l'entête du fichier
| Champ | Taille |
|---|---|
| signature | 4 octets (toujours « gd2\0 ») |
| version | 1 mot (par exemple « \0\002 ») |
| width | 1 mot |
| height | 1 mot |
| chunk_size | 1 mot |
| format | 1 mot |
| x_chunk_count | 1 mot |
| y_chunk_count | 1 mot |
Formats reconnus
| Valeur | Description |
|---|---|
| 1 | Données d'image de palette brutes |
| 2 | Données d'image de palette compressées |
| 3 | Données d'image en couleurs vraies brutes |
| 4 | Données d'image en couleurs vraies compressées |
Entête de bloc
| Champ | Taille |
|---|---|
| offset | 1 double mot |
| size | 1 double mot |
Il existe des entêtes de bloc x_chunk_count * y_chunk_count.
Entête couleur de l'image Truecolor
| Champ | Taille |
|---|---|
| truecolor | 1 octet (toujours «\001») |
| transparent | 1 dword (couleur ARGB); « \377\377\377\377 » signifie qu'aucune couleur transparente n'est définie |
Entête de couleur de l'image de la palette
| Champ | Taille |
|---|---|
| truecolor | 1 octet (toujours «\0») |
| count | 1 mot (le nombre de couleurs de palette utilisées) |
| transparent | 1 double mot (index de palette) ; «\377\377\377\377» signifie qu'aucune couleur transparente n'est définie. |
| palette | 256 doubles mots (couleurs RGBA) |
Structure des blocs
Données de pixels séquentielles d'une zone rectangulaire (chunk_size x chunk_size), rangée principale de haut en bas, de gauche à droite :
- 1 octet par pixel pour les images en palette
- 1 double mot (ARGB) par pixel pour les images en vraies couleurs
Selon le format, le bloc peut être compressé en ZLIB.
Les fonctions
Voici les fonctions proposé par LibGD pour le GD2 IO :
| Nom | Description |
|---|---|
| gdImageCreateFromGd2 | Cette fonction est utilisée pour charger une image complète depuis un fichier au format GD2. Elle lit le fichier GD2 spécifié et crée une image en mémoire, pouvant ensuite être manipulée par d'autres fonctions de la bibliothèque. C'est une méthode courante pour travailler avec des fichiers GD2 entreposés sur le disque. |
| gdImageCreateFromGd2Ptr | Cette fonction permet de charger une image GD2 à partir d'un bloc de mémoire (plutôt que depuis un fichier). Cela est particulièrement utile lorsqu'une image GD2 est reçue via un réseau ou entreposée dans un tampon mémoire, évitant ainsi de devoir écrire le fichier sur le disque pour le lire. |
| gdImageCreateFromGd2Ctx | Avec cette fonction, une image GD2 est chargée via une structure gdIOCtx, qui est un contexte d'entrée/sortie abstrait. Cela permet de personnaliser la manière dont les données GD2 sont lues, par exemple à partir de sockets, flux ou systèmes de fichiers non standard. |
| gdImageCreateFromGd2Part | Cette fonction permet de charger une partie spécifique d'une image GD2 à partir d'un fichier. Cela est particulièrement utile pour manipuler des régions spécifiques d'une image très large sans avoir à charger l'image entière en mémoire, ce qui économise des ressources. |
| gdImageCreateFromGd2PartPtr | Similaire à gdImageCreateFromGd2Part, mais cette version travaille avec des données stockées dans un bloc mémoire. C'est une alternative puissante pour extraire des sous-images directement depuis des tampons de données sans intermédiaire fichier. |
| gdImageCreateFromGd2PartCtx | Cette fonction fonctionne comme gdImageCreateFromGd2Part, mais utilise un contexte gdIOCtx pour lire les données. Cela permet de lire une partie d'une image GD2 à partir de sources de données non standard (par exemple, des flux de données en continu). |
| gdImageGd2 | Cette fonction est utilisée pour enregistrer une image au format GD2 dans un fichier. Vous pouvez configurer certains paramètres, comme la taille des blocs ou le niveau de compression, ce qui rend cette méthode flexible pour différents cas d'utilisation. |
| gdImageGd2Ptr | Cette variante de gdImageGd2 écrit l'image GD2 dans un tampon mémoire au lieu d'un fichier. Cela permet de transmettre directement l'image, par exemple via des sockets ou des API, sans avoir besoin d'un fichier intermédiaire. |
gdImageCreateFromGd2
| gdImagePtr gdImageCreateFromGd2( FILE * inFile) |
gdImageCreateFromGd2 est appelé pour charger des images à partir de fichiers au format gd2. Appelez gdImageCreateFromGd2 avec un pointeur déjà ouvert vers un fichier contenant l'image souhaitée au format de fichier gd2, étant spécifique à gd2 et destiné au chargement rapide de parties d'images volumineuses. (Il s'agit d'un format compressé, mais généralement pas aussi bon que la compression maximale de l'image entière.)
gdImageCreateFromGd2 renvoie un gdImagePtr à la nouvelle image, ou NULL s'il est impossible de charger l'image (le plus souvent parce que le fichier est corrompu ou ne contient pas d'image au format gd). gdImageCreateFromGd2 ne ferme pas le fichier. Vous pouvez inspecter les membres sx et sy de l'image pour déterminer sa taille. L'image doit éventuellement être détruite à l'aide de gdImageDestroy.
Variantes
- gdImageCreateFromGd2Ptr crée une image à partir de données GD (c'est-à-dire le contenu d'un fichier GD2) déjà en mémoire.
- gdImageCreateFromGd2Ctx lit une image à l'aide des fonctions d'une structure gdIOCtx.
Paramètre
| Nom | Description |
|---|---|
| infile | Ce paramètre permet d'indiquer le pointeur de fichier d'entrée. |
Retour
| Valeur | Description |
|---|---|
| Pointeur | Un pointeur vers la nouvelle image ou NULL si une erreur s'est produite. |
Exemple
gdImageCreateFromGd2Ptr
| gdImagePtr gdImageCreateFromGd2Ptr(int size, void * data); |
Paramètre
| Nom | Description |
|---|---|
| size | Ce paramètre permet d'indiquer la taille des données GD2 en octets. |
| data | Ce paramètre permet d'indiquer les données GD2 (c'est-à-dire le contenu d'un fichier GIF). |
Voir gdImageCreateFromGd2.
gdImageCreateFromGd2Ctx
| gdImagePtr gdImageCreateFromGd2Ctx(gdIOCtxPtr in); |
Cette fonction permet de lire une image GD2 via une structure gdIOCtx. Voir gdImageCreateFromGd2.
gdImageCreateFromGd2Part
| gdImagePtr gdImageCreateFromGd2Part(FILE * inFile, int srcx, int srcy, int w, int h); |
gdImageCreateFromGd2Part est appelé pour charger des parties d'images à partir de fichiers au format gd2. Appelé de la même manière que gdImageCreateFromGd2, mais avec des paramètres supplémentaires indiquant la source (x, y) et la largeur/hauteur de l'image souhaitée. gdImageCreateFromGd2Part renvoie un gdImagePtr vers la nouvelle image, ou NULL s'il est impossible de charger l'image. L'image doit éventuellement être détruite à l'aide de gdImageDestroy.
Variantes
gdImageCreateFromGd2PartPtr crée une image à partir de données GD2 (c'est-à-dire le contenu d'un fichier GD2) déjà en mémoire.
gdImageCreateFromGd2Ctx lit une image à l'aide des fonctions d'une structure gdIOCtx.
Paramètre
| Nom | Description |
|---|---|
| infile | Ce paramètre permet d'indiquer le pointeur de fichier d'entrée. |
| srcx, srcy | Ces paramètres permettent d'indiquer les coordonnées X et Y de la source. |
| w, h | Ces paramètres permettent d'indiquer la largeur et la hauteur de l'image résultante. |
Retour
| Valeur | Description |
|---|---|
| Pointeur | Un pointeur vers la nouvelle image ou NULL si une erreur s'est produite. |
gdImageCreateFromGd2PartPtr
| gdImagePtr gdImageCreateFromGd2PartPtr(int size, void * data, int srcx, int srcy, int w, int h) |
Paramètre
| Nom | Description |
|---|---|
| size | Ce paramètre permet d'indiquer la taille des données GD en octets. |
| data | Ce paramètre permet d'indiquer les données GD (c'est-à-dire le contenu d'un fichier GIF). |
| srcx, srcy | Ces paramètres permettent d'indiquer les coordonnées X et Y de la source. |
| w, h | Ces paramètres permettent d'indiquer la largeur et la hauteur de l'image résultante. |
Cette fonction permet de lire une partie d'un fichier image GD2 entreposé en mémoire. Voir gdImageCreateFromGd2Part.
gdImageCreateFromGd2PartCtx
| gdImagePtr gdImageCreateFromGd2PartCtx(gdIOCtx * in, int srcx, int srcy, int w, int h); |
Paramètre
| Nom | Description |
|---|---|
| in | Ce paramètre permet d'indiquer la source des données. |
| srcx, srcy | Ces paramètres permettent d'indiquer les coordonnées X et Y de la source. |
| w, h | Ces paramètres permettent d'indiquer la largeur et la hauteur de l'image résultante. |
Cette fonction permet de lire une partie d'un fichier image de données GD2 via une structure gdIOCtx. Voir gdImageCreateFromGd2Part.
gdImageGd2
| void gdImageGd2(gdImagePtr im, FILE * outFile, int cs, int fmt); |
Cette fonction est utilisée pour enregistrer une image au format GD2 dans un fichier. Vous pouvez configurer certains paramètres, comme la taille des blocs ou le niveau de compression, ce qui rend cette méthode flexible pour différents cas d'utilisation.
gdImageGd2Ptr
| void * gdImageGd2Ptr(gdImagePtr im, int cs, int fmt, int *size); |
Cette variante de gdImageGd2 écrit l'image GD2 dans un tampon mémoire au lieu d'un fichier. Cela permet de transmettre directement l'image, par exemple via des sockets ou des API, sans avoir besoin d'un fichier intermédiaire.