XVIDEO.C

Go to the documentation of this file.

/* --
OpenFX version
-- */

/* XVIDEO  Image post-processor using Z buffer                            */

#include <stdlib.h>
#include <stdio.h>
#include <float.h>
#include <math.h>
#include <windows.h>
#include <commctrl.h>
#include "struct.h"           /* general structures    */
#include "..\common\postprocess\ximage.h"           /* XIMAGE structure      */
#include "local.h"

#include "xvideo.h"

static long version=0;

#if __X__MIPS__
BOOL WINAPI _CRT_INIT(HINSTANCE ,DWORD , LPVOID );
#endif

static HINSTANCE hDLLinstance=NULL; /* use to pick up resources from DLL  */

#include "utils.h"
#include "paint.c"

#include "..\animate\wspaces.c"

#include "video1.c"

#define imod(z,a) ((z) - ((z)/(a))*(a))

unsigned char *LoadMAP(char *name, int *x, int *y);

#if __WATCOMC__
int APIENTRY LibMain(HANDLE hDLL, DWORD dwReason, LPVOID lpReserved){
#elif __BC__
BOOL WINAPI DllEntryPoint(HANDLE hDLL, DWORD dwReason, LPVOID lpReserved){
#else
BOOL WINAPI DllMain(HANDLE hDLL, DWORD dwReason, LPVOID lpReserved){
#endif
  switch (dwReason) {
    case DLL_PROCESS_ATTACH:
#if __X__MIPS__
      if(!_CRT_INIT(hDLL,dwReason,lpReserved))return(int)FALSE;
#endif
      hDLLinstance = hDLL;  /* handle to DLL file */
      break;
    case DLL_PROCESS_DETACH:
#if __X__MIPS__
      if(!_CRT_INIT(hDLL,dwReason,lpReserved))return(int)FALSE;
#endif
      break;
  }
return (int)TRUE;
}

#if __SC__
#pragma startaddress(DllMain)
#endif

static void TwoByTwo(double mr, fullscreenbuffer *Screen, long Xmax, long Ymax,
                long nx, long ny, long R, long G, long B, long type,
                fullscreenbuffer *Bb){
 vector p,Mn={0.0,0.0,1.0},Mx,My,Mp[50];
 double r,g,b;
 long i,j,k,w,border,dx,dy,x,y;
 fullscreenbuffer *S,*T,*Tcreen, *bb;
 if((Tcreen=(fullscreenbuffer *)X__Malloc(Xmax*Ymax*sizeof(fullscreenbuffer))) == NULL){
   MessageBeep(MB_OK);
   return;
 }
 nx = min(10,nx);
 ny = min(5,ny);
 nx = 1+(nx-1)*mr;
 ny = 1+(ny-1)*mr;
 T=Tcreen; S=Screen;
 memset(T,0,Xmax*Ymax*sizeof(fullscreenbuffer));
 for(k=0;k<nx*ny;k++)Mp[k][2]=0.0;
 Mx[2]=My[2]=p[2]=Mx[1]=My[0]=0.0;
 border=(2*Xmax)/320;
 dx=(Xmax-(nx+1)*border)/nx;
 dy=(Ymax-(ny+1)*border)/ny;
 Mx[0]=dx; My[1]=dy;
 y=border; k=0;for(j=0;j<ny;j++){
   x=border;
   for(i=0;i<nx;i++){
     Mp[k][0]=x;
     Mp[k][1]=y;
     x += (dx+border);
     k++;
   }
   y += (dy+border);
 }
 for(i=0;i<Ymax;i++)for(j=0;j<Xmax;j++){
   p[0]=(double)j;
   p[1]=(double)i;
   for(k=0;k<nx*ny;k++){
     if((w=MapFrom(p,Mp[k],Mx,My,Mn,Screen,Xmax,Ymax,&r,&g,&b)) > 0){
       T->R=(unsigned char)r;
       T->G=(unsigned char)g;
       T->B=(unsigned char)b;
       goto NEXTPIXEL;
     }
   }
   if(Bb != NULL){
     bb=(Bb+i*Xmax+j);
     T->R=(unsigned char)bb->R;
     T->G=(unsigned char)bb->G;
     T->B=(unsigned char)bb->B;
   }
   else{
     T->R=(unsigned char)R;
     T->G=(unsigned char)G;
     T->B=(unsigned char)B;
   }
   NEXTPIXEL:
   T->A=S->A;
   S++;
   T++;
 }
 memcpy(Screen,Tcreen,Xmax*Ymax*sizeof(fullscreenbuffer));
 X__Free(Tcreen);
}

static void WipeRandomBlocks(double mr, fullscreenbuffer *S,
                     long Xmax, long Ymax,
                     long nnx, long nny, long R, long G, long B,
                     fullscreenbuffer *Bb){
 long i,j,k,l,nx,ny,n,nb,ii,jj,id,*blockid;
 fullscreenbuffer *s,*bb;
 if(nnx < 1 || nny < 1 || nnx > Xmax || nny > Ymax || nnx > 64 || nny > 64)return;
 nx = Xmax/nnx; ny=Ymax/nny;
 if(nx*nnx < Xmax)nx++;
 if(ny*nny < Ymax)ny++;
 ii=0; for(i=0;i<Ymax;i+=ny){jj=0;for(j=0;j<Xmax;j+=nx){jj++;}ii++;}nb=ii*jj;
 if((blockid = (long *)X__Malloc(nb*sizeof(long))) == NULL)return;
 for(i=0;i<nb;i++)blockid[i]=i;
 n=(long)((double)nnx*(double)nny*mr);
 ii=nb-1; for(i=0;i<n;i++){
   id=(long)(((double)rand()*(double)ii)/32767.0);
   for(j=0;j<nb;j++){
     if(blockid[j] == id)blockid[j]= -1;
     else if(blockid[j] > id)blockid[j]=blockid[j]-1;
   }
   ii--;
 }
 ii=0;
 for(i=0;i<Ymax;i+=ny){
   jj=0;
   for(j=0;j<Xmax;j+=nx){
     id=ii*nnx+jj;
     for(k=i;k<i+ny;k++)for(l=j;l<j+nx;l++){
       if(id < nb && blockid[id] < 0 && l < Xmax && k < Ymax){
         s=(S+k*Xmax+l);
         if(Bb != NULL){
           bb=(Bb+k*Xmax+l);
           s->R=(unsigned char)bb->R;
           s->G=(unsigned char)bb->G;
           s->B=(unsigned char)bb->B;
         }
         else{
           s->R = (unsigned char)R;
           s->G = (unsigned char)G;
           s->B = (unsigned char)B;
         }
       }
     }
     jj++;
   }
   ii++;
 }
 X__Free(blockid);
 return;
}


static void GetP(vector pc, vector d, vector Mp, vector Mn, vector p){
 double mu;
 vector dp;
 VECSUB(Mp,pc,dp)
 mu=DOT(Mn,dp)/DOT(Mn,d);
 VECSCALE(mu,d,d)
 VECSUM(pc,d,p)
}

static void FoldPiP(double mr, fullscreenbuffer *Screen, long Xmax, long Ymax,
                long nx, long ny, long R, long G, long B, long type,
                fullscreenbuffer *Bb){
 vector p,pc,d,Mn={0.0,0.0,1.0},Mx,My,Mp,x,y,n,wt,Mw={1.0,0.0,0.0};
 double r,g,b;
 long i,j,w;
 double Tx[4][4],Ta[4][4],Tb[4][4],Ts[4][4],angle,ss;
 vector Mxx;
 fullscreenbuffer *T,*Tcreen,*bb;
 if((Tcreen=(fullscreenbuffer *)X__Malloc(Xmax*Ymax*sizeof(fullscreenbuffer))) == NULL){
   MessageBeep(MB_OK);
   return;
 }
 memset(Tcreen,0,Xmax*Ymax*sizeof(fullscreenbuffer));
 Mp[2]=Mx[2]=My[2]=p[2]=0.0;
 Mx[1]=0.0; My[0]=0.0;
 nx = max(nx,0);
 angle = nx*mr;
 angle *= PI/180.0;
 if(type > 0){ // spin - rotate - tumble small
   Mx[0]=(double)Xmax;
   My[1]=(double)Ymax;
   Mp[0]=0.0;
   Mp[1]=0.0;
   tram(Ta,-(double)Xmax*0.5,-(double)Ymax*0.5,0.0);
   if(type == 1)roty(Tx,angle);
   if(type == 2)rotz(Tx,angle);
   if(type == 3)rotx(Tx,-angle);
   if(type == 4){ // wild tumble
     rotz(Tx,angle);
     m4by1(Tx,Mw,wt);
     rotate_round_vector(angle*180.0/PI,wt,Tx);
   }
   m4by4(Tx,Ta,Tb);
   ny=min(ny,100);
   ss=(double)ny * 0.01;
   ss=1.0-mr*(1.0-ss);
   scal(Ts,ss,ss,ss);
   m4by4(Ts,Tb,Ta);
   tram(Tx,(double)Xmax*0.5,(double)Ymax*0.5,0.0);
   m4by4(Tx,Ta,Tb);
   m4by1(Tb,Mx,x);
   m4by1(Tb,My,y);
   VECCOPY(Mp,Mxx)
   m4by1(Tb,Mxx,Mp);
   VECSUB(x,Mp,Mx)
   VECSUB(y,Mp,My)
   m4by1(Tb,Mn,n);
   VECSUB(n,Mp,Mn);
 }
 T=Tcreen;
 for(i=0;i<Ymax;i++)for(j=0;j<Xmax;j++){
   pc[0] = (double)(Xmax/2);
   pc[1] = (double)(Ymax/2);
   pc[2] = (double)(-Xmax*2);
   d[0]  = (double)(j-Xmax/2);
   d[1]  = (double)(i-Ymax/2);
   d[2]  = -pc[2];
   GetP(pc,d,Mp,Mn,p);
   if((w=MapFrom(p,Mp,Mx,My,Mn,Screen,Xmax,Ymax,&r,&g,&b)) > 0){
     T->R=(unsigned char)r;
     T->G=(unsigned char)g;
     T->B=(unsigned char)b;
   }
   else if(Bb != NULL){
     bb=(Bb+i*Xmax+j);
     T->R=(unsigned char)bb->R;
     T->G=(unsigned char)bb->G;
     T->B=(unsigned char)bb->B;
   }
   else{
     T->R=(unsigned char)R;
     T->G=(unsigned char)G;
     T->B=(unsigned char)B;
   }
   T++;
 }
 memcpy(Screen,Tcreen,Xmax*Ymax*sizeof(fullscreenbuffer));
 X__Free(Tcreen);
}

static void Inlay(double mr, fullscreenbuffer *S, long Xmax, long Ymax,
                   long R, long G, long B, fullscreenbuffer *Bb){
 long i,j;
 double mix;
 for(i=0;i<Ymax;i++)for(j=0;j<Xmax;j++){
   if(S->A > 0){
     mix = (double)S->A*3.921568e-3*mr;
     if(Bb != NULL){
       S->R = (unsigned char)((double)(S->R)*(1.0-mix)+(double)Bb->R*mix);
       S->G = (unsigned char)((double)(S->G)*(1.0-mix)+(double)Bb->G*mix);
       S->B = (unsigned char)((double)(S->B)*(1.0-mix)+(double)Bb->B*mix);
     }
     else{
       S->R = (unsigned char)((double)(S->R)*(1.0-mix)+(double)R*mix);
       S->G = (unsigned char)((double)(S->G)*(1.0-mix)+(double)G*mix);
       S->B = (unsigned char)((double)(S->B)*(1.0-mix)+(double)B*mix);
     }
   }
   S++;
   if(Bb != NULL)Bb++;
 }
 return;
}

static void Slice(double mr, long ny,
                   fullscreenbuffer *S, long Xmax, long Ymax,
                   long R, long G, long B, fullscreenbuffer *Bb){
 BOOL right;
 long i,j,k,dy,dx;
 fullscreenbuffer *s,*b;
 fullscreenbuffer *T,*t;
 dy=Ymax/max(1,ny);
 dx=(long)((double)Xmax*mr);
 if((T=(fullscreenbuffer *)X__Malloc(Xmax*Ymax*sizeof(fullscreenbuffer))) == NULL){
   MessageBeep(MB_OK);
   return;
 }
 right=TRUE;
 for(k=0;k<Ymax;k+=dy){
   for(i=k;i<k+dy;i++)for(j=0;j<Xmax;j++){
     if(i >= Ymax)continue;
     t=(T+i*Xmax+j);
     if(Bb != NULL)b=(Bb+i*Xmax+j);
     if(right){
       if(j > dx){
         if(j-dx < Xmax){
           s=(S+i*Xmax+j-dx);
           t->R = s->R;
           t->G = s->G;
           t->B = s->B;
         }
       }
       else if(Bb != NULL){
         t->R = b->R;
         t->G = b->G;
         t->B = b->B;
       }
       else{
         t->R = (unsigned char)R;
         t->G = (unsigned char)G;
         t->B = (unsigned char)B;
       }
     }
     else{
       if(j < Xmax-dx){
         if(j+dx < Xmax && j+dx >= 0){
           s=(S+i*Xmax+j+dx);
           t->R = s->R;
           t->G = s->G;
           t->B = s->B;
         }
       }
       else if(Bb != NULL){
         t->R = b->R;
         t->G = b->G;
         t->B = b->B;
       }
       else{
         t->R = (unsigned char)R;
         t->G = (unsigned char)G;
         t->B = (unsigned char)B;
       }
     }
   }
   right ^= 1;
 }
 memcpy(S,T,Xmax*Ymax*sizeof(fullscreenbuffer));
 X__Free(T);
 return;
}

static void FogIn(double mr, fullscreenbuffer *S, long Xmax, long Ymax,
                 long R, long G, long B,
                 fullscreenbuffer *Bb,
                 float *Zb){
 float *z;
 long i,j;
 double mix,zmin = FARAWAY, zmax = -FARAWAY,dz,zi,zj,dzz;
 if((z=Zb) == NULL)return;
 for(i=0;i<Ymax;i++)for(j=0;j<Xmax;j++){
   if(*z < FARAWAY-1000){
     if(*z < zmin)zmin = *z;
     if(*z > zmax)zmax = *z;
   }
   z++;
 }
 if((dz=zmax-zmin) == 0.0)return;
 dzz=dz/5.0;
 dz=dz+dzz;
 zj=zmin+dz*mr;
 zi=zj-dzz;
 z=Zb;
 for(i=0;i<Ymax;i++)for(j=0;j<Xmax;j++){
   if(*z > zi){
     if(*z > zj){
       if(Bb != NULL){
         S->R = Bb->R;
         S->G = Bb->G;
         S->B = Bb->B;
       }
       else{
         S->R = R;
         S->G = G;
         S->B = B;
       }
     }
     else{
       mix =  (*z - zi)/dzz;
       if(Bb != NULL){
         S->R = (unsigned char)((double)(S->R)*(1.0-mix)+(double)Bb->R*mix);
         S->G = (unsigned char)((double)(S->G)*(1.0-mix)+(double)Bb->G*mix);
         S->B = (unsigned char)((double)(S->B)*(1.0-mix)+(double)Bb->B*mix);
       }
       else{
         S->R = (unsigned char)((double)(S->R)*(1.0-mix)+(double)R*mix);
         S->G = (unsigned char)((double)(S->G)*(1.0-mix)+(double)G*mix);
         S->B = (unsigned char)((double)(S->B)*(1.0-mix)+(double)B*mix);
       }
     }
   }
   z++;
   S++;
   if(Bb != NULL)Bb++;
 }
 return;
}

static long *GenerateRandomSelection(long nb);
static void sRandom(long i);

static void WipeRandomBits(double mr, fullscreenbuffer *S,
                     long Xmax, long Ymax,
                     long nnx, long nny, long R, long G, long B,
                     fullscreenbuffer *Bb){
 long i,ii,j,jj,k,l,m,nx,ny,n,nb,id,*blockid;
 fullscreenbuffer *s,*bb;
 if(nnx < 1 || nny < 1 || nnx > Xmax || nny > Ymax)return;
// nx = Xmax/nnx; ny=Ymax/nny;
// if(nx*nnx < Xmax)nx++;
// if(ny*nny < Ymax)ny++;
 nx = nnx; ny=nny;  // nnx nny are bit size
 nnx = Xmax/nx;
 nny = Ymax/ny;
 ii=0; for(i=0;i<Ymax;i+=ny){jj=0;for(j=0;j<Xmax;j+=nx){jj++;}ii++;}nb=ii*jj;
 n=(long)((double)nnx*(double)nny*mr);
 if((blockid=GenerateRandomSelection(nb)) == NULL){
   MessageBeep(MB_OK);
   return;
 }
 for(m=0;m<n;m++){
   id=blockid[m];
   i=id/nnx;
   j=(id-(i*nnx));
   i=i*ny;
   j=j*nx;
   for(k=i;k<i+ny;k++)for(l=j;l<j+nx;l++){
     if(l < Xmax && k < Ymax){
       s=(S+k*Xmax+l);
       if(Bb != NULL){
         bb=(Bb+k*Xmax+l);
         s->R=(unsigned char)bb->R;
         s->G=(unsigned char)bb->G;
         s->B=(unsigned char)bb->B;
       }
       else{
         s->R = (unsigned char)R;
         s->G = (unsigned char)G;
         s->B = (unsigned char)B;
       }
     }
   }
 }
 X__Free(blockid);
 return;
}

#if 0
static void OldWhiteNoiseBackground(double mr,
                     long frame, fullscreenbuffer *S,
                     long Xmax, long Ymax,
                     long param,
                     long R, long G, long B,
                     fullscreenbuffer *Bb){
 double pc;
 long i,ii,j,jj,k,l,m,nx,ny,n,nb,id,*blockid,nny,nnx;
 fullscreenbuffer *s,*bb;
 param=min(param,100);
 pc = 0.005*(double)param*mr;
 ny = nx = (2*Xmax)/320; // size of noise particle
 nnx = Xmax/nx;          // nnx nny are number of blocks
 nny = Ymax/ny;
 ii=0; for(i=0;i<Ymax;i+=ny){jj=0;for(j=0;j<Xmax;j+=nx){jj++;}ii++;}nb=ii*jj;
 n=(long)((double)nnx*(double)nny)*pc;
 if(n == 0)return;
 n=min(n,nb);
 sRandom(frame);
 if((blockid=GenerateRandomSelection(nb)) == NULL){
   MessageBeep(MB_OK);
   return;
 }
 for(m=0;m<n;m++){
   id=blockid[m];
   i=id/nnx;
   j=(id-(i*nnx));
   i=i*ny;
   j=j*nx;
   for(k=i;k<i+ny;k++)for(l=j;l<j+nx;l++){
     if(l < Xmax && k < Ymax){
       s=(S+k*Xmax+l);
       if(s->A > 0)continue;
       if(Bb != NULL){
         bb=(Bb+k*Xmax+l);
         s->R=(unsigned char)bb->R;
         s->G=(unsigned char)bb->G;
         s->B=(unsigned char)bb->B;
       }
       else{
         s->R = (unsigned char)R;
         s->G = (unsigned char)G;
         s->B = (unsigned char)B;
       }
     }
   }
 }
 X__Free(blockid);
 return;
}
#endif

static void WhiteNoise(double mr,
                       long frame, fullscreenbuffer *S,
                       long Xmax, long Ymax,
                       long param,
                       long R, long G, long B,
                       BOOL include_foreground){
 double pc,r;
 long i,j,k,l,step,d;
 fullscreenbuffer *s,*bb;
 param=min(param,100);
 pc = 0.01*(double)param*mr;
 step=max(1,Xmax/320);
 srand(frame);
 for(i=0;i<Ymax;i+=step)for(j=0;j<Xmax;j+=step){
   r=(double)rand()/32767.0;
   d=min(255,(long)((rand()*255)/32767));
   for(k=i;k<i+step;k++)for(l=j;l<j+step;l++){
     if(k >= Ymax || l >= Xmax)continue;
     s=(S+k*Xmax+l);
     if(include_foreground || s->A < 64){
       if(r < pc){
         s->R = (unsigned char)d;
         s->G = (unsigned char)d;
         s->B = (unsigned char)d;
       }
     }
   }
 }
 return;
}

static void WipeLR(double mr, fullscreenbuffer *S, long Xmax, long Ymax,
                   long R, long G, long B, fullscreenbuffer *Bb){
 long i,j;
 long w,dx;
 fullscreenbuffer *bb;
 double f;
 dx=Xmax/5;
 w = -dx + (long)((double)(Xmax+dx)*mr);
 for(i=0;i<Ymax;i++){
   for(j=0;j<Xmax;j++){
     if(j < w){
       if(Bb != NULL){
         bb=(Bb+i*Xmax+j);
         S->R=(unsigned char)bb->R;
         S->G=(unsigned char)bb->G;
         S->B=(unsigned char)bb->B;
       }
       else{
         S->R = (unsigned char)R;
         S->G = (unsigned char)G;
         S->B = (unsigned char)B;
       }
     }
     else if(j < w+dx){
       f = 1.0-(double)(j-w)/(double)dx;
       if(Bb != NULL){
         bb=(Bb+i*Xmax+j);
         S->R = (unsigned char)((double)(S->R)*(1.0-f)+(double)bb->R*f);
         S->G = (unsigned char)((double)(S->G)*(1.0-f)+(double)bb->G*f);
         S->B = (unsigned char)((double)(S->B)*(1.0-f)+(double)bb->B*f);
       }
       else{
         S->R = (unsigned char)((double)(S->R)*(1.0-f)+(double)R*f);
         S->G = (unsigned char)((double)(S->G)*(1.0-f)+(double)G*f);
         S->B = (unsigned char)((double)(S->B)*(1.0-f)+(double)B*f);
       }
     }
     S++;
   }
 }
}

static void WipeRL(double mr, fullscreenbuffer *S, long Xmax, long Ymax,
                   long R, long G, long B, fullscreenbuffer *Bb){
 long i,j;
 long w,dx;
 fullscreenbuffer *bb;
 double f;
 dx=Xmax/5;
 w=Xmax-(long)((double)(Xmax+dx)*mr);
 for(i=0;i<Ymax;i++){
   for(j=0;j<Xmax;j++){
     if(j >= w+dx){
       if(Bb != NULL){
         bb=(Bb+i*Xmax+j);
         S->R=(unsigned char)bb->R;
         S->G=(unsigned char)bb->G;
         S->B=(unsigned char)bb->B;
       }
       else{
         S->R = (unsigned char)R;
         S->G = (unsigned char)G;
         S->B = (unsigned char)B;
       }
     }
     else if(j > w){
       f = (double)(j-w)/(double)dx;
       if(Bb != NULL){
         bb=(Bb+i*Xmax+j);
         S->R = (unsigned char)((double)(S->R)*(1.0-f)+(double)bb->R*f);
         S->G = (unsigned char)((double)(S->G)*(1.0-f)+(double)bb->G*f);
         S->B = (unsigned char)((double)(S->B)*(1.0-f)+(double)bb->B*f);
       }
       else{
         S->R = (unsigned char)((double)(S->R)*(1.0-f)+(double)R*f);
         S->G = (unsigned char)((double)(S->G)*(1.0-f)+(double)G*f);
         S->B = (unsigned char)((double)(S->B)*(1.0-f)+(double)B*f);
       }
     }
     S++;
   }
 }
}

static void xWipeToCentre(double mr, long nx,
                          fullscreenbuffer *S,
                          long Xmax, long Ymax,
                          long R, long G, long B,
                          fullscreenbuffer *Bb){
 long i,j;
 long w1,w2,dx;
 fullscreenbuffer *bb;
 double f;
 nx=max(1,nx);
 nx=min(100,nx);
 dx=(Xmax*nx)/100;
 w1 =  -dx + (long)((double)(Xmax/2+dx)*mr);
 w2 = Xmax + dx - (long)((double)(Xmax/2+dx)*mr);
 for(i=0;i<Ymax;i++){
   for(j=0;j<Xmax;j++){
     if(j < w1 || j >= w2){
       if(Bb != NULL){
         bb=(Bb+i*Xmax+j);
         S->R=(unsigned char)bb->R;
         S->G=(unsigned char)bb->G;
         S->B=(unsigned char)bb->B;
       }
       else{
         S->R = (unsigned char)R;
         S->G = (unsigned char)G;
         S->B = (unsigned char)B;
       }
     }
     else if(j < w1+dx || j >= w2-dx){
       if(j < Xmax/2)f = 1.0-(double)(j-w1)/(double)dx;
       else          f = (double)(j-(w2-dx))/(double)dx;
       if(Bb != NULL){
         bb=(Bb+i*Xmax+j);
         S->R = (unsigned char)((double)(S->R)*(1.0-f)+(double)bb->R*f);
         S->G = (unsigned char)((double)(S->G)*(1.0-f)+(double)bb->G*f);
         S->B = (unsigned char)((double)(S->B)*(1.0-f)+(double)bb->B*f);
       }
       else{
         S->R = (unsigned char)((double)(S->R)*(1.0-f)+(double)R*f);
         S->G = (unsigned char)((double)(S->G)*(1.0-f)+(double)G*f);
         S->B = (unsigned char)((double)(S->B)*(1.0-f)+(double)B*f);
       }
     }
     S++;
   }
 }
}

static void xWipeFromCentre(double mr, long nx,
                            fullscreenbuffer *S,
                            long Xmax, long Ymax,
                            long R, long G, long B,
                            fullscreenbuffer *Bb){
 long i,j;
 long w1,w2,dx;
 fullscreenbuffer *bb;
 double f;
 nx=max(1,nx);
 nx=min(100,nx);
 dx=(Xmax*nx)/100;
 w1 = Xmax/2 - (long)((double)(Xmax/2+dx)*mr);
 w2 = Xmax/2 + (long)((double)(Xmax/2+dx)*mr);
 for(i=0;i<Ymax;i++){
   for(j=0;j<Xmax;j++){
     if(j > w1+dx && j < w2-dx){
       if(Bb != NULL){
         bb=(Bb+i*Xmax+j);
         S->R=(unsigned char)bb->R;
         S->G=(unsigned char)bb->G;
         S->B=(unsigned char)bb->B;
       }
       else{
         S->R = (unsigned char)R;
         S->G = (unsigned char)G;
         S->B = (unsigned char)B;
       }
     }
     else if(j < w1 || j >= w2){;} // do nothing
     else {
       if(j < Xmax/2)f = (double)(j-w1)/(double)dx;
       else          f = 1.0-(double)(j-(w2-dx))/(double)dx;
       if(Bb != NULL){
         bb=(Bb+i*Xmax+j);
         S->R = (unsigned char)((double)(S->R)*(1.0-f)+(double)bb->R*f);
         S->G = (unsigned char)((double)(S->G)*(1.0-f)+(double)bb->G*f);
         S->B = (unsigned char)((double)(S->B)*(1.0-f)+(double)bb->B*f);
       }
       else{
         S->R = (unsigned char)((double)(S->R)*(1.0-f)+(double)R*f);
         S->G = (unsigned char)((double)(S->G)*(1.0-f)+(double)G*f);
         S->B = (unsigned char)((double)(S->B)*(1.0-f)+(double)B*f);
       }
     }
     S++;
   }
 }
}

static void yWipeToCentre(double mr, long ny,
                          fullscreenbuffer *S,
                          long Xmax, long Ymax,
                          long R, long G, long B,
                          fullscreenbuffer *Bb){
 long i,j;
 long w1,w2,dy;
 fullscreenbuffer *bb;
 double f;
 ny=max(1,ny);
 ny=min(100,ny);
 dy=(Ymax*ny)/100;
 w1 =  -dy + (long)((double)(Ymax/2+dy)*mr);
 w2 = Ymax + dy - (long)((double)(Ymax/2+dy)*mr);
 for(i=0;i<Ymax;i++){
   for(j=0;j<Xmax;j++){
     if(i < w1 || i >= w2){
       if(Bb != NULL){
         bb=(Bb+i*Xmax+j);
         S->R=(unsigned char)bb->R;
         S->G=(unsigned char)bb->G;
         S->B=(unsigned char)bb->B;
       }
       else{
         S->R = (unsigned char)R;
         S->G = (unsigned char)G;
         S->B = (unsigned char)B;
       }
     }
     else if(i < w1+dy || i >= w2-dy){
       if(i < Ymax/2)f = 1.0-(double)(i-w1)/(double)dy;
       else          f = (double)(i-(w2-dy))/(double)dy;
       if(Bb != NULL){
         bb=(Bb+i*Xmax+j);
         S->R = (unsigned char)((double)(S->R)*(1.0-f)+(double)bb->R*f);
         S->G = (unsigned char)((double)(S->G)*(1.0-f)+(double)bb->G*f);
         S->B = (unsigned char)((double)(S->B)*(1.0-f)+(double)bb->B*f);
       }
       else{
         S->R = (unsigned char)((double)(S->R)*(1.0-f)+(double)R*f);
         S->G = (unsigned char)((double)(S->G)*(1.0-f)+(double)G*f);
         S->B = (unsigned char)((double)(S->B)*(1.0-f)+(double)B*f);
       }
     }
     S++;
   }
 }
}

static void yWipeFromCentre(double mr, long ny,
                            fullscreenbuffer *S,
                            long Xmax, long Ymax,
                            long R, long G, long B,
                            fullscreenbuffer *Bb){
 long i,j;
 long w1,w2,dy;
 fullscreenbuffer *bb;
 double f;
 ny=max(1,ny);
 ny=min(100,ny);
 dy=(Ymax*ny)/100;
 w1 = Ymax/2 - (long)((double)(Ymax/2+dy)*mr);
 w2 = Ymax/2 + (long)((double)(Ymax/2+dy)*mr);
 for(i=0;i<Ymax;i++){
   for(j=0;j<Xmax;j++){
     if(i > w1+dy && i < w2-dy){
       if(Bb != NULL){
         bb=(Bb+i*Xmax+j);
         S->R=(unsigned char)bb->R;
         S->G=(unsigned char)bb->G;
         S->B=(unsigned char)bb->B;
       }
       else{
         S->R = (unsigned char)R;
         S->G = (unsigned char)G;
         S->B = (unsigned char)B;
       }
     }
     else if(i < w1 || i >= w2){;} // do nothing
     else {
       if(i < Ymax/2)f = (double)(i-w1)/(double)dy;
       else          f = 1.0-(double)(i-(w2-dy))/(double)dy;
       if(Bb != NULL){
         bb=(Bb+i*Xmax+j);
         S->R = (unsigned char)((double)(S->R)*(1.0-f)+(double)bb->R*f);
         S->G = (unsigned char)((double)(S->G)*(1.0-f)+(double)bb->G*f);
         S->B = (unsigned char)((double)(S->B)*(1.0-f)+(double)bb->B*f);
       }
       else{
         S->R = (unsigned char)((double)(S->R)*(1.0-f)+(double)R*f);
         S->G = (unsigned char)((double)(S->G)*(1.0-f)+(double)G*f);
         S->B = (unsigned char)((double)(S->B)*(1.0-f)+(double)B*f);
       }
     }
     S++;
   }
 }
}

static void CircularWipeToCentre(double mr, long nx,
                                 fullscreenbuffer *S,
                                 long X, long Y,
                                 long R, long G, long B,
                                 fullscreenbuffer *Bb){
 long i,j;
 fullscreenbuffer *bb;
 double r,rw,dr,f,rmax;
 nx=max(1,nx);
 nx=min(100,nx);
 rmax=sqrt((double)(Y/2)*(double)(Y/2)+(double)(X/2)*(double)(X/2));
 dr=(rmax*(double)nx)/100.0;
 rw = rmax+dr-(rmax+dr)*mr;
 for(i=0;i<Y;i++){
   for(j=0;j<X;j++){
     r=sqrt((double)(i-Y/2)*(double)(i-Y/2)+(double)(j-X/2)*(double)(j-X/2));
     if(r > rw){
       if(Bb != NULL){
         bb=(Bb+i*X+j);
         S->R=(unsigned char)bb->R;
         S->G=(unsigned char)bb->G;
         S->B=(unsigned char)bb->B;
       }
       else{
         S->R = (unsigned char)R;
         S->G = (unsigned char)G;
         S->B = (unsigned char)B;
       }
     }
     else if(r > rw-dr){
       f = (r-(rw-dr))/dr;
       if(Bb != NULL){
         bb=(Bb+i*X+j);
         S->R = (unsigned char)((double)(S->R)*(1.0-f)+(double)bb->R*f);
         S->G = (unsigned char)((double)(S->G)*(1.0-f)+(double)bb->G*f);
         S->B = (unsigned char)((double)(S->B)*(1.0-f)+(double)bb->B*f);
       }
       else{
         S->R = (unsigned char)((double)(S->R)*(1.0-f)+(double)R*f);
         S->G = (unsigned char)((double)(S->G)*(1.0-f)+(double)G*f);
         S->B = (unsigned char)((double)(S->B)*(1.0-f)+(double)B*f);
       }
     }
     S++;
   }
 }
}

static void CircularWipeFromCentre(double mr, long nx,
                                 fullscreenbuffer *S,
                                 long X, long Y,
                                 long R, long G, long B,
                                 fullscreenbuffer *Bb){
 long i,j;
 fullscreenbuffer *bb;
 double r,rw,dr,f,rmax;
 nx=max(1,nx);
 nx=min(100,nx);
 rmax=sqrt((double)(Y/2)*(double)(Y/2)+(double)(X/2)*(double)(X/2));
 dr=(rmax*(double)nx)/100.0;
 rw = (rmax+dr)*mr;
 for(i=0;i<Y;i++){
   for(j=0;j<X;j++){
     r=sqrt((double)(i-Y/2)*(double)(i-Y/2)+(double)(j-X/2)*(double)(j-X/2));
     if(r > rw){;}
     else if(r > rw-dr){
       f = 1.0-(r-(rw-dr))/dr;
       if(Bb != NULL){
         bb=(Bb+i*X+j);
         S->R = (unsigned char)((double)(S->R)*(1.0-f)+(double)bb->R*f);
         S->G = (unsigned char)((double)(S->G)*(1.0-f)+(double)bb->G*f);
         S->B = (unsigned char)((double)(S->B)*(1.0-f)+(double)bb->B*f);
       }
       else{
         S->R = (unsigned char)((double)(S->R)*(1.0-f)+(double)R*f);
         S->G = (unsigned char)((double)(S->G)*(1.0-f)+(double)G*f);
         S->B = (unsigned char)((double)(S->B)*(1.0-f)+(double)B*f);
       }
     }
     else{
       if(Bb != NULL){
         bb=(Bb+i*X+j);
         S->R=(unsigned char)bb->R;
         S->G=(unsigned char)bb->G;
         S->B=(unsigned char)bb->B;
       }
       else{
         S->R = (unsigned char)R;
         S->G = (unsigned char)G;
         S->B = (unsigned char)B;
       }
     }
     S++;
   }
 }
}

static void ScrollRight(long hold,long nx,
                        fullscreenbuffer *S,
                        long Xmax, long Ymax,
                        long tf, long ff, long lf){
 long i,j,w;
 fullscreenbuffer *B,*s,*b;
 double mr;
 mr=(double)(tf-ff)/(double)(lf-ff+1);
 if(hold == 1 || hold == 3)mr=(1.0-mr);
 w=(long)((double)((Xmax*nx)/100)*mr);
 B=(fullscreenbuffer *)X__Malloc(Xmax*sizeof(fullscreenbuffer));
 if(B != NULL){
   for(i=0;i<Ymax;i++){
     s=(S+i*Xmax); b=B;
     memcpy(b,s,Xmax*sizeof(fullscreenbuffer));
     s += w;
     for(j=w;j<Xmax;j++){
       s->R = b->R;
       s->G = b->G;
       s->B = b->B;
       s->A = b->A;
       b++; s++;
     }
     s=(S+i*Xmax);
     if(w > 0)for(j=0;j<w;j++){
       s->R = b->R;
       s->G = b->G;
       s->B = b->B;
       s->A = b->A;
       b++; s++;
     }
   }
   X__Free(B);
 }
}

static void ScrollDown(long hold,long ny,
                        fullscreenbuffer *S,
                        long Xmax, long Ymax,
                        long tf, long ff, long lf){
 long i,j,w;
 fullscreenbuffer *B,*s,*b;
 double mr;
 mr=(double)(tf-ff)/(double)(lf-ff+1);
 if(hold == 1 || hold == 3)mr=(1.0-mr);
 w=(long)((double)((Ymax*ny)/100)*mr);
 B=(fullscreenbuffer *)X__Malloc(Ymax*sizeof(fullscreenbuffer));
 if(B != NULL){
   for(i=0;i<Xmax;i++){
     for(j=0;j<Ymax;j++){
       b=(B+j); s=(S+j*Xmax+i);
       memcpy(b,s,sizeof(fullscreenbuffer));
     }
     for(j=w;j<Ymax;j++){
       b=(B+(j-w)); s=(S+j*Xmax+i);
       s->R = b->R;
       s->G = b->G;
       s->B = b->B;
       s->A = b->A;
     }
     if(w > 0)for(j=0;j<w;j++){
       b=(B+(Ymax-w+j)); s=(S+j*Xmax+i);
       s->R = b->R;
       s->G = b->G;
       s->B = b->B;
       s->A = b->A;
     }
   }
   X__Free(B);
 }
}

static void StirRound(double mr, long nx, BOOL linear,// nx = angle
                      fullscreenbuffer *S,
                      long X, long Y){
 long i,j,k,l,X2,Y2,X1,Y1;
 fullscreenbuffer *T,*t,*s;
 double r,rmax,anglemax,angle,dx,dy,as,ac,dxx,dyy,R,G,B;
 if((T=(fullscreenbuffer *)X__Malloc(X*Y*sizeof(fullscreenbuffer))) == NULL){
   MessageBeep(MB_OK);
   return;
 }
 rmax=min((double)(Y/2),(double)(X/2));
 anglemax=(double)nx*mr*PI/180.0;
 X1=X-1; Y1=Y-1; X2=X/2; Y2=Y/2;
 t=T;
 for(i=0;i<Y;i++){
   for(j=0;j<X;j++){
     dy=(double)(i-Y2);
     dx=(double)(j-X2);
     r=sqrt(dy*dy+dx*dx);
     if(r < rmax){
       if(linear)angle = anglemax*(1.0-r/rmax);
       else angle = anglemax*((rmax-r)/rmax)*((rmax-r)/rmax);
       as=sin(angle); ac=cos(angle);
       dxx=dx*ac-dy*as;
       dyy=dx*as+dy*ac;
       if(!Bilinear((double)X2+dxx,(double)Y2+dyy,S,X,Y,&R,&G,&B)){
         R=G=B=0.0;
       }
       t->R=(unsigned char)R;
       t->G=(unsigned char)G;
       t->B=(unsigned char)B;
       t->A=0;
#if 0
       k=Y2+(long)dyy;
       l=X2+(long)dxx;
       k=max(0,min(k,Y1));
       l=max(0,min(l,X1));
       s=(S+k*X+l);
       t->R=s->R;
       t->G=s->G;
       t->B=s->B;
       t->A=s->A;
#endif
     }
     else{
       s=(S+i*X+j);
       t->R=s->R;
       t->G=s->G;
       t->B=s->B;
       t->A=s->A;
     }
     t++;
   }
 }
 memcpy(S,T,X*Y*sizeof(fullscreenbuffer));
 X__Free(T);
}

long _RenderImageProcess(char *PrmList, XIMAGE *lpXimage){
 double mr;
 char name_path[256],imagefile[256];
 fullscreenbuffer *Screen,*BackBuffer;
 BOOL bMorph=FALSE;
 long cR,cG,cB,mcR,mcG,mcB,dummy,type,hold,back,lframe,nx,ny,Xmax,Ymax,frame;
#include "pro_key.c"
 sscanf(PrmList,"%s %ld %ld %ld %ld %ld %ld %ld %ld %ld %ld %s",name_path,
        &version,&type,&hold,
        &nx,&ny,&cR,&cG,&cB,&back,&lframe,imagefile);
 if(lpXimage->Morph && lpXimage->mParameters != NULL){
   bMorph=TRUE; mr=lpXimage->MorphRatio;
   sscanf(lpXimage->mParameters,
          "%s %ld %ld %ld %ld %ld %ld %ld %ld",
          name_path,&version,&dummy,&dummy,&dummy,&dummy,&dummy,
          &mcR,&mcG,&mcB);
 }
 if(!bMorph){
   mr=(double)(lpXimage->last_frame - lpXimage->first_frame);
   if(mr < 1.0)return 1;
   mr=(double)(lpXimage->this_frame - lpXimage->first_frame)/mr;
 }
 frame=lpXimage->this_frame - lpXimage->first_frame + 1;
 if     (hold == 1)mr=(1.0-mr);
 else if(hold == 2)mr=1.0;
 else if(hold == 3)mr=0.0;
 BackBuffer=NULL;
 Xmax=lpXimage->Xmax; Ymax=lpXimage->Ymax;
 if(back > 0){
   unsigned char *ImagePixels;
   int ImageXsize,ImageYsize;
   if(back == 2)GetAnimFileName(imagefile,name_path,
                     lpXimage->this_frame - lpXimage->first_frame + 1,
                     1,lframe,1);
   RestoreWhiteSpaces(imagefile);
   if((ImagePixels=LoadMAP(imagefile,&ImageXsize,&ImageYsize)) != NULL){
     BackBuffer=ScaleImageMap(ImagePixels,ImageXsize,ImageYsize,Xmax,Ymax);
     X__Free(ImagePixels);
   }
 }
 Screen=lpXimage->Screen;
 if(type ==  0)TwoByTwo(mr,Screen,Xmax,Ymax,nx,ny,cR,cG,cB,0,NULL);
 if(type ==  1)WipeRandomBlocks(mr,Screen,Xmax,Ymax,nx,ny,cR,cG,cB,BackBuffer);
 if(type ==  2)FoldPiP(mr,Screen,Xmax,Ymax,nx,ny,cR,cG,cB,2,BackBuffer); //r
 if(type ==  3)FoldPiP(mr,Screen,Xmax,Ymax,nx,ny,cR,cG,cB,1,BackBuffer); //s
 if(type ==  4)FoldPiP(mr,Screen,Xmax,Ymax,nx,ny,cR,cG,cB,3,BackBuffer); //t
 if(type ==  5)FoldPiP(mr,Screen,Xmax,Ymax,nx,ny,cR,cG,cB,4,BackBuffer); //w
 if(type ==  6)Inlay(mr,Screen,Xmax,Ymax,cR,cG,cB,BackBuffer);
 if(type ==  7)FogIn(mr,Screen,Xmax,Ymax,cR,cG,cB,BackBuffer,lpXimage->Zbuffer);
 if(type ==  8)WipeRandomBits(mr,Screen,Xmax,Ymax,nx,ny,cR,cG,cB,BackBuffer);
 if(type ==  9)WhiteNoise(mr,frame,Screen,Xmax,Ymax,nx,cR,cG,cB,TRUE);
 if(type == 10)WhiteNoise(mr,frame,Screen,Xmax,Ymax,nx,cR,cG,cB,FALSE);
 if(type == 11)Slice(mr,ny,Screen,Xmax,Ymax,cR,cG,cB,BackBuffer);
 if(type == 12)WipeLR(mr,Screen,Xmax,Ymax,cR,cG,cB,BackBuffer);
 if(type == 13)WipeRL(mr,Screen,Xmax,Ymax,cR,cG,cB,BackBuffer);
 if(type == 14)xWipeToCentre(mr,nx,Screen,Xmax,Ymax,cR,cG,cB,BackBuffer);
 if(type == 15)xWipeFromCentre(mr,nx,Screen,Xmax,Ymax,cR,cG,cB,BackBuffer);
 if(type == 16)yWipeToCentre(mr,ny,Screen,Xmax,Ymax,cR,cG,cB,BackBuffer);
 if(type == 17)yWipeFromCentre(mr,ny,Screen,Xmax,Ymax,cR,cG,cB,BackBuffer);
 if(type == 18)CircularWipeToCentre(mr,nx,Screen,Xmax,Ymax,cR,cG,cB,BackBuffer);
 if(type == 19)CircularWipeFromCentre(mr,nx,Screen,Xmax,Ymax,cR,cG,cB,BackBuffer);
 if(type == 20)ScrollRight(hold,nx,Screen,Xmax,Ymax,lpXimage->this_frame,
                              lpXimage->first_frame,lpXimage->last_frame);
 if(type == 21)ScrollDown(hold,ny,Screen,Xmax,Ymax,lpXimage->this_frame,
                              lpXimage->first_frame,lpXimage->last_frame);
 if(BackBuffer != NULL)X__Free(BackBuffer);
 if(type == 22)StirRound(mr,nx,FALSE,Screen,Xmax,Ymax);
 if(type == 23)StirRound(mr,-nx,FALSE,Screen,Xmax,Ymax);
 if(type == 24)StirRound(mr,nx,TRUE,Screen,Xmax,Ymax);
 if(type == 25)StirRound(mr,-nx,TRUE,Screen,Xmax,Ymax);
 return 1;
}

/*************** Function that renders any of the OpenGL Functionality ************/

long _RenderGLexternal(char *PrmList, XIMAGE *lpXimage){
MessageBox(NULL,"OpenGL function called","OK",MB_OK);
 return 1;
}
/**********************************************************************************/

BOOL CALLBACK DlgProc(HWND hwnd,UINT msg,WPARAM wparam,LPARAM lparam);

static long colour[3]={255,255,255};
static long type=0,hold=0,back=0,lframe=9999,nx=10,ny=10;
static char iname[256];
static X__MEMORY_MANAGER *lpLocalEVI;

char * _SetExternalParameters(
  char *Op,                 /* string for the parameters                  */
  HWND hWnd,                /* parent window                              */
  long ruler,               /* ruler scale value to facilitate scaling    */
  char *name,               /* name of DLL file with the effect           */
  X__MEMORY_MANAGER *lpEVI /* pointer to structure with memory functions */
                                    ){
 char buffer[1024];
 long id1,id2;   /* integer scaled radius value */
 strcpy(iname," ");
 if(Op != NULL){  /* parameters exist so read them off the list */
   sscanf(Op,"%s %ld %ld %ld %ld %ld %ld %ld %ld %ld %ld %s",buffer,&version,
          &type,&hold,&nx,&ny,&colour[0],&colour[1],&colour[2],
          &back,&lframe,iname);
 }
 lpLocalEVI=lpEVI;
 if(DialogBox(hDLLinstance,MAKEINTRESOURCE(DLG_VIDEO),hWnd,
              (DLGPROC)DlgProc) == FALSE)return Op;
 if(Op != NULL)CALL_FREE(Op);  /* free the old string */
 sprintf(buffer,"%s %ld %ld %ld %ld %ld %ld %ld %ld %ld %ld %s",
           name,version,type,hold,
           nx,ny,colour[0],colour[1],colour[2],back,lframe,iname);
 if((Op=(char *)CALL_MALLOC(strlen(buffer)+1)) == NULL){
  MessageBox (GetFocus(),"External effect: Out of memory","Error",
                MB_OK|MB_TASKMODAL|MB_ICONSTOP);
   return NULL;
 }
 strcpy(Op,buffer);
 return Op;
}

#define NVIDEO 26

static void LoadAnimatedClip(HWND hDlg,long id){
 char *c,str[32],modname[256];
 GetModuleFileName(hDLLinstance,modname,255);
 if((c=strrchr(modname,'.')) != NULL){
   sprintf(str,"%ld",id+1);
   strcpy(c,str);
   strcat(modname,".avi");
   Animate_Open(GetDlgItem(hDlg,DLG_IMAGE),modname);
   Animate_Play(GetDlgItem(hDlg,DLG_IMAGE),0, -1, -1);
 }
}

BOOL CALLBACK DlgProc(HWND hwnd,UINT msg,WPARAM wparam,LPARAM lparam){
 BOOL err;
 int i;
 char lname[256],text[512];
 static long type_list[NVIDEO]={
   DLG_VIDEO_1,
   DLG_VIDEO_2,
   DLG_VIDEO_3,
   DLG_VIDEO_4,
   DLG_VIDEO_5,
   DLG_VIDEO_6,
   DLG_VIDEO_7,
   DLG_VIDEO_8,
   DLG_VIDEO_9,
   DLG_VIDEO_10,
   DLG_VIDEO_11,
   DLG_VIDEO_12,
   DLG_VIDEO_13,
   DLG_VIDEO_14,
   DLG_VIDEO_15,
   DLG_VIDEO_16,
   DLG_VIDEO_17,
   DLG_VIDEO_18,
   DLG_VIDEO_19,
   DLG_VIDEO_20,
   DLG_VIDEO_21,
   DLG_VIDEO_22,
   DLG_VIDEO_23,
   DLG_VIDEO_24,
   DLG_VIDEO_25,
   DLG_VIDEO_26
 };
 static long text_list[NVIDEO]={
   IDX_VIDEO_1,
   IDX_VIDEO_2,
   IDX_VIDEO_3,
   IDX_VIDEO_4,
   IDX_VIDEO_5,
   IDX_VIDEO_6,
   IDX_VIDEO_7,
   IDX_VIDEO_8,
   IDX_VIDEO_9,
   IDX_VIDEO_10,
   IDX_VIDEO_11,
   IDX_VIDEO_12,
   IDX_VIDEO_13,
   IDX_VIDEO_14,
   IDX_VIDEO_15,
   IDX_VIDEO_16,
   IDX_VIDEO_17,
   IDX_VIDEO_18,
   IDX_VIDEO_19,
   IDX_VIDEO_20,
   IDX_VIDEO_21,
   IDX_VIDEO_22,
   IDX_VIDEO_23,
   IDX_VIDEO_24,
   IDX_VIDEO_25,
   IDX_VIDEO_26
 };
 switch( msg ) {
   case WM_INITDIALOG:
     if     (hold == 0)
       SendDlgItemMessage(hwnd,DLG_VIDEO_FADE_IN,BM_SETCHECK,TRUE,0);
     else if(hold == 1)
       SendDlgItemMessage(hwnd,DLG_VIDEO_FADE_OUT,BM_SETCHECK,TRUE,0);
     else if(hold == 2)
       SendDlgItemMessage(hwnd,DLG_VIDEO_HOLD_IN,BM_SETCHECK,TRUE,0);
     else if(hold == 3)
       SendDlgItemMessage(hwnd,DLG_VIDEO_HOLD_OUT,BM_SETCHECK,TRUE,0);
     for(i=0;i<NVIDEO;i++){
       LoadString(hDLLinstance,type_list[i],lname,256);
       SendDlgItemMessage(hwnd,DLG_VIDEO_LIST,LB_ADDSTRING,0,
                   (LPARAM)(LPCTSTR)lname);
     }
     SendDlgItemMessage(hwnd,DLG_VIDEO_LIST,LB_SETCURSEL,(WPARAM)type,0);
     if     (back == 0)
       SendDlgItemMessage(hwnd,DLG_VIDEO_PLAIN,BM_SETCHECK,TRUE,0);
     if     (back == 1)
       SendDlgItemMessage(hwnd,DLG_VIDEO_IMAGE,BM_SETCHECK,TRUE,0);
     if     (back == 2)
       SendDlgItemMessage(hwnd,DLG_VIDEO_ANIIMAGE,BM_SETCHECK,TRUE,0);
     strcpy(lname,iname);
     RestoreWhiteSpaces(lname);
     SetDlgItemText(hwnd,DLG_VIDEO_IMAGENAME,lname);
     SetDlgItemInt(hwnd,DLG_VIDEO_NX,nx,TRUE);
     SetDlgItemInt(hwnd,DLG_VIDEO_NY,ny,TRUE);
     SetDlgItemInt(hwnd,DLG_VIDEO_LASTFRAME,lframe,TRUE);
     LoadAnimatedClip(hwnd,type);
     LoadString(hDLLinstance,text_list[type],text,256);
     SendDlgItemMessage(hwnd,DLG_VIDEO_HELP,WM_SETTEXT,0,(LPARAM)text);
     CentreDialogOnScreen(hwnd);
   case WM_PAINT:
     PaintBackground(hwnd);
     break;
     return TRUE;
   case WM_DRAWITEM:{
       LPDRAWITEMSTRUCT lpdis;
       HBRUSH   hbr,hbrold;
       BYTE r,g,b;
       lpdis=(LPDRAWITEMSTRUCT)lparam;
       if(lpdis->CtlID == DLG_VIDEO_COLOUR){
         r=(BYTE)colour[0]; g=(BYTE)colour[1]; b=(BYTE)colour[2];
         if(lpdis->itemState & ODS_SELECTED)
            InvertRect(lpdis->hDC,&(lpdis->rcItem));
         else{
           hbr=CreateSolidBrush(RGB(r,g,b));
           hbrold=SelectObject(lpdis->hDC,hbr);
           Rectangle(lpdis->hDC,lpdis->rcItem.left,lpdis->rcItem.top,
                         lpdis->rcItem.right,lpdis->rcItem.bottom);
           SelectObject(lpdis->hDC,hbrold);
           DeleteObject(hbr);
         }
       }
     }
     break;
   case WM_COMMAND:
     switch(LOWORD(wparam)){
        case DLG_VIDEO_LIST:
          switch(HIWORD(wparam)){
            case LBN_SELCHANGE:{
               HWND hctl;
               hctl=GetDlgItem(hwnd,DLG_VIDEO_LIST);
               i=SendMessage(hctl,LB_GETCURSEL,0,0);
               LoadAnimatedClip(hwnd,i);
               LoadString(hDLLinstance,text_list[i],text,256);
               SendDlgItemMessage(hwnd,DLG_VIDEO_HELP,WM_SETTEXT,0,(LPARAM)text);
            }
            break;
            default: break;
          }
          break;
        case DLG_VIDEO_SETIMAGENAME:{
            strcpy(lname,iname);
            RestoreWhiteSpaces(lname);
            if(XimageFileName(lpLocalEVI->lpAni,lname,"gif",
                              "Choose First/Only Image File",
                              "All file formats|*.gif;*.tga|"
                              "Compuserve GIFs|*.gif|"
                              "Targa TGAs|*.tga|",
                              hwnd)){

              SetDlgItemText(hwnd,DLG_VIDEO_IMAGENAME,lname);
              HideWhiteSpaces(lname);
              strcpy(iname,lname);
            }
          }
          break;
        case DLG_VIDEO_COLOUR:
          SetColour(colour,hwnd);
          InvalidateRect(GetDlgItem(hwnd,DLG_VIDEO_COLOUR),NULL,FALSE);
          break;
        case IDCANCEL:
          EndDialog(hwnd,FALSE);
          return(TRUE);
        case IDOK:
          nx=GetDlgItemInt(hwnd,DLG_VIDEO_NX,&err,FALSE);
          ny=GetDlgItemInt(hwnd,DLG_VIDEO_NY,&err,FALSE);
          lframe=GetDlgItemInt(hwnd,DLG_VIDEO_LASTFRAME,&err,FALSE);
          if(SendDlgItemMessage(hwnd,DLG_VIDEO_FADE_IN,BM_GETCHECK,0,0))
            hold=0;
          if(SendDlgItemMessage(hwnd,DLG_VIDEO_FADE_OUT,BM_GETCHECK,0,0))
            hold=1;
          if(SendDlgItemMessage(hwnd,DLG_VIDEO_HOLD_IN,BM_GETCHECK,0,0))
            hold=2;
          if(SendDlgItemMessage(hwnd,DLG_VIDEO_HOLD_OUT,BM_GETCHECK,0,0))
            hold=3;
          if(SendDlgItemMessage(hwnd,DLG_VIDEO_ANIIMAGE,BM_GETCHECK,0,0))
            back=2;
          if(SendDlgItemMessage(hwnd,DLG_VIDEO_IMAGE,BM_GETCHECK,0,0))
            back=1;
          if(SendDlgItemMessage(hwnd,DLG_VIDEO_PLAIN,BM_GETCHECK,0,0))
            back=0;
          type=SendDlgItemMessage(hwnd,DLG_VIDEO_LIST,LB_GETCURSEL,0,0);
          EndDialog(hwnd,TRUE);
          return(TRUE);
        default:
          break;
      }
      break;
    default: break;
 }
 return FALSE;
}

#include "video2.c"

#undef double


static long IX=9123,IY=8844,IZ=20846;

static void  sRandom(long i){
 srand(i); IX=rand(); IY=rand(); IZ=rand();
}

static double Random(void){
 IX=imod(171*IX,30269);
 IY=imod(172*IY,20207);
 IZ=imod(170*IZ,30323);
 return (double)fmod((double)IX/30269.0+
                     (double)IY/30307.0+
                     (double)IZ/30323.0,1.0);
}

static void SortArray(long n, long *id, double *r){
 long i,j,gap,itemp;
 double rtemp;
 for (gap = n; gap > 0; gap /=2) {
   for (i = gap; i < n; i++) {
     for (j = i-gap; j >= 0 && *(r+j) < *(r+j+gap); j -= gap){
       rtemp = *(r+j);
       *(r+j) = *(r+j+gap);
       *(r+j+gap) = rtemp;
       itemp = *(id+j);
       *(id+j) = *(id+j+gap);
       *(id+j+gap) = itemp;
     }
   }
 }
}

static long *GenerateRandomSelection(long nb){
 /* Random selection of nb numbers in range [0, nb-1] returns pointer
    to array with randomly ordered intergers */
 long i,*blockid;
 double *blockV;
 if((blockid = (long *)X__Malloc(nb*sizeof(long))) == NULL)return NULL;
 if((blockV = (double *)X__Malloc(nb*sizeof(double))) == NULL){
   X__Free(blockid); return NULL;
 }
 for(i=0;i<nb;i++){
   blockid[i]=i;
   blockV[i]=Random();
 }
 SortArray(nb,blockid,blockV);
 X__Free(blockV);
 return blockid;
}