Bonjour,

étant entrain de développer un projet d'école avec la sdl (librairie qui m'est imposée, donc pas de sdl2) et en c, je dois à partir d'un dossier spécifié, afficher toutes les images qui y sont. J'ai déjà réussi à "pondre" un code permettant de le faire (il fonctionne en tant que fonction), néanmoins, pour une raison inconnue, le code plante au bout d'une vingtaines de secondes en fonction des images ciblées depuis un dossier. J'ai d'abord pensé que c'était lié au nombre d'image mais ça semble plutôt venir de la taille des images. Lorsque j'ai 22 images et qu'elles sont trop grandes, le code plante, ce qui n'est pas le cas lorsque j'ai 27 images et qu'elles sont plus petites. Donc, ma question est : comment réussir à allouer suffisamment de mémoire en fonction des dimensions des images ?

Voici mon code, je répète qu'il est fait avec sdl et c et que la sdl m'est imposée, donc pas de sdl2

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <dirent.h>
#include <windows.h>
#include <SDL/SDL.h>
#include <SDL/SDL_ttf.h>
#include <SDL/SDL_image.h>
#include <SDL/SDL_rotozoom.h>
#include <SDL/SDL_framerate.h>
#include <SDL/SDL_gfxPrimitives.h>
int dir(SDL_Surface*src)
{
    struct dirent *lecture;
    char chemin[20000]=/*"projects/test/"*/"images/";
    DIR *rep;
    rep = opendir(chemin);
    const char *tab[]={".bmp",".png",".jpg",".jpeg",".tiff",".webp"};
    size_t nb_elem  = sizeof tab / sizeof *tab;
    int cnt=1;
    SDL_Surface**tab_image=(SDL_Surface**)calloc(1,sizeof(SDL_Surface*));
    SDL_Rect *IMAGE=(SDL_Rect*)calloc(1,sizeof(SDL_Rect));
    char chemin2[20000]="";
    while ((lecture = readdir(rep)))
    {
    	for(int i=0;i<nb_elem;i++)
    	{
    		if(strstr(lecture->d_name,tab[i]))
	    	{
	    	    strcpy(chemin2,chemin);
	    	    strcpy(chemin,chemin);
	    		strcat(chemin2,lecture->d_name);
	    		tab_image[cnt-1]=IMG_Load(chemin2);
	    		if(!tab_image[cnt-1])
                {
                    printf("image[%d]:%s = Erreur\n",cnt-1,chemin2);
                }
                else
                {
                    printf("%s\n",chemin2);
                    IMAGE[cnt-1].x=8;
                    IMAGE[cnt-1].y=8;
                    IMAGE[cnt-1].w=tab_image[cnt-1]->w;
                    IMAGE[cnt-1].h=tab_image[cnt-1]->h;
                    SDL_BlitSurface(tab_image[cnt-1],0,src,&IMAGE[cnt-1]);
                    cnt++;
                    tab_image=(SDL_Surface**)realloc(tab_image,(cnt)*sizeof(SDL_Surface*));
                    IMAGE=(SDL_Rect*)realloc(IMAGE,(cnt)*sizeof(SDL_Rect));
                }
	    	}
    	}
    }
    printf("%d\n",cnt-1);
    closedir(rep);
    return 0;
    for(int i=0;i<cnt;i++)
    {
        SDL_FreeSurface(tab_image[i]);
        free(&IMAGE[i]);
    }
}

Hello,

Dois-tu absolument mettre en mémoire toutes les images du dossier ? Ne peux-tu te contenter que de les afficher ?

De toute façon, ta méthode pour les mémoriser n'est pas correcte. Ce serait plutôt quelque chose du genre (méthode basique)

int nsrfc=0;
SDL_Surface **srfc=NULL;

while(....) {
	....
	if(c'est une image) {
		*srcf=realloc(*srfc,(nsrfc+1)*sizeof(SDL_Surface *));
		srfc[nsrfc]=IMG_Load(....);
		nsrfc++;
	}
	....
}

Edit: code modifié suite au post suivant, distrait, j'ai oublié un paramètre pour realloc()

-
Edité par edgarjacobs 25 mars 2020 à 17:40:21

L'objectif du code est de récupérer les chemins d'accès des images du dossier ciblé, puis de les afficher, donc oui, il faut mettre en mémoire toutes les images, parce que si quelqu'un change de dossier ou ajoute une nouvelle image au dossier, il faut que le code puisse afficher la/les nouvelle(s) image(s).

J'ai testé ta méthode mais malheureusement ça ne change rien, le code plante au bout de 20 secondes avec un certain dossier.

Pour la fonction realloc tu as oublié un paramètre, le prototype de la fonction est : void *realloc(void *tampon,size_t taille).

Est-ce que c'est à cause du premier paramètre de la fonction realloc que mon code plante (voir le code posté au début du forum) ?

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <dirent.h>
#include <windows.h>
#include <SDL/SDL.h>
#include <SDL/SDL_ttf.h>
#include <SDL/SDL_image.h>
#include <SDL/SDL_rotozoom.h>
#include <SDL/SDL_framerate.h>
#include <SDL/SDL_gfxPrimitives.h>
int dir(SDL_Surface*src)
{
    struct dirent *lecture;
    char chemin[20000]=/*"projects/test/"*/"images/";
    DIR *rep;
    rep = opendir(chemin);
    const char *tab[]={".bmp",".png",".jpg",".jpeg",".tiff",".webp",".ico"};
    size_t nb_elem  = sizeof tab / sizeof *tab;
    int cnt=0;
    //SDL_Surface**tab_image=(SDL_Surface**)malloc(1*sizeof(SDL_Surface*));
    SDL_Surface**tab_image=NULL;
    //SDL_Rect *IMAGE=(SDL_Rect*)malloc(1*sizeof(SDL_Rect));
    SDL_Rect *IMAGE=NULL;
    char chemin2[20000]="";

    while ((lecture = readdir(rep)))
    {
    	for(int i=0;i<nb_elem;i++)
    	{
    		if(strstr(lecture->d_name,tab[i]))
	    	{
	    	    strcpy(chemin2,chemin);
	    	    strcpy(chemin,chemin);
	    		strcat(chemin2,lecture->d_name);

                SDL_Surface*tmp=IMG_Load(chemin2);
                if(tmp)
                {
                    tab_image=realloc(tab_image,(cnt+1)*sizeof(SDL_Surface*));
                    IMAGE=realloc(IMAGE,(cnt+1)*sizeof(SDL_Rect));
                    tab_image[cnt]=IMG_Load(chemin2);
                    IMAGE[cnt].x=8;
                    IMAGE[cnt].y=8;
                    IMAGE[cnt].w=tab_image[cnt]->w;
                    IMAGE[cnt].h=tab_image[cnt]->h;
                    SDL_BlitSurface(tab_image[cnt],NULL,src,&IMAGE[cnt]);
                    printf("\n%s",chemin2);
                    cnt++;
                }
                SDL_FreeSurface(tmp);
	    	}
    	}
    }
    printf("\n%d\n",cnt);
    closedir(rep);
    return 0;
    for(int i=0;i<cnt;i++)
    {
        SDL_FreeSurface(tab_image[i]);
        free(&IMAGE[i]);
    }
}