ramimage.c

Go to the documentation of this file.

/* --
OpenFX - Modelling, Animation and Rendering Package
-- */

/* file RAMIMAGE.C */

// This file manages RAM images for the iamge maps;

#define MODULE_RAMIMAGE 1

#include "design.h"

#define ALIGNULONG(i)   ((i+3)/4*4)
#define  temp_image_name "OFX_T_$$"

static void MakeThumbnailFromMap(RAMIMAGE *image);
static unsigned char *MakeThumbnailFromFile(BOOL bThumb, char *file, 
                            long *xx, long *yy, long type);
static int IdentifyImageFileType(char *fn);
static int  number_of_file_extensions=6;
static char *image_file_extensions[]={".gif",".tga",".tif",".jpg",".png",".bmp"};
void ScaleImageBuffer4(long xi, long yi, unsigned char *pi, long xo, long yo, unsigned char *po);


void InitialiseRamImage(RAMIMAGE *im){
 im->version=1;
 im->in_use=FALSE;
 im->size=0;
 im->filename=NULL;
 im->data=NULL;
 im->thumbx=0;
 im->thumby=0;
 im->thumb=NULL;
}

BOOL LoadRamImage(RAMIMAGE *image, char *file){ // Read the RAM image file into store
 HANDLE fq;
 DWORD dwSize,dwRead;
 char *pfilename,*pdata;
 if(file == NULL)return FALSE;
 if(!bEmbedImageMaps)return TRUE;
 if(image->in_use)UnloadRamImage(image);
 //MessageBox(NULL,file,"Load Image File",MB_OK);
 fq=CreateFile(file,GENERIC_READ,FILE_SHARE_READ,NULL,OPEN_EXISTING,
    FILE_ATTRIBUTE_READONLY,(HANDLE)NULL);
 if(fq == INVALID_HANDLE_VALUE){
   MessageBox(NULL,file,"Bad Handle Load Ram Image",MB_OK);
   return FALSE;
 }
 dwSize = GetFileSize (fq, NULL) ; 
 //{char xxx[256]; sprintf(xxx,"image [%s] size=%ld",file,dwSize);
 //MessageBox(NULL,xxx,"Loading",MB_OK);}
 if(dwSize == INVALID_FILE_SIZE || dwSize == 0){
   CloseHandle(fq);
   return FALSE;
 }
 if((pfilename=(char *)X__Malloc(strlen(file)+2)) == NULL){
   CloseHandle(fq);
   MessageBox(NULL,"Bad Read 1",NULL,MB_OK);
   return FALSE;
 }
 if((pdata=(unsigned char*)X__Malloc(dwSize)) == NULL){
   X__Free(pfilename);
   CloseHandle(fq);
   MessageBox(NULL,"Bad Read 2",NULL,MB_OK);
   return FALSE;   
 }
 if(ReadFile(fq,pdata,dwSize,&dwRead,NULL) == 0 || dwRead != dwSize){
   X__Free(pfilename);
   X__Free(pdata);
   CloseHandle(fq);
   MessageBox(NULL,"Bad Read 3",NULL,MB_OK);
   return FALSE;   
 } 
 strcpy(pfilename,file);
 image->in_use=TRUE;
 image->filename=pfilename;
 image->data=pdata;
 image->size=dwSize;
 CloseHandle(fq);
 { // Make the small thumbnal image - this requres reading the file again
   // later it should be possible to make the thumbnail by passing the already
   // loaded image (JPEG etc.) to MakeThumbnailFromMap() but as yet
   // this has to write it to temporary files and re-read those.
   unsigned char *p;
   long x,y,id;
   if(image->in_use && image->filename != NULL && 
      image->data != NULL && image->size > 0){
      id=IdentifyImageFileType(image->filename);
     if(id >= 0){
       if((p=MakeThumbnailFromFile(TRUE,file,&x,&y,id)) != NULL){
         image->thumb  = p;
         image->thumbx = x;
         image->thumby = y;
       }
     }
   }
 }
 return TRUE;
}

BOOL UnloadRamImage(RAMIMAGE *image){
 if(!image->in_use)return TRUE;
 //MessageBox(NULL,image->filename,"Image Unloaded From Store",MB_OK);
 if(image->data != NULL)X__Free(image->data);
 if(image->filename != NULL)X__Free(image->filename);
 if(image->thumb != NULL)X__Free(image->thumb);
 InitialiseRamImage(image);
 return TRUE;
}

void UnloadRamImagesFromMap(int i){   // called as part of the unload to files 
 UnloadRamImage(&(iMap[i].si));
 UnloadRamImage(&(iMap[i].ri));
 UnloadRamImage(&(iMap[i].bi));
 UnloadRamImage(&(iMap[i].ti));
}

void UnloadRamImagesFromAllMaps(void){   
 int i;
 if(nImaps == 0)return;
 if(SendPrgmQuery(IDQ_CONFIRM,1) != IDYES)return;
 for(i=0;i<nImaps;i++){
   UnloadRamImage(&(iMap[i].si));
   UnloadRamImage(&(iMap[i].ri));
   UnloadRamImage(&(iMap[i].bi));
   UnloadRamImage(&(iMap[i].ti));
 }
}

void EmbedMapsForMap(int m){
 int i;
 char filename[256],*p;
 IMAGEMAP *map;
 RAMIMAGE *image;
  map = &(iMap[m]);
 for(i=0;i<4;i++){
   image=NULL;
   if(i == 0 && map->s == 1 && map->S != NULL && map->Type != ANIMBRUSH){
      image  = &(map->si); p = map->S;
   } 
   else if(i == 1 && map->r == 1 && map->R != NULL && map->TypeR != ANIMBRUSH){
      image  = &(map->ri); p = map->R;
   } 
   else if(i == 2 && map->b == 1 && map->B != NULL && map->TypeB != ANIMBRUSH){
      image  = &(map->bi); p = map->B;
   }
   else if(i == 3 && map->t == 1 && map->T != NULL && map->TypeT != ANIMBRUSH){
      image  = &(map->ti); p = map->T;
   } 
   if(image != NULL){
     if( ! image->in_use && image->filename == NULL && 
            image->data == NULL && image->size == 0){
       //MessageBox(NULL,p,"Embedding Map",MB_OK); 
       LoadRamImage(image,p);
     }
   }
 }
}

void EmbedAllMapsImages(void){       
  int i;
  if(nImaps > 0)for(i=0;i<nImaps;i++){
    EmbedMapsForMap(i);
  } 
}

void SaveRamImagesToFiles(int m){ // map m  
 int i,j;
 char filename[MAX_FILE],new_dir[MAX_DIR],temp[MAX_FILE],text_string[64];
 RAMIMAGE *image;
 strcpy(temp,"temp.txt"); strcpy(new_dir,TempPath);
 LoadString(ghinst_main,IDX_MISC_EXPORTMAPFOLDER,text_string,sizeof(text_string));
 if(SelectDirectoryName(temp,new_dir,text_string,"(*.txt)|*.txt|",ghwnd_main) == FALSE)return;
 if(strlen(new_dir) == 2)strcat(new_dir,"\\");
 if((j=strlen(new_dir)) < 3)return;  if(new_dir[j-1] != '\\')strcat(new_dir,"\\");
 for(i=0;i<4;i++){
   if(i == 0)image  = &(iMap[m].si);
   if(i == 1)image  = &(iMap[m].ri);
   if(i == 2)image  = &(iMap[m].bi);
   if(i == 3)image  = &(iMap[m].ti);
   if(image->in_use && image->filename != NULL && 
     image->data != NULL && image->size > 0){
     //sprintf(filename,"%s%s",TempPath,short_form(image->filename));
     sprintf(filename,"%s%s",new_dir,short_form(image->filename));
     UnstoreRamImage(image,filename);
   }
 }
}

void SaveRamImagesFromAllMaps(void){ 
 int i,m,j;
 char filename[MAX_FILE],new_dir[MAX_DIR],temp[MAX_FILE],text_string[64];
 RAMIMAGE *image;
 if(nImaps < 1)return;
 strcpy(temp,"temp.txt"); strcpy(new_dir,TempPath);
 LoadString(ghinst_main,IDX_MISC_EXPORTMAPFOLDER,text_string,sizeof(text_string));
 if(SelectDirectoryName(temp,new_dir,text_string,"(*.txt)|*.txt|",ghwnd_main) == FALSE)return;
 if(strlen(new_dir) == 2)strcat(new_dir,"\\");
 if((j=strlen(new_dir)) < 3)return;  if(new_dir[j-1] != '\\')strcat(new_dir,"\\");
 for(m=0; m<nImaps; m++){
   for(i=0;i<4;i++){
     if(i == 0)image  = &(iMap[m].si);
     if(i == 1)image  = &(iMap[m].ri);
     if(i == 2)image  = &(iMap[m].bi);
     if(i == 3)image  = &(iMap[m].ti);
     if(image->in_use && image->filename != NULL && 
       image->data != NULL && image->size > 0){
       //sprintf(filename,"%s%s",TempPath,short_form(image->filename));
       sprintf(filename,"%s%s",new_dir,short_form(image->filename));
       UnstoreRamImage(image,filename);
     }
   }
 }
}

BOOL UnstoreRamImage(RAMIMAGE *image, char *filename){ // used for saving images to files
 HANDLE fq;
 DWORD dwSize,dwWrite;
 char file[256];
 if(image->in_use && image->filename != NULL && 
   image->data != NULL && image->size > 0){
   if(filename == NULL) // unstore to original location
         strcpy(file,image->filename);
   else strcpy(file,filename);
   fq=CreateFile(file,GENERIC_WRITE,FILE_SHARE_WRITE,NULL,CREATE_ALWAYS,
                  FILE_ATTRIBUTE_NORMAL,(HANDLE)NULL);
   if(fq == INVALID_HANDLE_VALUE){
    MessageBox(NULL,file,"Bad Handle Unstore Ram Image",MB_OK);
    return FALSE;
   }
   dwSize=image->size;
   if(WriteFile(fq,image->data ,dwSize,&dwWrite,NULL) != 0 && dwWrite == dwSize){
     CloseHandle(fq);
     return TRUE;
   }
   else CloseHandle(fq);
 }
 return FALSE;
}

static int IdentifyImageFileType(char *fn){
 int i; char last4[5];
 last4[4]=0;
 strncpy(last4,(fn+strlen(fn)-4),4);
 strlwr(last4);
 for(i=0;i<number_of_file_extensions;i++){
   if(strncmp((char *)last4,image_file_extensions[i],4) == 0)return i;
 }
 return -1; 
}

void DisplayImageFromStore(RAMIMAGE *image, char *alternate_name){
 HANDLE fq;
 DWORD dwSize,dwWrite;
 int id;
 char file[256];
 if(image->in_use && image->filename != NULL && 
    image->data != NULL && image->size > 0){
   id=IdentifyImageFileType(image->filename);
   if(id < 0){
     MessageBox(NULL,"Bad Type",NULL,MB_OK);
     return;
   }
   sprintf(file,"%s%s%s",TempPath,temp_image_name,image_file_extensions[id]);
   fq=CreateFile(file,GENERIC_WRITE,FILE_SHARE_WRITE,NULL,CREATE_ALWAYS,
                  FILE_ATTRIBUTE_NORMAL,(HANDLE)NULL);
   if(fq == INVALID_HANDLE_VALUE){
     MessageBox(NULL,file,"Bad Handle Display from Store",MB_OK);
     return;
   }
   dwSize=image->size;
   if(WriteFile(fq,image->data ,dwSize,&dwWrite,NULL) != 0 && dwWrite == dwSize){
     CloseHandle(fq);
     Sleep(10);
     WritePrivateProfileString("VIEWER","MAPFILE",file,IniFilename);
     //MessageBox(NULL,file,"Displaying Image",MB_OK); 
     LoadViewer(2);
   }
   else CloseHandle(fq);
 }
 else{
   //MessageBox(NULL,alternate_name,"Displaying Alternate",MB_OK); 
   WritePrivateProfileString("VIEWER","MAPFILE",alternate_name,IniFilename);
   LoadViewer(2);
 }
}

void EraseTempImageFiles(void){
 int i;
 char file[256];
 for(i=0;i<number_of_file_extensions;i++){
   sprintf(file,"%s%s%s",TempPath,temp_image_name,image_file_extensions[i]);
   remove(file);
 }
 //MessageBox(NULL,"Temp Image files deleted",NULL,MB_OK);
}

unsigned char *MakeFullMemoryImage(RAMIMAGE *image, long *w, long *h){
 HANDLE fq;   // make a full "in ram" image from the map's image data
 DWORD dwSize,dwWrite;
 int id;
 char file[256];
 if(image->in_use && image->filename != NULL && 
    image->data != NULL && image->size > 0){
   id=IdentifyImageFileType(image->filename);
   if(id < 0){
     MessageBox(NULL,"Bad Type",NULL,MB_OK);
     return NULL;
   }
   sprintf(file,"%s%s%s",TempPath,temp_image_name,image_file_extensions[id]);
   fq=CreateFile(file,GENERIC_WRITE,FILE_SHARE_WRITE,NULL,CREATE_ALWAYS,
                  FILE_ATTRIBUTE_NORMAL,(HANDLE)NULL);
   if(fq == INVALID_HANDLE_VALUE){
     MessageBox(NULL,file,"Bad Handle Make Image data from map",MB_OK);
     return NULL;
   }
   dwSize=image->size;
   if(WriteFile(fq,image->data ,dwSize,&dwWrite,NULL) != 0 && dwWrite == dwSize){
     unsigned char *p;
     long x,y;
     CloseHandle(fq);
     if((p=MakeThumbnailFromFile(FALSE,file,&x,&y,id)) != NULL){ // make full image
       *w = x;
       *h = y;
       return p;
     }
   }
   else CloseHandle(fq);
 }
 return NULL;
}



static void MakeThumbnailFromMap(RAMIMAGE *image){
 // at present this function is only used by the reading code because there is NO
 // original file to work with and we will need to write out the image to a temp file
 // and build the thumbnail from that.
 // The openGL drawing code EXPECTS that this thumbnail exists (is made here) for ALL embedded
 // maps since the OpenGL map loading functions cannot access the embedded maps.
 HANDLE fq;
 DWORD dwSize,dwWrite;
 int id;
 char file[256];
 if(image->in_use && image->filename != NULL && 
    image->data != NULL && image->size > 0){
   id=IdentifyImageFileType(image->filename);
   if(id < 0){
     MessageBox(NULL,"Bad Type",NULL,MB_OK);
     return;
   }
   sprintf(file,"%s%s%s",TempPath,temp_image_name,image_file_extensions[id]);
   fq=CreateFile(file,GENERIC_WRITE,FILE_SHARE_WRITE,NULL,CREATE_ALWAYS,
                  FILE_ATTRIBUTE_NORMAL,(HANDLE)NULL);
   if(fq == INVALID_HANDLE_VALUE){
     MessageBox(NULL,file,"Bad Handle Make Thumbnail from map",MB_OK);
     return;
   }
   dwSize=image->size;
   if(WriteFile(fq,image->data ,dwSize,&dwWrite,NULL) != 0 && dwWrite == dwSize){
     unsigned char *p;
     long x,y;
     CloseHandle(fq);
     if((p=MakeThumbnailFromFile(TRUE,file,&x,&y,id)) != NULL){
       image->thumb  = p;
       image->thumbx = x;
       image->thumby = y;
     }
   }
   else CloseHandle(fq);
 }
}

static unsigned char *MakeThumbnailFromFile(BOOL bThumb, char *file, 
                            long *xx, long *yy, long type){
 // make the thumbnail image from the file containing the image 
 // will need to identify the file type so that the correct DLL is loaded
 int x_size,y_size;
 unsigned char *p,*px,*R,*G,*B,*r,*g,*b;
 long i,j,imagesize,xi,yi;
 long x,y;
 FILE *t24;
 char lname[256];
 HMODULE hLib;
 FARPROC fpFun;
 BOOL (*fpGetMapSize)(char *, long *, long *);
 BOOL (*fpGetMap)(char *, long, long,
                          unsigned char *, unsigned char *, unsigned char *);
 strcpy(lname,gszHomeDir);
 if     (type == 0)strcat(lname,"gif_map.dll");
 else if(type == 1)strcat(lname,"tga_map.dll");
 else if(type == 2)strcat(lname,"tif_map.dll");
 else if(type == 3)strcat(lname,"jpg_map.dll");
 else if(type == 4)strcat(lname,"png_map.dll");
 else if(type == 5)strcat(lname,"bmp_map.dll");
 R=G=B=NULL;
 //MessageBox(NULL,lname,file,MB_OK);
 hLib=LoadLibrary(lname);
 if(hLib != NULL){
   if((fpFun=GetProcAddress(hLib,"_GetExternalImageSize")) != NULL){
     fpGetMapSize = (void *)fpFun;
     if((*fpGetMapSize)(file,&x,&y)){
       if((R = (unsigned char *)X__Malloc(x*y)) == NULL)goto CLOSEOUT;
       if((G = (unsigned char *)X__Malloc(x*y)) == NULL)goto CLOSEOUT;
       if((B = (unsigned char *)X__Malloc(x*y)) == NULL)goto CLOSEOUT;
       if((fpFun=GetProcAddress(hLib,"_GetExternalImage")) != NULL){
         fpGetMap = (void *)fpFun;
         if(!(*fpGetMap)(file,x,y,R,G,B))goto CLOSEOUT;
       }
       else goto CLOSEOUT;
     }
     else goto CLOSEOUT;
   }
   else goto CLOSEOUT;
   FreeLibrary(hLib);
 }
 else return NULL;
// x_size = x; bad when used with scale image and not `long' aligned
 x_size=(int)ALIGNULONG(x);
 y_size = y;
 imagesize=x_size*y_size*3;
 if((p=(unsigned char *)X__Malloc(imagesize+3)) == NULL){
   X__Free(R);
   X__Free(G);
   X__Free(B);
   return NULL;
 }
 for(j=0;j<y;j++){  // combine the colour components
  px=(p+(y-j-1)*x_size*3);
  r=(R+j*x); g=(G+j*x); b=(B+j*x);
  for(i=0;i<x;i++){
if(!bThumb){
    *px++ = *b++;
    *px++ = *g++;
    *px++ = *r++;
}
else{
    *px++ = *r++;
    *px++ = *g++;
    *px++ = *b++;
}
  }
 }
 X__Free(R);
 X__Free(G);
 X__Free(B);
 if(!bThumb){ // return the full buffer size buffer
   *xx = x;
   *yy = y;
   return p;
 }
 if     (x_size <  128)xi=32; else xi=64;
 if     (y_size <  128)yi=32; else yi=64;
 if((px=(unsigned char *)X__Malloc(xi*yi*3+3)) == NULL){
   X__Free((char *)p);
   return NULL;
 }
 ScaleImageBuffer(x_size,y_size,p,xi,yi,px);
// gluScaleImage(GL_RGB,x_size,y_size,GL_UNSIGNED_BYTE,  // Dont use becuase only works
//               p,xi,yi,GL_UNSIGNED_BYTE,px);           // when OpenGL is active
 X__Free((char *)p);
 *xx = xi;
 *yy = yi;
 return px;
 CLOSEOUT:
 if(R != NULL)X__Free(R);
 if(G != NULL)X__Free(G);
 if(B != NULL)X__Free(B);
 FreeLibrary(hLib);
 return NULL;
}


static void GetRowPixelValues4(long rgb, long row, long n, unsigned char *buffer, double *values){
 int i;
 unsigned char *p;
 p=(buffer + row*n*4 + rgb);
 for(i=0;i<n;i++){
   values[i] = (double)(*p);  p += 4;
 }
}

static void GetColumnPixelValues4(long rgb, long col, long n, long w, unsigned char *buffer, double *values){
 int i;
 unsigned char *p;
 p=(buffer + col*4 + rgb);
 for(i=0;i<n;i++){
   values[i] = (double)(*p);  p += w*4;
 } 
}

static void PutRowPixelValues4(long rgb, long row, long n, unsigned char *buffer, double *values){
 int i;
 unsigned char *p;
 p=(buffer + row*n*4 + rgb);
 for(i=0;i<n;i++){
   *p = (unsigned char)values[i]; p += 4;
 }
}

static void PutColumnPixelValues4(long rgb, long col, long n, long w, unsigned char *buffer, double *values){
 int i;
 unsigned char *p;
 p=(buffer + col*4 + rgb);
 for(i=0;i<n;i++){
   *p = (unsigned char)values[i]; p += w*4;
 } 
}


static void GetRowPixelValues(long rgb, long row, long n, unsigned char *buffer, double *values){
 int i;
 unsigned char *p;
 p=(buffer + row*n*3 + rgb);
 for(i=0;i<n;i++){
   values[i] = (double)(*p);  p += 3;
 }
}

static void GetColumnPixelValues(long rgb, long col, long n, long w, unsigned char *buffer, double *values){
 int i;
 unsigned char *p;
 p=(buffer + col*3 + rgb);
 for(i=0;i<n;i++){
   values[i] = (double)(*p);  p += w*3;
 } 
}

static void PutRowPixelValues(long rgb, long row, long n, unsigned char *buffer, double *values){
 int i;
 unsigned char *p;
 p=(buffer + row*n*3 + rgb);
 for(i=0;i<n;i++){
   *p = (unsigned char)values[i]; p += 3;
 }
}

static void PutColumnPixelValues(long rgb, long col, long n, long w, unsigned char *buffer, double *values){
 int i;
 unsigned char *p;
 p=(buffer + col*3 + rgb);
 for(i=0;i<n;i++){
   *p = (unsigned char)values[i]; p += w*3;
 } 
}

static void InterpolateLine(long ni, double *pi, long no, double *po, long ij){ // ij used for debug only
 int i,xl,xr;
 double x,dx,dh;
 for(i=0;i<no;i++){
   x=((double)i*(double)(ni-1))/(double)(no-1);
   xl=(int)x; xr=min(ni-1,xl+1);
   dx=x-(double)xl;
   dh=pi[xr]-pi[xl];
   po[i]=pi[xl]+dx*dh;
   //x=(double)i * (double)(ni-1) /(double)(no-1); po[i]=pi[min((int)x,ni-1)];   // nearest
 } 
}

void FilterLine(long ni, long no , double *v, long *nii, long ij){
 int i,j,k,subsample,nsamples,remainder;
 double sample;
 sample = ((double)ni/(double)no);
 subsample=(int)sample;
 if(sample - (double)subsample > 0.5)subsample += 1;
 nsamples = ni / subsample;
 remainder = ni - nsamples*subsample;
 //if(debug != NULL && ij == 0)fprintf(debug,"Filtering ni=%ld no=%ld subsample=%ld nsamples=%ld remainder=%ld\n",ni,no,subsample,nsamples,remainder);
 if(nsamples > 1)for(i=0,k=0;i<nsamples;i++,k += subsample){
   *(v+i) = *(v+k);  
   if(subsample > 1){
     for(j=k+1;j<k+subsample;j++) *(v+i) += *(v+j); 
     *(v+i) /= (double)subsample;
   }
 }
 if(remainder == 0)*nii = nsamples;
 else{
   *(v+i) = *(v+k);
   if(remainder > 1){
     for(j=k+1;j<k+remainder;j++) *(v+i) += *(v+j);
     *(v+i) /= (double)remainder;
   }
   *nii = nsamples + 1;
  }
}

void ScaleImageBuffer(long xi, long yi, unsigned char *pi, long xo, long yo, unsigned char *po){
 double i,j;
 double *vi,*vo;
 long xii,yii;
 unsigned char *p;
 if((vi=(double *)X__Malloc(max(xi,yi)*sizeof(double))) == NULL){return;}
 if((vo=(double *)X__Malloc(max(xo,yo)*sizeof(double))) == NULL){X__Free(vi); return;}
 if((p=(unsigned char *)X__Malloc(xo*yi*3)) == NULL){ // temp buffer xout by yin
   X__Free(p); X__Free(vi); X__Free(vo);
   return;
 }
 //if(debug != NULL)fprintf(debug,"Scale image from (%ld x %ld) to (%ld %ld)\n",xi,yi,xo,yo);
 //MessageBox(NULL,"Starting First Pass","Scaling Image",MB_OK);
 for(i=0;i<yi;i++)for(j=0;j<3;j++){
   GetRowPixelValues(j,i,xi,pi,vi);
   if(xi > xo)FilterLine(xi,xo,vi,&xii,i+j); else xii=xi;
   InterpolateLine(xii,vi,xo,vo,i+j);
   PutRowPixelValues(j,i,xo,p,vo);
 }
 //MessageBox(NULL,"Starting Second Pass","Scaling Image",MB_OK);
 for(i=0;i<xo;i++)for(j=0;j<3;j++){
   GetColumnPixelValues(j,i,yi,xo,p,vi);
   if(yi > yo)FilterLine(yi,yo,vi,&yii,i+j); else yii=yi;
   InterpolateLine(yii,vi,yo,vo,i+j);
   PutColumnPixelValues(j,i,yo,xo,po,vo);
 }
 X__Free(p);
 X__Free(vi);
 X__Free(vo);
}

void ScaleImageBuffer4(long xi, long yi, unsigned char *pi, long xo, long yo, unsigned char *po){  // INCOMPLETE
 double i,j;
 double *vi,*vo;
 long xii,yii;
 unsigned char *p;
 if((vi=(double *)X__Malloc(max(xi,yi)*sizeof(double))) == NULL){return;}
 if((vo=(double *)X__Malloc(max(xo,yo)*sizeof(double))) == NULL){X__Free(vi); return;}
 if((p=(unsigned char *)X__Malloc(xo*yi*4)) == NULL){ // temp buffer xout by yin
   X__Free(p); X__Free(vi); X__Free(vo);
   return;
 }
 //if(debug != NULL)fprintf(debug,"Scale image from (%ld x %ld) to (%ld %ld)\n",xi,yi,xo,yo);
 //MessageBox(NULL,"Starting First Pass","Scaling Image",MB_OK);
 for(i=0;i<yi;i++)for(j=0;j<4;j++){
   GetRowPixelValues4(j,i,xi,pi,vi);
   if(xi > xo)FilterLine(xi,xo,vi,&xii,i+j); else xii=xi;
   InterpolateLine(xii,vi,xo,vo,i+j);
   PutRowPixelValues4(j,i,xo,p,vo);
 }
 //MessageBox(NULL,"Starting Second Pass","Scaling Image",MB_OK);
 for(i=0;i<xo;i++)for(j=0;j<4;j++){
   GetColumnPixelValues4(j,i,yi,xo,p,vi);
   if(yi > yo)FilterLine(yi,yo,vi,&yii,i+j); else yii=yi;
   InterpolateLine(yii,vi,yo,vo,i+j);
   PutColumnPixelValues4(j,i,yo,xo,po,vo);
 }
 X__Free(p);
 X__Free(vi);
 X__Free(vo);
}


BOOL ReadRamImage(RAMIMAGE *image, HANDLE *fq){
 char *pfilename,*pdata;
 DWORD dwRead,dwSize,dwLen;
 long l,ls,ld;
 ReadLongInteger(&l,fq);
 image->version=l;
 ReadLongInteger(&l,fq);
 //if(l)MessageBox(NULL,"In use","Reading Ram Image",MB_OK);
 //else MessageBox(NULL,"Not in use","Reading",MB_OK);
 if((BOOL)l == FALSE)return FALSE;
 ReadLongInteger(&ls,fq);
 ReadLongInteger(&ld,fq);
 if((pfilename=(char *)X__Malloc(ls+1)) == NULL)return FALSE;
 if((pdata=(unsigned char*)X__Malloc(ld)) == NULL)return FALSE;
 ReadFile(fq,pfilename,ls+1,&dwRead,NULL);  // Image name
 //{char xxx[256]; sprintf(xxx,"[%s] text len=%ld size=%ld",pfilename,ls,ld);
 //MessageBox(NULL,xxx,"Reading",MB_OK);}
 ReadFile(fq,pdata,ld,&dwRead,NULL);  // data
 image->in_use=TRUE;
 image->filename=pfilename;
 image->data=pdata;
 image->size=ld;
 MakeThumbnailFromMap(image);  // make the thumbnail for OpenGL renderer
 return TRUE;
}

BOOL WriteRamImage(RAMIMAGE *image, FILE *fp){
 long l,zero=0;
//if(image->in_use)MessageBox(NULL,image->filename,"Writing Ram Image",MB_OK);
//else MessageBox(NULL,"Not in use","Writing",MB_OK);
 WriteLongInteger(image->version,fp);
 if(! image->in_use || image->size == 0 || image->filename == NULL || image->data == NULL){
   WriteLongInteger(zero,fp);
   return TRUE;
 }
 l=strlen(image->filename);
 if(l <= 0){
   WriteLongInteger(zero,fp);
   return TRUE;
 }
 WriteLongInteger(image->in_use,fp);
 if( ! image->in_use)return TRUE;
 WriteLongInteger(l,fp);
 WriteLongInteger(image->size,fp);
 fwrite(image->filename,strlen(image->filename)+1,1,fp);
 fwrite(image->data,image->size,1,fp);
 //{char xxx[256]; sprintf(xxx,"[%s] len=%ld size=%ld",image->filename,l,image->size);
 //MessageBox(NULL,xxx,"Writing Ram Image",MB_OK);}
 return TRUE;
}