création d un fichier virtuel

[chtimi]

bonjour, j essaie désespérement de recevoir un fichier en tcp et de l'écrire dans un fichier virtuel

déjà à quoi correspond le 3ème paramètre de la fonction VirtualFileWrite(ptr, size, n, f)?
voici une partie du code

char *data="";
int taille = 0;


OSL_VIRTUALFILENAME ram_files[ ] = {
{"ram:/image.png", data, strlen(data), &VF_MEMORY},
};

oslAddVirtualFileList(ram_files, oslNumberof(ram_files));

vf=VirtualFileOpen("ram:/image.png", 0, VF_AUTO , VF_O_WRITE);

do{
memset(buffer,0,sizeof(buffer));
taille=recv(sock, buffer, sizeof(buffer), 0);

if (taille > 0){
VirtualFileWrite(buffer,sizeof(buffer),n,vf);
}

}
while(taille>0);

VirtualFileClose(vf);

le fichier se créée bien mais j'arrive pas à ecrire dedans

[cyril92]

Extrait des sources OSLib :

/** Writes in a file and returns the number of bytes effectively written. */
#define VirtualFileWrite(ptr, size, n, f) (VirtualFileGetSource(f)->fWrite(ptr, size, n, f))

n =1 d'habitude : c'est le nombre de fois ou tu veux écrire la chaine 'ptr' de taille = size.

[chtimi]

merci, pour la réponse!

par contre j ai un souci avec le chargement d'une image
image = oslLoadImageFile("cam.png", OSL_IN_RAM, OSL_PF_8888);

quand je rentre les coordonnées de l image, ça fais planter le homebrew!
image->x = 73;
image->y = 0;

voici la source si quelqu un à le temps d'y regarder

http://www.megaupload.com/?d=LB0TTCNF

[cyril92]

j'ai regardé un peu ton code.
ta boucle (!osl_quit) n'est pas très propre.
par ex initConsole devrait être en dehors.

mais à mon avis, ton plantage provient d'un pb en amont de l'affichage de l'image :
je soupconnerais une fuite memoire lors du remplissage de ton buffer
je n'ai pas bien regardé mais tu fais un 'memset' à chaque boucle ???

[chtimi]

dsl pour la présentation de la source, mais ça fait 2 jours que je fais plein de teste

oui, je remet à zéro le buffer à chaque boucle, le pire c est que j'utilise une image stoké sur la ms pour testé, j avais déjà eu un souci avec la oslib, j'avais du utilisé la libpng dans l ancienne version

pour revenir à mon image, si je la déclare OSL_IMAGE *image comme variable globale et que je charge le fichier image depuis la fonction main, j arrive à l affiché!

mais pas si je déclare en local et que je la charge depuis la fonction connect_and_send(), ça plante

je suis quand meme content, ça marche plus de 10 min sans planté, 2000 image de 50Ko à peu près

[cyril92]

bah laisse-la en globale : en local elle ne doit pas être detruite et donc tu reserves un espace à chaque fois (à mon avis)

[chtimi]

je viens de tester, ça fais la meme chose!

je vais devoir tout décomposer pour trouver le probleme

juste pour savoir avant que je m engage trop, c'est possible de recharger une image avec la oslib? j'ai vu que c'était possible mais d'autre n y arrive pas!

au passage, il a l'air super sympa ton homebrew

[chtimi]

J'ai du me servir que de la lib GU pour résoudre mon souci!

Du coup, je me suis amusé à faire des loaders d'image

Pour ceux que ça interesse, voici celui du BMP 8bits et 24 bits avec ou sans la compression RLE

PS: désolé c'est pas super propre, n'hésiter à poster d'autre loader d'image, j'ai également fait pour le tga et le pcx, je les mettraient si quelques personnes sont interessés!

A ajouter dans graphics.h

#define BYTE unsigned char
#define WORD unsigned short
#define DWORD unsigned long

struct RGBQUAD{
BYTE b;
BYTE g;
BYTE r;
BYTE a;
} ;

/* le Header d'un fichier BMP */
struct BMPHEADER {
char type[2]; /* Type of the bitmap. Set to BM */
DWORD size; /* Size of the file */
DWORD reserved;
DWORD offset; /* Offset of the data from this position */
DWORD headersize; /* Size of the rest of the header */
DWORD width; /* Width of the bitmap */
DWORD height; /* Height of the bitmap */
WORD planes; /* Planes of the bitmap */
WORD bitsperpixel; /* number of bits per pixel */
DWORD compression; /* Type of compression. Usually set to 0 */
DWORD sizeimage; /* Size of the image */
DWORD xpixelspermeter; /* Number of pixel per meter */
DWORD ypixelspermeter;
DWORD colorsused; /* Number of colors used */
DWORD colorsimportant; /* Number of colors considered important */
};

extern Image* loadImagebmp(const char* filename);

puis dans graphics.c

Image* loadImagebmp(const char* filename){

struct BMPHEADER header;
struct RGBQUAD rgbquad;
unsigned char *palette,*pixel;
int x,y;
int nbroctet;
int pos=0,c;
int repeat=0;
u32 color_table[256];

FILE *f = fopen( filename, "rb" );
if (f==NULL) return NULL;

header.type[0]=' ';
fread(&header.type, 2, 1, f);
if((header.type[0]!='B')||(header.type[1]!='M')) {
fclose(f);
return NULL;
}

// Read all the header
if(fread(&header.size, 52, 1, f)!=1) {
fclose(f);
return NULL;
}

Image* image = (Image*) malloc(sizeof(Image));
if (!image) return NULL;

image->imageWidth = header.width;
image->imageHeight = header.height;
image->textureWidth = getNextPower2(image->imageWidth);
image->textureHeight = getNextPower2(image->imageHeight);

// Read the data informations
image->data = (Color*) memalign(16, image->textureWidth * image->textureHeight * sizeof(Color));

switch(header.bitsperpixel){
case 1:
break;

case 2 :
break;

case 4 :
break;

case 8:

// Read the palette information
palette = (unsigned char*)malloc(768);
memset (palette,0,768);

for(y=0;y<256;y++) {
rgbquad.b=getc(f);
rgbquad.g=getc(f);
rgbquad.r=getc(f);
getc(f);
color_table[y]=RGBA(rgbquad.r,rgbquad.g,rgbquad.b,255);
}

nbroctet=header.sizeimage;
pixel = (unsigned char*)malloc(nbroctet);
x=0;
y=0;

while (y < nbroctet){
c = getc(f);
if (((c & 0xC0) == 0xC0) & (header.compression==1)){
repeat = 0x3f & c;
c = getc(f);
for (x = 0; x < repeat; x++){
pixel[y++] = c;
}
}
else
pixel[y++] = c;
}
int color_id;
pos=0;
for(y=image->imageHeight;y>0;y--) {
for(x=0;x<image->imageWidth;x++){
color_id = pixel[pos];
image->data[x + y * image->textureWidth] = color_table[color_id];
}
// Adjust the data if the width is not divisible for 4
while(x%4>0){
pos++;
x++;
}
}
break;

case 24:

nbroctet=header.sizeimage;
pixel = (unsigned char*)malloc(nbroctet);
x=0;
y=0;
while (y < nbroctet){
c = getc(f);
if (((c & 0xC0) == 0xC0) & (header.compression==1)){
repeat = 0x3f & c;
c = getc(f);
for (x = 0; x < repeat; x++){
pixel[y++] = c;
}
}
else
pixel[y++] = c;
}
pos=0;
for(y=image->imageHeight;y>0;y--){
for(x=0;x<image->imageWidth;x++){
image->data[x + y * image->textureWidth] = RGBA(pixel[pos+2],pixel[pos+1],pixel[pos],255);
pos+=3;
}
// Adjust the data if the width is not divisible for 4
while(x%4>0){
pos++;
x++;
}
}
break;

default:
printf("format non standard");
}

fclose(f);

return image;
}