LOADMAPS.C

Go to the documentation of this file.

// file loadmaps.c

// load and prepare any image maps used by the renderer


#define MODULE_LOADMAPS

/* Output file writing + image map loading */

#include "render.h"
//#undef OK                     /* OK is defined again in giflib.h */
//#include "giflib.h"

typedef struct RenderIMAP_tag {
 unsigned char *p24R,*p24G,*p24B;
 short xmax,ymax;
} RenderIMAP;

typedef struct ImageStoreEntry_tag {
 unsigned char *name;
 unsigned char *p24R,*p24G,*p24B;
 unsigned char *pImage;
 unsigned short x,y,xs,ys;
} ImageStoreEntry;

extern char gszHomeDir[];

static short LoadExternalImageMap(char *fn, char *ofname, RenderIMAP *map);
static long LoadRenderImageMap(imap *Map, char *mfname, char *ofname,
                           RenderIMAP *map);
static unsigned char *MakeScaledImage(BOOL combined, long *xx, long *yy,
          unsigned char **RR, unsigned char **GG, unsigned char **BB);
static unsigned char *MakeUnscaledImage(BOOL, long xx, long yy,
          unsigned char **RR, unsigned char **GG, unsigned char **BB, unsigned char **AA);
static short LoadExternalMovieFrame(char *fn, char *ofname, RenderIMAP *map);

static ImageStoreEntry *ImageStoreList=NULL;
static long nImageStoreEntries=0;


int AddImageToImageStore(char *name,  unsigned short x, unsigned short y,
                          unsigned char *r, unsigned char *g, unsigned char *b,
                          unsigned char *Image){
  ImageStoreEntry *tImageStoreList=NULL;
  char *n;
  int l;
  if(ImageStoreList == NULL){
    if((tImageStoreList=(ImageStoreEntry *)X__Malloc(sizeof(ImageStoreEntry))) == NULL)return 0;
  }
  else{
    if((tImageStoreList=(ImageStoreEntry *)X__Realloc(ImageStoreList,
      sizeof(ImageStoreEntry)*(nImageStoreEntries+1))) == NULL)return 0;
  }
  l=strlen(name)+2;
  ImageStoreList = tImageStoreList;
  if((n=(char *)X__Malloc(l)) == NULL)return 0;
  ImageStoreList[nImageStoreEntries].name=n;
  strcpy(n,name);
  //if(debug != NULL){fprintf(debug,"Added image map [%s] to store\n",name); fflush(debug);}
  ImageStoreList[nImageStoreEntries].x=x;
  ImageStoreList[nImageStoreEntries].y=y;
  ImageStoreList[nImageStoreEntries].p24R=r;
  ImageStoreList[nImageStoreEntries].p24G=g;
  ImageStoreList[nImageStoreEntries].p24B=b;
  ImageStoreList[nImageStoreEntries].pImage=Image;
  nImageStoreEntries++;
  return 1;
}

int CheckImageStoreForEntry(char *name,
                            unsigned short *x, unsigned short *y,
                            unsigned char **r, unsigned char **g, unsigned char **b,
                            unsigned char **Image){
 int i;
 //MessageBox(NULL,name,"Checking for map",MB_OK);
 if(nImageStoreEntries > 0 && ImageStoreList != NULL)for(i=0;i<nImageStoreEntries;i++){
   if(ImageStoreList[i].name != NULL && strcmp(name,ImageStoreList[i].name) == 0){
     if(ImageStoreList[i].p24R != NULL &&
        ImageStoreList[i].p24G != NULL &&
        ImageStoreList[i].p24B != NULL){
       *x=ImageStoreList[i].x;
       *y=ImageStoreList[i].y;
       *r=ImageStoreList[i].p24R;
       *g=ImageStoreList[i].p24G;
       *b=ImageStoreList[i].p24B;
       *Image=ImageStoreList[i].pImage;
       //if(debug != NULL){fprintf(debug,"Found image map [%s] in store\n",name); fflush(debug);}
       return 1;
     }
   }
 }
 return 0;
}

void ReleaseImageStore(void){
  int i;
  if(nImageStoreEntries > 0 && ImageStoreList != NULL)for(i=0;i<nImageStoreEntries;i++){
    //if(debug != NULL){fprintf(debug,"Releasing image map [%s] from store\n",ImageStoreList[i].name); fflush(debug);}
    X__Free(ImageStoreList[i].name);
    if(ImageStoreList[i].p24R != NULL)X__Free(ImageStoreList[i].p24R);
    if(ImageStoreList[i].p24G != NULL)X__Free(ImageStoreList[i].p24G);
    if(ImageStoreList[i].p24B != NULL)X__Free(ImageStoreList[i].p24B);
    if(ImageStoreList[i].pImage != NULL)X__Free(ImageStoreList[i].pImage);
  }
  X__Free(ImageStoreList);
  ImageStoreList=NULL;
  nImageStoreEntries=0;
  //if(debug != NULL){fprintf(debug,"ImageStoreList Released\n"); fflush(debug);}
}


long SetupImageMap(imap *Map, char *objectfilename){
 RenderIMAP temp_map,*map;
 long success;
 //MessageBox(NULL,objectfilename,"SetupImageMap",MB_OK);
 map=&temp_map;
 success=1;
 if(!Map->bLoadedS && !Map->bAnimS){
   if(Map->pp >= 0){
     //if(debug != NULL)fprintf(debug,"Attempting to load map [%s]\n",Map->filename);
     if(LoadRenderImageMap(Map,Map->filename,objectfilename,map) == 1){
       Map->p24R=map->p24R; Map->p24G=map->p24G; Map->p24B=map->p24B;
       Map->xmax=map->xmax;
       Map->ymax=map->ymax;
       Map->bLoadedS=TRUE;
     }
     else Map->pp = -1; // No image for this map so don't try and render anything with it.
   }
 } 
 else {
  ;//if(debug != NULL)fprintf(debug,"[%s] already loaded %ld or AVI\n",Map->filename,Map->pp);
 }
 if(!Map->bLoadedR && !Map->bAnimR){
   if(Map->rp >= 0){
     if(LoadRenderImageMap(Map,Map->frefl,objectfilename,map) == 1){
       Map->p24Rrefl=map->p24R;
       Map->p24Grefl=map->p24G;
       Map->p24Brefl=map->p24B;
       Map->xmaxrefl=map->xmax;
       Map->ymaxrefl=map->ymax;
       Map->bLoadedR=TRUE;
     }
     else Map->rp = -1;
   }
 }
 else {
  ;//if(debug != NULL)fprintf(debug,"Refl map [%s] already loaded %ld\n",Map->filename,Map->pp);
 }
 if(!Map->bLoadedB && !Map->bAnimB){
   if(Map->bp >= 0){
     if(LoadRenderImageMap(Map,Map->fbump,objectfilename,map) == 1){
       Map->p24Rbump=map->p24R;
       Map->p24Gbump=map->p24G;
       Map->p24Bbump=map->p24B;
       Map->xmaxbump=map->xmax;
       Map->ymaxbump=map->ymax;
       Map->bLoadedB=TRUE;
     }
     else Map->bp = -1;
   }
 }
 if(!Map->bLoadedT && !Map->bAnimT){
   if(Map->tp >= 0){
     if(LoadRenderImageMap(Map,Map->ftran,objectfilename,map) == 1){
       Map->p24Rtran=map->p24R;
       Map->p24Gtran=map->p24G;
       Map->p24Btran=map->p24B;
       Map->xmaxtran=map->xmax;
       Map->ymaxtran=map->ymax;
       Map->bLoadedT=TRUE;
     }
     else Map->tp = -1;
   }
 }
 return success;
}

BOOL CheckSingleRenderImageMap(imap *Map, char *mfname, char *ofname, char *tempfile, int type){
 RenderIMAP temp_map,*map;
 unsigned char *dummy;
 char *fn;
 long status;
 //MessageBox(NULL,objectfilename,"SetupImageMap",MB_OK);
 map=&temp_map;
 fn=(char *)strlwr(mfname);
 map->p24R=NULL; map->p24G=NULL; map->p24B=NULL;
 status=0;
 if(CheckImageStoreForEntry(mfname,&(map->xmax),&(map->ymax),
                            &(map->p24R),&(map->p24G),&(map->p24B),&dummy)){
   if(type == 0){
       Map->p24R=map->p24R; Map->p24G=map->p24G; Map->p24B=map->p24B;
       Map->xmax=map->xmax;
       Map->ymax=map->ymax;
       Map->bLoadedS=TRUE;
   }
   else if(type == 1){
       Map->p24Rrefl=map->p24R;
       Map->p24Grefl=map->p24G;
       Map->p24Brefl=map->p24B;
       Map->xmaxrefl=map->xmax;
       Map->ymaxrefl=map->ymax;
       Map->bLoadedR=TRUE;
   }
   else if(type == 2){
       Map->p24Rbump=map->p24R;
       Map->p24Gbump=map->p24G;
       Map->p24Bbump=map->p24B;
       Map->xmaxbump=map->xmax;
       Map->ymaxbump=map->ymax;
       Map->bLoadedB=TRUE;
   }
   else if(type == 3){
       Map->p24Rtran=map->p24R;
       Map->p24Gtran=map->p24G;
       Map->p24Btran=map->p24B;
       Map->xmaxtran=map->xmax;
       Map->ymaxtran=map->ymax;
       Map->bLoadedT=TRUE;
   }
   //if(debug != NULL)fprintf(debug,"Map [%s] temp [%s] already in store\n",mfname,tempfile);
   return TRUE;
 }
 return FALSE;
}

void LoadSingleRenderImageMap(imap *Map, char *mfname, char *ofname, char *tempfile, int type){
 RenderIMAP temp_map,*map;
 unsigned char *dummy;
 char *fn;
 long status;
 //MessageBox(NULL,objectfilename,"SetupImageMap",MB_OK);
 map=&temp_map;
 fn=(char *)strlwr(mfname);
 map->p24R=NULL; map->p24G=NULL; map->p24B=NULL;
 status=LoadExternalImageMap(tempfile,ofname,map);
 if(status == 1){
   status=AddImageToImageStore(mfname,(map->xmax),(map->ymax),
                          (map->p24R),(map->p24G),(map->p24B),NULL);
   if(status == 1){
     if(type == 0){
       Map->p24R=map->p24R; Map->p24G=map->p24G; Map->p24B=map->p24B;
       Map->xmax=map->xmax;
       Map->ymax=map->ymax;
       Map->bLoadedS=TRUE;
     }
     else if(type == 1){
       Map->p24Rrefl=map->p24R;
       Map->p24Grefl=map->p24G;
       Map->p24Brefl=map->p24B;
       Map->xmaxrefl=map->xmax;
       Map->ymaxrefl=map->ymax;
       Map->bLoadedR=TRUE;
     }
     else if(type == 2){
       Map->p24Rbump=map->p24R;
       Map->p24Gbump=map->p24G;
       Map->p24Bbump=map->p24B;
       Map->xmaxbump=map->xmax;
       Map->ymaxbump=map->ymax;
       Map->bLoadedB=TRUE;
     }
     else if(type == 3){
       Map->p24Rtran=map->p24R;
       Map->p24Gtran=map->p24G;
       Map->p24Btran=map->p24B;
       Map->xmaxtran=map->xmax;
       Map->ymaxtran=map->ymax;
       Map->bLoadedT=TRUE;
     }
     //if(debug != NULL)fprintf(debug,"Single Image [%s] from temp [%s]  status=%ld flags %ld %ld %ld %ld\n",mfname,
     //  tempfile,status,Map->bLoadedS,Map->bLoadedR,Map->bLoadedB,Map->bLoadedT);
   }
 }
}

//static long GetAVIframeImage(RenderIMAP *map, char * mfname, char *ofname, long GLobalFrameID){
//  return 0;
//}

static long LoadRenderImageMap(imap *Map, char *mfname, char *ofname,
                           RenderIMAP *map){
   long i,j,status=0,istga=0,isbmp=0,isgif=0,isext=0;
   char last4[8],*fn;
   unsigned char *dummy;
   map->p24R=NULL; map->p24G=NULL; map->p24B=NULL;
   fn=(char *)strlwr(mfname);
   if(CheckImageStoreForEntry(mfname,&(map->xmax),&(map->ymax),
                            &(map->p24R),&(map->p24G),&(map->p24B),&dummy))return 1;
   strncpy(last4,(fn+strlen(fn)-4),4);
   if(strncmp((char *)last4,".gif",4) == 0)isgif=1;
   if(strncmp((char *)last4,".tga",4) == 0)istga=1;
   if(strncmp((char *)last4,".tif",4) == 0)isext=1;
   if(strncmp((char *)last4,".jpg",4) == 0)isext=1;
   if(strncmp((char *)last4,".png",4) == 0)isext=1;
   if(strncmp((char *)last4,".bmp",4) == 0)isbmp=1;
   if     (isbmp)status=LoadExternalImageMap(mfname,ofname,map);
   else if(istga)status=LoadExternalImageMap(mfname,ofname,map);
   else if(isgif)status=LoadExternalImageMap(mfname,ofname,map);
   else          status=LoadExternalImageMap(mfname,ofname,map);
   if(status == 1)status=AddImageToImageStore(mfname,(map->xmax),(map->ymax),
                            (map->p24R),(map->p24G),(map->p24B),NULL);
   return status;
}

static short LoadExternalImageMap(char *fn, char *ofname, RenderIMAP *map){
 long x,y;
 FILE *t24;
 char lname[256],last3[8],dll[256],rep_name[256];
 HMODULE hLib;
 FARPROC fpFun;
 BOOL (*fpGetMapSize)(char *,
                      long *, long *, unsigned char *);
 BOOL (*fpGetMap)(char *,
                  long, long,
                  unsigned char *, unsigned char *, unsigned char *, unsigned char *);
 Render_Message(61,0,fn);
 strcpy(rep_name,"%%**%%"); //some dummy string that will never be a filename
 //MessageBox(NULL,ofname,"External Map Object",MB_OK);
 t24=GetRenderRelativeFile(fn,ofname,rep_name);
 if(t24 == NULL)return 0;
 fclose(t24);
 if(strcmp(rep_name,"%%**%%") != 0){ // string was replaced
   fn=rep_name;
 }
 strcpy(lname,gszHomeDir);
 strncpy(last3,(fn+strlen(fn)-3),3);
 last3[3]=0;  // to ensure end of string null
 sprintf(dll,"%s_map.dll",last3);
 strcat(lname,dll);
 hLib=AddLoadedLibrary(lname);
 //MessageBox(NULL,fn,lname,MB_OK);
 if(hLib != NULL){
   if((fpFun=GetProcAddress(hLib,"_GetExternalImageSize")) != NULL){
     fpGetMapSize = (void *)fpFun;
     if((*fpGetMapSize)(fn,&x,&y,NULL)){
       if((map->p24R = (unsigned char *)X__Malloc(x*y)) == NULL)goto CLOSEOUT;
       if((map->p24G = (unsigned char *)X__Malloc(x*y)) == NULL)goto CLOSEOUT;
       if((map->p24B = (unsigned char *)X__Malloc(x*y)) == NULL)goto CLOSEOUT;
       if((fpFun=GetProcAddress(hLib,"_GetExternalImage")) != NULL){
         fpGetMap = (void *)fpFun;
         if(!(*fpGetMap)(fn,x,y,map->p24R,map->p24G,map->p24B,NULL))goto CLOSEOUT;
       }
       else goto CLOSEOUT;
     }
     else goto CLOSEOUT;
   }
   else goto CLOSEOUT;
 }
 else return 0;
 // Use this to make small image maps for OpenGL mapping  - comment out if not in use
 MakeScaledImage(FALSE,&x,&y,&(map->p24R),&(map->p24G),&(map->p24B));
 map->xmax = (short)x;
 map->ymax = (short)y;
 //{char ttt[256]; sprintf(ttt,"map size %ld %ld  [%s] [%s]",x,y,fn,lname);
 //MessageBox(NULL,ttt,"Load External",MB_OK);}
 return 1;
 CLOSEOUT:
 if(map->p24R != NULL)X__Free(map->p24R); map->p24R = NULL;
 if(map->p24G != NULL)X__Free(map->p24G); map->p24G = NULL;
 if(map->p24B != NULL)X__Free(map->p24B); map->p24B = NULL;
 Render_Message(62,0,fn);
 return 0;
}

unsigned char *LoadSystemMAP(BOOL bScale, BOOL b32, char *fn, long *xx,long *yy){ // Load a default map from file THIS FILE MUST EXIST
 unsigned char *pix;
 unsigned char *R,*G,*B,*A=NULL;
 long x,y;
 char lname[256],last3[8],dll[256],rep_name[256];
 HMODULE hLib;
 FARPROC fpFun;
 BOOL (*fpGetMapSize)(char *,
                      long *, long *, unsigned char *);
 BOOL (*fpGetMap)(char *,
                  long, long,
                  unsigned char *, unsigned char *, unsigned char *, unsigned char *);
 BOOL (*fpGetMap32)(char *,
                  long, long,
                  unsigned char *, unsigned char *, unsigned char *, unsigned char *, unsigned char *);
 strcpy(lname,gszHomeDir);
 strncpy(last3,(fn+strlen(fn)-3),3);
 last3[3]=0;  // to ensure end of string null
 sprintf(dll,"%s_map.dll",last3);
 strcat(lname,dll);
 hLib=AddLoadedLibrary(lname);
 //MessageBox(NULL,fn,lname,MB_OK);
 if(hLib != NULL){
   if((fpFun=GetProcAddress(hLib,"_GetExternalImageSize")) != NULL){
     fpGetMapSize = (void *)fpFun;
     if((*fpGetMapSize)(fn,&x,&y,NULL)){
       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(b32){
         if((A = (unsigned char *)X__Malloc(x*y)) == NULL)goto CLOSEOUT;
         if((fpFun=GetProcAddress(hLib,"_GetExternalImageA")) != NULL){
           fpGetMap32 = (void *)fpFun;
           if(!(*fpGetMap32)(fn,x,y,R,G,B,A,NULL))goto CLOSEOUT;
         }
         else goto CLOSEOUT;
       }
       else{
         if((fpFun=GetProcAddress(hLib,"_GetExternalImage")) != NULL){
           fpGetMap = (void *)fpFun;
           if(!(*fpGetMap)(fn,x,y,R,G,B,NULL))goto CLOSEOUT;
         }
         else goto CLOSEOUT;
       }
     }
     else goto CLOSEOUT;
   }
   else goto CLOSEOUT;
 }
 else return NULL;
 if(bScale)pix=MakeScaledImage(TRUE,&x,&y,&R,&G,&B);
 else if(!b32)pix=MakeUnscaledImage(b32,x,y,&R,&G,&B,NULL);
 else         pix=MakeUnscaledImage(b32,x,y,&R,&G,&B,&A);  // 32 bit with alpha channel
 *xx = x;
 *yy = y;
 if(R != NULL)X__Free(R); 
 if(G != NULL)X__Free(G); 
 if(B != NULL)X__Free(B);
 if(b32 && A != NULL)X__Free(A); 
 //{char ttt[256]; sprintf(ttt,"map size %ld %ld  [%s] [%s]",x,y,fn,lname);
 //MessageBox(NULL,ttt,"Load System Map",MB_OK);}
 return pix;
 CLOSEOUT:
 if(R != NULL)X__Free(R); 
 if(G != NULL)X__Free(G); 
 if(B != NULL)X__Free(B); 
 if(b32 && A != NULL)X__Free(A); 
 return NULL;
}

#define MIPMAP1 1024
#define MIPMAP2 MIPMAP1/2
#define MIPMAP3 MIPMAP1/4
#define MIPMAP4 MIPMAP1/8
#define MIPMAP5 MIPMAP1/16
#define MIPMAP6 MIPMAP1/32

static unsigned char *MakeScaledImage(BOOL combined, long *xx, long *yy,
          unsigned char **RR, unsigned char **GG, unsigned char **BB){
 long imagesize,i,j,x,y,xi,yi;
 unsigned char *R,*G,*B;
 unsigned char *r,*g,*b;
 unsigned char *p, *px;
 x = *xx; y = *yy;
 R = *RR; G = *GG; B = *BB;
 imagesize = x*y*3;
 if((p=(unsigned char *)X__Malloc(imagesize+3)) == NULL){
   return NULL;
 }
//if(debug != NULL)fprintf(debug,"Scaling image from %ld %ld\n",x,y);
 for(j=0;j<y;j++){  // combine the colour components
  px=(p+(y-j-1)*x*3);
  r=(R+j*x); g=(G+j*x); b=(B+j*x);
  for(i=0;i<x;i++){
    *px++ = *r++;
    *px++ = *g++;
    *px++ = *b++;
  }
 }
 X__Free(R); *RR = NULL; 
 X__Free(G); *GG = NULL;
 X__Free(B); *BB = NULL;
 *xx = 0; *yy = 0;

 if(x < MIPMAP5)xi=MIPMAP6; else 
 if(x < MIPMAP4)xi=MIPMAP5; else 
 if(x < MIPMAP3)xi=MIPMAP4; else 
 if(x < MIPMAP2)xi=MIPMAP3; else 
 if(x < MIPMAP1)xi=MIPMAP2; else xi=MIPMAP1;
 if(y < MIPMAP5)yi=MIPMAP6; else 
 if(y < MIPMAP4)yi=MIPMAP5; else 
 if(y < MIPMAP3)yi=MIPMAP4; else 
 if(y < MIPMAP2)yi=MIPMAP3; else 
 if(y < MIPMAP1)yi=MIPMAP2; else yi=MIPMAP1;
  //xi=yi=64; 
 if((px=(unsigned char *)X__Malloc(xi*yi*3)) == NULL){
   X__Free((char *)p);
   return NULL;
 }
 ScaleImageBuffer3(x,y,p,xi,yi,px); // Our own scaling function
 X__Free((char *)p);
 //px=p; xi=x; yi=y; // this line substitutes for the two above if no scaling used
 *xx = xi; *yy = yi;
 if(combined)return px;
 x= xi; y=yi;
 if((R = (unsigned char *)X__Malloc(x*y)) != NULL){
   if((G = (unsigned char *)X__Malloc(x*y)) != NULL){
     if((B = (unsigned char *)X__Malloc(x*y)) != NULL){
       for(j=0;j<y;j++){  // combine the colour components
         p=(px+(y-j-1)*x*3);
         r=(R+j*x); g=(G+j*x); b=(B+j*x);
         for(i=0;i<x;i++){
           *r++ = *p++;
           *g++ = *p++;
           *b++ = *p++;
         }
       }
     }
     else{X__Free(G); X__Free(R); G=NULL; R=NULL;}
   }
   else {X__Free(R); R=NULL;}
 }
 *RR = R;
 *GG = G;
 *BB = B;
 *xx = x; *yy = y;
 X__Free(px);
 //if(debug != NULL)fprintf(debug,"Scaled down to %ld %ld\n",x,y);
 return NULL;
}


static unsigned char *MakeUnscaledImage(BOOL b32, long xx, long yy,
          unsigned char **RR, unsigned char **GG, unsigned char **BB, unsigned char **AA){
 long imagesize,i,j,x,y,xi,yi;
 unsigned char *R,*G,*B,*A;
 unsigned char *r,*g,*b,*a;
 unsigned char *p, *px;
 x = xx; y = yy;
 R = *RR; G = *GG; B = *BB;
 if(b32){A = *AA; imagesize = x*y*4;}
 else  imagesize = x*y*3;
 if((p=(unsigned char *)X__Malloc(imagesize+3)) == NULL){
   return NULL;
 }
//if(debug != NULL)fprintf(debug,"Converting image to standard %ld %ld\n",x,y);
 if(b32){
  for(j=0;j<y;j++){  // combine the colour components
    px=(p+(y-j-1)*x*4);
    r=(R+j*x); g=(G+j*x); b=(B+j*x); a=(A+j*x);
    for(i=0;i<x;i++){
      *px++ = *r++;
      *px++ = *g++;
      *px++ = *b++;
      *px++ = *a++;
    }
  }
 }
 else{
  for(j=0;j<y;j++){  // combine the colour components
    px=(p+(y-j-1)*x*3);
    r=(R+j*x); g=(G+j*x); b=(B+j*x); 
    for(i=0;i<x;i++){
      *px++ = *r++;
      *px++ = *g++;
      *px++ = *b++;
    }
  }
 }
 X__Free(R); *RR = NULL; 
 X__Free(G); *GG = NULL;
 X__Free(B); *BB = NULL;
 if(b32){X__Free(A); *AA = NULL;}
 return p;
}


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 ScaleImageBuffer3(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){
 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 4 way 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);
}



void CompleteMovieMapLoading(long ObjectID, char *objectfilename){
 // Load any outstanding image maps that have been found as embedded maps
 // in the MFX file.
 int i,n;
 imap *Map;
 RenderIMAP temp_map,*map;
 map=&temp_map;
 if((n=Object[ObjectID].NoMaps) > 0 &&
    (Map=Object[ObjectID].Mbase) != NULL){
   for(i=0;i<n;i++,Map++){
     if(Map->bAnimS && Map->pp >= 0){
       //if(debug != NULL){fprintf(debug,"Getting Movie map parts for Map %ld Object[%s]\n",i,objectfilename); fflush(debug);}
       map->p24R=NULL; map->p24G=NULL; map->p24B=NULL;
       if(LoadExternalMovieFrame(Map->filename,objectfilename,map) == 1){
         Map->p24R=map->p24R; Map->p24G=map->p24G; Map->p24B=map->p24B;
         Map->xmax=map->xmax;
         Map->ymax=map->ymax;
         Map->bLoadedS=TRUE;
       }
       else Map->pp = -1;
     }
     if(Map->bAnimR && Map->rp >= 0){
       map->p24R=NULL; map->p24G=NULL; map->p24B=NULL;
       if(LoadExternalMovieFrame(Map->frefl,objectfilename,map) == 1){
         Map->p24Rrefl=map->p24R;
         Map->p24Grefl=map->p24G;
         Map->p24Brefl=map->p24B;
         Map->xmaxrefl=map->xmax;
         Map->ymaxrefl=map->ymax;
         Map->bLoadedR=TRUE;
       }
       else Map->rp = -1;
     }
     if(Map->bAnimB && Map->bp >= 0){
       map->p24R=NULL; map->p24G=NULL; map->p24B=NULL;
       if(LoadExternalMovieFrame(Map->fbump,objectfilename,map) == 1){
         Map->p24Rbump=map->p24R;
         Map->p24Gbump=map->p24G;
         Map->p24Bbump=map->p24B;
         Map->xmaxbump=map->xmax;
         Map->ymaxbump=map->ymax;
         Map->bLoadedB=TRUE;
       }
       else Map->bp = -1;
     }
     if(Map->bAnimT && Map->tp >= 0){
       map->p24R=NULL; map->p24G=NULL; map->p24B=NULL;
       if(LoadExternalMovieFrame(Map->ftran,objectfilename,map) == 1){
         Map->p24Rtran=map->p24R;
         Map->p24Gtran=map->p24G;
         Map->p24Btran=map->p24B;
         Map->xmaxtran=map->xmax;
         Map->ymaxtran=map->ymax;
         Map->bLoadedT=TRUE;
       }
       else Map->tp = -1;
     }
   }
 }
}

void FreeMovieMapImages(long ObjectID){
 int i,n;
 imap *Map;
 if((n=Object[ObjectID].NoMaps) > 0 &&
    (Map=Object[ObjectID].Mbase) != NULL){
   for(i=0;i<n;i++,Map++){
     if(Map->bAnimS && Map->pp >= 0){
       //if(debug != NULL){fprintf(debug,"Freeing Movie map parts for Map %ld\n",i); fflush(debug);}
       if(Map->p24R != NULL)X__Free(Map->p24R); Map->p24R=NULL;
       if(Map->p24G != NULL)X__Free(Map->p24G); Map->p24G=NULL;
       if(Map->p24B != NULL)X__Free(Map->p24B); Map->p24B=NULL;
       Map->bLoadedS=FALSE;
     }
     if(Map->bAnimR && Map->rp >= 0){
       if(Map->p24R != NULL)X__Free(Map->p24Rrefl); Map->p24Rrefl=NULL;
       if(Map->p24G != NULL)X__Free(Map->p24Grefl); Map->p24Grefl=NULL;
       if(Map->p24B != NULL)X__Free(Map->p24Brefl); Map->p24Brefl=NULL;
       Map->bLoadedR=FALSE;
     }
     if(Map->bAnimB && Map->bp >= 0){
       if(Map->p24R != NULL)X__Free(Map->p24Rbump); Map->p24Rbump=NULL;
       if(Map->p24G != NULL)X__Free(Map->p24Gbump); Map->p24Gbump=NULL;
       if(Map->p24B != NULL)X__Free(Map->p24Bbump); Map->p24Bbump=NULL;
       Map->bLoadedB=FALSE;
     }
     if(Map->bAnimT && Map->tp >= 0){
       if(Map->p24R != NULL)X__Free(Map->p24Rtran); Map->p24Rtran=NULL;
       if(Map->p24G != NULL)X__Free(Map->p24Gtran); Map->p24Gtran=NULL;
       if(Map->p24B != NULL)X__Free(Map->p24Btran); Map->p24Btran=NULL;
       Map->bLoadedT=FALSE;
     }
   }
 }
}

static short LoadExternalMovieFrame(char *fn, char *ofname, RenderIMAP *map){
 long x,y;
 FILE *t24;
 char lname[256],rep_name[256];
 HMODULE hLib;
 FARPROC fpFun;
 BOOL (*fpGetMapSize)(char *,
                      long *, long *, long);
 BOOL (*fpGetMap)(char *,
                  long, long,
                  unsigned char *, unsigned char *, unsigned char *, long);
 Render_Message(61,0,fn);
 strcpy(rep_name,"%%**%%"); //some dummy string that will never be a filename
 //MessageBox(NULL,ofname,"External Map Object",MB_OK);
 t24=GetRenderRelativeFile(fn,ofname,rep_name);
 if(t24 == NULL)return 0;
 fclose(t24);
 if(strcmp(rep_name,"%%**%%") != 0){ // string was replaced
   fn=rep_name;
 }
 strcpy(lname,gszHomeDir);
 strcat(lname,"avi_map.dll");
 hLib=AddLoadedLibrary(lname);
 //MessageBox(NULL,fn,lname,MB_OK);
 if(hLib != NULL){
   if((fpFun=GetProcAddress(hLib,"_GetExternalImageSize")) != NULL){
     fpGetMapSize = (void *)fpFun;
     if((*fpGetMapSize)(fn,&x,&y,RenderCurrentFrame)){
       //if(debug != NULL)fprintf(debug,"Loading AVI [%s] size %ld by %ld frame %ld\n",fn,x,y,RenderCurrentFrame);
       if((map->p24R = (unsigned char *)X__Malloc(x*y)) == NULL)goto CLOSEOUT;
       if((map->p24G = (unsigned char *)X__Malloc(x*y)) == NULL)goto CLOSEOUT;
       if((map->p24B = (unsigned char *)X__Malloc(x*y)) == NULL)goto CLOSEOUT;
       if((fpFun=GetProcAddress(hLib,"_GetExternalImage")) != NULL){
         fpGetMap = (void *)fpFun;
         if(!(*fpGetMap)(fn,x,y,map->p24R,map->p24G,map->p24B,RenderCurrentFrame))goto CLOSEOUT;
       }
       else goto CLOSEOUT;
     }
     else goto CLOSEOUT;
   }
   else goto CLOSEOUT;
 }
 else return 0;

 MakeScaledImage(FALSE,&x,&y,&(map->p24R),&(map->p24G),&(map->p24B)); 

 map->xmax = (short)x;
 map->ymax = (short)y;
//{int i,j; unsigned char *r, *b, *g; r=map->p24B; g=map->p24G; b=map->p24B; 
// for(i=0;i<y;i++)for(j=0;j<x;j++){*r++=0; *g++=0; *b++=255;} }
 //if(debug != NULL)fprintf(debug,"Loaded AVI [%s] size %ld by %ld frame %ld\n",fn,x,y,RenderCurrentFrame);
 return 1;
 CLOSEOUT:
 //if(debug != NULL)fprintf(debug,"Failed to load movie frame\n");
 if(map->p24R != NULL)X__Free(map->p24R); map->p24R = NULL;
 if(map->p24G != NULL)X__Free(map->p24G); map->p24G = NULL;
 if(map->p24B != NULL)X__Free(map->p24B); map->p24B = NULL;
 Render_Message(62,0,fn);
 return 0;
}