Gestion des ressources avec SDL via les SDL_RWops, en C++

Avant de pouvoir écrire le code, il faut décider une structure de l'entête. Nous allons utiliser la structure la plus simple :

La structure de l'entête

1. Le nombre de fichiers
2. La liste des noms de fichiers, point de départ et leur taille
3. Le contenu de chaque fichier

Voici la déclaration des structures mises en jeu :

#define TAILLE_NBR 7
typedef struct sEntete_interne_dep{
    unsigned char nbr_entrees[TAILLE_NBR];
}SEntete_interne;

#define TAILLE_NOM 32
#define TAILLE_POS 10
#define TAILLE_TAILLE 10
typedef struct sEntete_interne_elem{
    unsigned char nomFichier[TAILLE_NOM];
    unsigned char position[TAILLE_POS];
    unsigned char taille[TAILLE_TAILLE];
}SEntete_interne_elem;

Comme vous le voyez, l'entête est constitué de chaînes de caractères de longueurs fixes. Cela permet de savoir exactement sa taille. Le fichier commencera donc par un entier qui tiendra sur sept caractères. Cet entier correspond au nombre de fichiers dans l'archive. Ensuite, nous aurons une entrée par fichier. Chacune contiendra le nom du fichier, sa position et sa taille. Chaque élément de cet entête est rempli à droite par des espaces.

Pour trouver un fichier, il suffira donc de parcourir la liste des entrées et trouver le nom correspondant. Ensuite, nous aurons la position et la taille dans le fichier.

Nous continuerons cette partie en présentant le code pour créer facilement un fichier d'archive. Le code commence bien sûr par les inclusions habituelles :

#include <fstream>
#include <stdlib.h>
#include <string.h>
#include <iostream>
#include <sstream>

#include "gestionfich.h"

using namespace std;

Ensuite, nous avons écrit ce code simplement dans la fonction main vu sa complexité. Vous verrez qu'il n'y a pas grand-chose de plus simple. Nous commençons par vérifier le nombre d'arguments :

int main(int argc, char **argv)
{
    //On verifie le nombre d'arguments
    if(argc<=2) {
        cout << "Usage : " << argv[0] << " <Nom de l'archive> " << "<Fichier 1> [Fichier2]... [FichierN]" << endl;
        return EXIT_FAILURE;
    }

Ensuite, nous tentons d'ouvrir le fichier archive en écriture, si cela échoue, le programme sortira sans rien faire.

        //On tente d'ouvrir l'archive en ecriture
    ofstream output(argv[1], ios_base::binary);

    if(output != NULL) {

La première donnée dans le fichier sera le nombre de fichiers qu'il contient. Cela se fait simplement, il faut juste s'assurer d'avoir le bon nombre de caractères pour assurer un entête de taille fixe. On utilise donc la macro TAILLE_NBR et la fonction resize de la classe string.

           //Ecriture du nombre d'elements
        ostringstream oss;
        oss << (argc-2);
        string nombre = oss.str();
        nombre.resize(TAILLE_NBR, ' ');
        output << nombre;

Ensuite, nous devons calculer la position de départ du premier fichier. Il faut donc calculer la taille totale de l'entête. En effet, bien que les structures soient de tailles fixes, nous avons un certain nombre d'éléments dans l'entête. Il faudra donc calculer la taille dépendant de ce nombre :

        //Position de depart
        long pos = sizeof(SEntete_interne_elem)*(argc-2) + sizeof(SEntete_interne);

Une fois que nous avons la position de départ du premier fichier, nous pouvons écrire les entrées des fichiers contenus dans l'archive. Ceci commence par l'écriture du nom du fichier et de sa position. Ensuite, il faut calculer la taille du fichier et l'écrire à la suite. Il n'y a rien de spécial dans ce code, mais il faut simplement faire attention de mettre tous les éléments à la bonne taille. Comme avant, ceci se fait en ajoutant des espaces sur la droite de la chaîne de caractères. Il faut donc transformer la position et la taille en string.

        for(int i = 2 ; i < argc; i++) {
            //Ecriture du nom de fichier
            string nom(argv[i]);
            nom.resize(TAILLE_NOM, ' ');
            output << nom;

            //Ecriture de la position
            ostringstream osspos;
            osspos << pos;
            string strpos = sspos.str();
            strpos.resize(TAILLE_POS, ' ');
            output << strpos;

            //Ecriture de la taille du fichier a ajouter
            ifstream fich(argv[i]);
            if(fich == NULL) {
                cerr << "Erreur d'ouverture du fichier " << argv[i] << endl;
                output.close();
                return EXIT_FAILURE;
            }
            fich.seekg(0, ios_base::end);
            long taille = fich.tellg();

            //On augmente la position pour le prochain fichier
            pos += taille;
            fich.close();

            //On transforme la taille en chaine avant de l'ecrire                    
            ostringstream osstaille;
            osstaille << taille;
            string strtaille = osstaille.str();
            strtaille.resize(TAILLE_TAILLE, ' ');
            output << strtaille;
        }

Enfin, nous allons pouvoir écrire le contenu des fichiers. Ceci se fait très simplement en utilisant la fonction rdbuf de la classe ifstream.

        //Maintenant on ecrit les fichiers
        for(int i = 2 ; i < argc; i++) {
            ifstream input(argv[i]);
            if(input != NULL) {
                output << input.rdbuf();
            }
            input.close();
        }

Cela termine donc ce fichier d'archive, nous pouvons le fermer et sortir du programme.

        output.close();

    }
    
    return EXIT_SUCCESS;
}

Certes, ce petit programme est un peu naïf et l'entête n'est pas très intelligent, mais il suffit largement pour ce que nous voulons faire. Il va permettre à un programme de lire facilement les informations et récupérer les fichiers qu'il cherche. La prochaine section montre comment faire.

Vous trouverez le code source de création d'archive ici.

Enfin, pour créer notre archive, nous devons simplement faire cela :

creation archive.arc image1.bmp image2.bmp

Ceci va créer une archive archive.arc contenant les deux images BMP.

Pour simplifier encore plus le système nous allons écrire une classe qui se charge de donner le point de départ de chaque fichier, de charger en mémoire la zone si nécessaire, de libérer si elle n'est plus utilisée. Voici sa déclaration :

class GestionFich
{
    private:
        //Le fichier
        string nomarchive;

        //Entete
        SEntete *entete;
        int nbr_entrees;

        //Les elements
        map<string, SZone*> elements;

        //Fonctions privees
        //Fonction qui charge une zone, cree une structure SZone associee
        SZone *chercheZone(string);
        
    public :
        GestionFich();
        GestionFich(string nom);
        ~GestionFich();

        SDL_RWops* chargeZone(string);
        void libereZone(string);
};

Cette classe contient le nom de l'archive, un pointeur sur un tableau contenant toutes les informations des fichiers contenus dans l'archive (comme on a vu précédemment) et une map qui contiendra la correspondance entre le nom de fichier et la zone en mémoire où se trouve ce fichier.

Comme constructeur, cette classe accepte le constructeur vide et un constructeur qui donnera le nom de l'archive. Finalement, nous aurons deux fonctions : une pour chercher un nom de fichier et le mettre en mémoire et une fonction pour libérer la zone.

En principe, vous avez dû remarquer que le tableau des entêtes est de type SEntete, or la structure que j'ai présentée avant s'appelait SEntete_interne_elem. La raison est assez simple : même si notre entête est écrit en chaînes de caractères, cela ne nous oblige pas à nous en servir par la suite comme tel, nous utiliserons plutôt :

typedef struct sEntete {
    string nomFichier;
    long position;
    long taille;
}SEntete;

Cela rendra l'utilisation de cette archive plus facile. Enfin, la dernière structure à présenter s'appelle SZone, elle contient simplement la position en mémoire du fichier extrait de l'archive et sa taille.

typedef struct sZone {
    void *depart;
    long taille;
}SZone;

Les constructeurs de cette classe sont très simples : on initialise le nom de l'archive avec le nom passé en argument et on met le pointeur entete à NULL.

//Constructeurs
GestionFich::GestionFich()
{
    nomarchive = "Donnees.arc";
    entete = NULL;
}

GestionFich::GestionFich(string nom)
{
    nomarchive = nom;
    entete = NULL;
}

Le destructeur est un peu plus compliqué. En effet, on efface le tableau entete mais on doit aussi effacer la map elements.

Pour effacer la map, on utilise un itérateur et on récupère chaque pointeur de type SZone. Ensuite, on transtype en pointeur char* et on libère la zone et le pointeur vers la structure.

Finalement, on libère la mémoire en appelant la fonction clear.

//Destructeur
GestionFich::~GestionFich()
{
    delete[] entete;

    //On efface la map
    map<string, SZone*>::iterator iter;
    for(iter = elements.begin(); iter != elements.end(); iter++) {
        //On efface la zone
        SZone *tmp = iter->second;

        if(tmp != NULL) {
            char *donnees = reinterpret_cast<char*> (tmp->depart);
            delete[] donnees;
            delete tmp;
        }
    }
    //On libere la memoire
    elements.clear();
}

La fonction chargeZone est le point d'entrée de la classe GestionFich. C'est grâce à elle que nous allons récupérer un fichier dans une archive et la mettre en mémoire. Nous allons supposer que les fichiers récupérés sont supposés en lecture seule. Ceci nous permettra de stocker les informations du chargement des fichiers. Cela implique que si nous chargeons deux fois le même fichier, le système va le charger une seule fois et retournera deux fois les mêmes informations.

La fonction chargeZone est en fait une fonction qui retourne un pointeur vers une structure de type SDL_RWops. Elle appelle la fonction chercheZone qui va chercher dans la map la zone correspondante. Si la zone ne se trouve pas dans la map, elle la chargera en mémoire. Voici le code de cette fonction :

SDL_RWops* GestionFich::chargeZone(string nom)
{
    //On regarde dans la map d'abord
    SZone *tmp = chercheZone(nom);

    //Gestion de l'erreur
    if(tmp == NULL) {
        return NULL;
    }

    //Creer un SDL_RWops
    SDL_RWops *res = SDL_RWFromConstMem(tmp->depart, tmp->taille);
    return res;
}

En principe, il n'y a rien de très particulier. La fonction chercheZone retourne un pointeur vers une structure SZone. Ensuite, nous testons sa valeur avant de passer les informations à la fonction SDL_RWFromConstMem.

La fonction libereZone fait l'inverse. Elle prend le nom du fichier à libérer et cherche dans la map si une zone associée est en mémoire. Si c'est le cas, on la libère sinon on ne fait rien.

void GestionFich::libereZone(string nom)
{
    //On regarde dans la map 
    map<string,SZone*>::iterator iter = elements.find(nom);

    if(iter != elements.end()) {
        SZone *tmp = iter->second;
        //Gestion de l'erreur
        if(tmp != NULL) {
            //Liberation de la memoire
            unsigned char *ptr = (unsigned char*) tmp->depart;
            delete[] ptr;
            delete tmp;

            //On enleve de la map
            elements.erase(nom);
        }
    }
}

Nous arrivons enfin à la plus grande fonction de cette classe : chercheZone. C'est elle qui va devoir lire le fichier d'archive si la ressource recherchée n'est pas présente.

On commence donc par vérifier si la ressource est présente :

SZone *GestionFich::chercheZone(string nom)
{
    //On regarde dans la map d'abord
    map<string,SZone*>::iterator iter = elements.find(nom);

Si jamais l'élément n'est pas présent, on va devoir parcourir l'entête. Pour rendre plus efficace la recherche, nous chargeons en mémoire l'entête la première fois que nous cherchons une ressource. Ensuite, nous aurons le tableau directement en mémoire.

    if(iter == elements.end()) {
        //Si l'entete n'est pas encore charge
        if(entete==NULL) {
            //Ouverture du fichier
            ifstream fich(nomarchive.c_str(), ios::in|ios::binary);

            //Gestion de l'erreur
            if(fich == NULL) {
                return NULL;
            }

On commence par lire le nombre d'entrées et on va allouer le tableau entete. Vous remarquerez la facilité pour lire la chaîne de caractères que nous avions écrite pour ce nombre d'entrées. La classe ifstream la transforme directement en entier en ignorant les espaces que nous avions ajoutés.

            //Chargement de l'entete
            fich >> nbr_entrees;

            //Gestion de l'erreur
            if(nbr_entrees == 0) {
                return NULL;
            }

            //Allocation du tableau
            entete = new SEntete[nbr_entrees];

Une fois le tableau alloué, le reste est assez facile, nous parcourons l'entête et nous remplissons le tableau.

            //Lecture du fichier de l'entete
            for(int i=0;i<nbr_entrees;i++) {
                fich >> entete[i].nomFichier;
                fich >> entete[i].position;
                fich >> entete[i].taille;
            }            
            //Fermeture du fichier
            fich.close();
        }

Lorsque nous arrivons à ce point du code, nous savons que la ressource n'est pas encore en mémoire et que le tableau de l'entête l'est. Donc nous allons juste parcourir le tableau :

        //Parcourir le tableau
        for(int i=0; i < nbr_entrees; i++) {
            if(entete[i].nomFichier== nom) {

une zone mémoire pour la structure SZone et nous allons ouvrir le fichier. Ensuite, après avoir bien positionné le curseur et alloué un tableau assez grand, nous allons extraire le fichier.

                SZone *zone = new SZone;

                //Ouverture du fichier
                ifstream fich(nomarchive.c_str(), ios::in|ios::binary);

                //Cherche la position dans le fichier
                fich.seekg(entete[i].position, ios::beg);

                //Allocation d'une zone pour lire le fichier
                char* buf = new char[entete[i].taille];

                //Remplir la structure
                zone->depart = buf;
                zone->taille = entete[i].taille;

                //Copier la zone du fichier
                fich.read(buf, zone->taille);

                //Fermer le fichier
                fich.close();

La dernière étape consiste à ajouter la paire (nom du fichier, pointeur sur la zone) à la map elements et retourner la zone.

                //Ajoute au map
                elements.insert(make_pair(nom, zone));

                //Retourner le pointeur vers la structure
                return zone;
            }
        }
    }

Il nous reste le cas où la ressource était déjà chargée et le cas d'erreur. Ces deux cas sont simples :

    else {
        // On retourne l'element
        return iter->second;
    }

    //Sinon on n'a rien trouve
    return NULL;
}

Comme vous le voyez, cette fonction est assez grande, mais très simple. Nous chargeons l'entête la première fois et ensuite nous allons l'utiliser pour trouver la ressource si elle n'est pas déjà en mémoire.

Voici la déclaration de la classe :

class Gestionnaire
{
    private:
        GestionFich *gestion_entete;
        
    public:
        Gestionnaire();
        Gestionnaire(string nom);        
        ~Gestionnaire();

        SDL_Surface *chargeBMP(string nom);
        void libere(string nom);
};

Cette classe est relativement petite pour le moment puisque nous avons simplement besoin d'un type de ressource : des fichiers BMP. Mais lorsque vous voudrez des fichiers textes, des fichiers sons et des fichiers vidéo, cela risque de se remplir rapidement.

Finalement, nous avons une fonction chargeBMP qui retourne directement une SDL_Surface vers l'image voulue et une fonction libere qui va appeler la fonction libereZone de la classe GestionFich.

Le travail des constructeurs et du destructeur est simplement de créer et libérer une instance de type GestionFich.

Gestionnaire::Gestionnaire()
{
    gestion_entete = new GestionFich();
}

Gestionnaire::Gestionnaire(string nom)
{
    gestion_entete = new GestionFich(nom);
}

Gestionnaire::~Gestionnaire()
{
    delete gestion_entete;
}

Les fonctions chargeBMP et libere vont simplement faire le lien avec l'instance gestion_entete.

Certes, chargeBMP fait un peu plus, vu qu'il va créer une surface SDL_Surface en plus. Mais le code est relativement facile à comprendre :

SDL_Surface* Gestionnaire::chargeBMP(string nom)
{
    SDL_RWops *tmp = gestion_entete->chargeZone(nom);

    if(tmp != NULL) {
        return SDL_LoadBMP_RW(tmp, 1);
    }
    return NULL;
}

void Gestionnaire::libere(string nom)
{
    gestion_entete->libereZone(nom);
}