VIDEO.C

Go to the documentation of this file.

/* --
OpenFX version 2.0 - Modelling, Animation and Rendering Package
Copyright (C) 2000 - OpenFX Development Team

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

You may contact the OpenFX development team via elecronic mail
at core@openfx.org, or visit our website at http://openfx.org for
further information and support details.
-- */

/* VIDEO  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"
#include "local.h"

#include "video.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"

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 FadeTo(double mr, fullscreenbuffer *S, long Xmax, long Ymax,
                   long R, long G, long B, fullscreenbuffer *Bb){
 long i,j;
 if(Bb != NULL){
   for(i=0;i<Ymax;i++)for(j=0;j<Xmax;j++){
     S->R = (unsigned char)((double)(S->R)*(1.0-mr)+(double)Bb->R*mr);
     S->G = (unsigned char)((double)(S->G)*(1.0-mr)+(double)Bb->G*mr);
     S->B = (unsigned char)((double)(S->B)*(1.0-mr)+(double)Bb->B*mr);
     S++; Bb++;
   }
 }
 else {
   for(i=0;i<Ymax;i++)for(j=0;j<Xmax;j++){
     S->R = (unsigned char)((double)(S->R)*(1.0-mr)+(double)R*mr);
     S->G = (unsigned char)((double)(S->G)*(1.0-mr)+(double)G*mr);
     S->B = (unsigned char)((double)(S->B)*(1.0-mr)+(double)B*mr);
     S++;
   }
 }
}

static void WipeLR(double mr, fullscreenbuffer *S, long Xmax, long Ymax,
                   long R, long G, long B, fullscreenbuffer *Bb){
 long i,j;
 long w;
 fullscreenbuffer *bb;
 w=(long)((double)Xmax*mr)+1;
 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;
     }
   }
   S++;
 }
}

static void WipeUD(double mr, fullscreenbuffer *S, long Xmax, long Ymax,
                   long R, long G, long B, fullscreenbuffer *Bb){
 long i,j;
 long w;
 fullscreenbuffer *bb;
 w=(long)((double)Ymax*mr)+1;
 for(i=0;i<Ymax;i++)for(j=0;j<Xmax;j++){
   if(i < 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;
     }
   }
   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;
 fullscreenbuffer *bb;
 w=Xmax-(long)((double)Xmax*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;
    }
   }
   S++;
 }
}

static void WipeDU(double mr, fullscreenbuffer *S, long Xmax, long Ymax,
                   long R, long G, long B, fullscreenbuffer *Bb){
 long i,j;
 long w;
 fullscreenbuffer *bb;
 w=Ymax-(long)((double)Ymax*mr);
 for(i=0;i<Ymax;i++)for(j=0;j<Xmax;j++){
   if(i >= 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;
     }
   }
   S++;
 }
}

static void Desaturate(double mr, fullscreenbuffer *S, long Xmax, long Ymax,
                   long R, long G, long B){
 long i,j;
 double f;
 f=(double)(R+G+B)*0.33333333/255.0;
 for(i=0;i<Ymax;i++)for(j=0;j<Xmax;j++){
   S->R = min(255,(unsigned char)((double)(S->R)*f));
   S->G = min(255,(unsigned char)((double)(S->G)*f));
   S->B = min(255,(unsigned char)((double)(S->B)*f));
   S++;
 }
}

static void Monochrome(double mr, fullscreenbuffer *S, long Xmax, long Ymax,
                   long R, long G, long B){
 long i,j;
 double mono;
 for(i=0;i<Ymax;i++)for(j=0;j<Xmax;j++){
   mono=0.3333333*((double)S->R+(double)S->G+(double)S->B);
   S->R = (unsigned char)min(255.0,(double)(S->R)*(1.0-mr)+mono*mr);
   S->G = (unsigned char)min(255.0,(double)(S->G)*(1.0-mr)+mono*mr);
   S->B = (unsigned char)min(255.0,(double)(S->B)*(1.0-mr)+mono*mr);
   S++;
 }
}

static void Negative(double mr, fullscreenbuffer *S, long Xmax, long Ymax,
                   long R, long G, long B){
 long i,j;
 for(i=0;i<Ymax;i++)for(j=0;j<Xmax;j++){
   S->R = (unsigned char)((double)S->R*(1.0-mr)+(double)(255 - S->R)*mr);
   S->G = (unsigned char)((double)S->G*(1.0-mr)+(double)(255 - S->G)*mr);
   S->B = (unsigned char)((double)S->B*(1.0-mr)+(double)(255 - S->B)*mr);
   S++;
 }
}

static void Colourise(double mr, fullscreenbuffer *S, long Xmax, long Ymax,
                       long levels){
 long i,j,nx;
 unsigned char R,G,B;
 double h,s,v;
 for(i=0;i<Ymax;i++)for(j=0;j<Xmax;j++){
   Rgb2Hsv(S->R,S->G,S->B,&h,&s,&v);
   if     (v > 0.8)v=1.0;
   else if(v > 0.6)v=0.8;
   else if(v > 0.4)v=0.6;
   else if(v > 0.2)v=0.4;
   else v=0.1;
   if     (s > 0.8)s=1.0;
   else if(s > 0.6)s=0.8;
   else if(s > 0.4)s=0.6;
   else if(s > 0.2)s=0.4;
   else s=0.1;
   Hsv2Rgb(h,s,v,&R,&G,&B);
   S->R = (unsigned char)((double)S->R*(1.0-mr)+(double)R*mr);
   S->G = (unsigned char)((double)S->G*(1.0-mr)+(double)G*mr);
   S->B = (unsigned char)((double)S->B*(1.0-mr)+(double)B*mr);
   S++;
 }
}

static void ChangeHue(double mr, fullscreenbuffer *S, long Xmax, long Ymax,
                       long angle){
 long i,j;
 unsigned char R,G,B;
 double h,s,v;
 for(i=0;i<Ymax;i++)for(j=0;j<Xmax;j++){
   Rgb2Hsv(S->R,S->G,S->B,&h,&s,&v);
   h += (double)angle*mr;
   while(h > 360.0)h -= 360.0;
   Hsv2Rgb(h,s,v,&R,&G,&B);
   S->R = (unsigned char)min(255,R);
   S->G = (unsigned char)min(255,G);
   S->B = (unsigned char)min(255,B);
   S++;
 }
}

static void Pixelate(double mr, fullscreenbuffer *S, long Xmax, long Ymax,
                     long nxx, long nyy){
 long i,j,k,l,nx,ny,n;
 double Rav,Gav,Bav;
 fullscreenbuffer *s;
 if(nxx < 1 || nyy < 1 || nxx > Xmax || nyy > Ymax)return;
 nx = Xmax/nxx; ny=Ymax/nyy;
 if(nx*nxx < Xmax)nx++;
 if(ny*nyy < Ymax)ny++;
 nx=1+mr*(nx-1);
 ny=1+mr*(ny-1);
 for(i=0;i<Ymax;i+=ny)for(j=0;j<Xmax;j+=nx){
   Rav=Gav=Bav=0.0; n=0;
   for(k=i;k<i+ny;k++)for(l=j;l<j+nx;l++){
     if(l < Xmax && k < Ymax){
       s=(S+k*Xmax+l);
       Rav += (double)s->R;
       Gav += (double)s->G;
       Bav += (double)s->B;
       n++;
     }
   }
   Rav /= (double)n; Gav /= (double)n; Bav /= (double)n;
   for(k=i;k<i+ny;k++)for(l=j;l<j+nx;l++){
     if(l < Xmax && k < Ymax){
       s=(S+k*Xmax+l);
       s->R = (unsigned char)(Rav);
       s->G = (unsigned char)(Gav);
       s->B = (unsigned char)(Bav);
     }
   }
 }
}

static void WipeBlocks(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,ii,jj,id;
 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++;
 n=(long)((double)nnx*(double)nny*mr);
 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 < n && 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++;
 }
}

static void InvertLR(double mr, fullscreenbuffer *S, long Xmax, long Ymax,
                   long R, long G, long B){
 long i,j;
 long w;
 fullscreenbuffer *T,*Row;
 if((T=(fullscreenbuffer *)X__Malloc(Xmax*sizeof(fullscreenbuffer))) == NULL){
   MessageBeep(MB_OK);
   return;
 }
 for(i=0;i<Ymax;i++){
   Row=(S+i*Xmax);
   memcpy(T,Row,Xmax*sizeof(fullscreenbuffer));
   for(j=0;j<Xmax;j++){
     (Row+j)->R = (T+Xmax-1-j)->R;
     (Row+j)->G = (T+Xmax-1-j)->G;
     (Row+j)->B = (T+Xmax-1-j)->B;
     (Row+j)->A = (T+Xmax-1-j)->A;
   }
 }
 X__Free(T);
}

static void InvertUD(double mr, fullscreenbuffer *S, long Xmax, long Ymax,
                   long R, long G, long B){
 long i,j;
 long w;
 fullscreenbuffer *T,*Row1,*Row2;
 if((T=(fullscreenbuffer *)X__Malloc(Xmax*sizeof(fullscreenbuffer))) == NULL){
   MessageBeep(MB_OK);
   return;
 }
 for(i=0;i<Ymax/2;i++){
   Row1=(S+i*Xmax);
   Row2=(S+(Ymax-1-i)*Xmax);
   memcpy(T,Row2,Xmax*sizeof(fullscreenbuffer));
   memcpy(Row2,Row1,Xmax*sizeof(fullscreenbuffer));
   memcpy(Row1,T,Xmax*sizeof(fullscreenbuffer));
 }
 X__Free(T);
}

static void WipeSquareIO(double mr, fullscreenbuffer *S, long Xmax, long Ymax,
                   long R, long G, long B, fullscreenbuffer *Bb){
 long i,j;
 long w,u;
 fullscreenbuffer *bb;
 w=(long)((double)Xmax/2*mr);
 u=(long)((double)Ymax/2*mr);
 for(i=0;i<Ymax;i++)for(j=0;j<Xmax;j++){
   if(j > Xmax/2-w && j < Xmax/2+w &&
      i > Ymax/2-u && i < Ymax/2+u){
     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;
     }
   }
   S++;
 }
}

static void WipeSquareOI(double mr, fullscreenbuffer *S, long Xmax, long Ymax,
                   long R, long G, long B, fullscreenbuffer *Bb){
 long i,j;
 long w,u;
 fullscreenbuffer *bb;
 mr = 1.0-mr;
 w=(long)((double)Xmax/2*mr);
 u=(long)((double)Ymax/2*mr);
 for(i=0;i<Ymax;i++)for(j=0;j<Xmax;j++){
   if(j < Xmax/2-w || j > Xmax/2+w ||
      i < Ymax/2-u || i > Ymax/2+u){
     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;
     }
   }
   S++;
 }
}

static void PiP(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;
 double r,g,b;
 long i,j,w;
 fullscreenbuffer *S,*T,*Tcreen, *bb;
 if((Tcreen=(fullscreenbuffer *)X__Malloc(Xmax*Ymax*sizeof(fullscreenbuffer))) == NULL){
   MessageBeep(MB_OK);
   return;
 }
 T=Tcreen; S=Screen;
 memset(T,0,Xmax*Ymax*sizeof(fullscreenbuffer));
 Mp[2]=Mx[2]=My[2]=p[2]=0.0;
 Mx[1]=0.0; My[0]=0.0;

 if(type == 2){ /* zoom */
   Mx[0]=max(1.0,(double)Xmax-mr*(double)(Xmax));
   My[1]=max(1.0,(double)Ymax-mr*(double)(Ymax));
   Mp[0]=mr*(double)Xmax/2;
   Mp[1]=mr*(double)Ymax/2;
 }
 else if(type == 3){ /* squeeze LR */
   Mx[0]=max(1.0,(double)Xmax-mr*(double)(Xmax));
   My[1]=(double)Ymax;
   Mp[0]=mr*(double)Xmax/2;
   Mp[1]=0.0;
 }
 else if(type == 4){ /* squeeze UD */
   Mx[0]=(double)Xmax;
   My[1]=max(1.0,(double)Ymax-mr*(double)(Ymax));
   Mp[0]=0.0;
   Mp[1]=mr*(double)Ymax/2;
 }
 else {
   Mx[0]=(double)Xmax+mr*(double)(Xmax/2-Xmax);
   My[1]=(double)Ymax+mr*(double)(Ymax/2-Ymax);
   Mp[0]=mr*(double)nx;
   Mp[1]=mr*(double)ny;
 }

 for(i=0;i<Ymax;i++)for(j=0;j<Xmax;j++){
   p[0]=(double)j;
   p[1]=(double)i;
   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 if(w < 0 && type == 0){
     T->R=S->R;
     T->G=S->G;
     T->B=S->B;
   }
   else{
     T->R=(unsigned char)R;
     T->G=(unsigned char)G;
     T->B=(unsigned char)B;
   }
   T->A=S->A;
   S++;
   T++;
 }
 memcpy(Screen,Tcreen,Xmax*Ymax*sizeof(fullscreenbuffer));
 X__Free(Tcreen);
}

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;
 double r,g,b;
 long i,j,w;
 double Tx[4][4],Ta[4][4],Tb[4][4],angle;
 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,45);
 if(type != 2){
   nx = min(nx,89);
 }
 angle = nx*mr;
 angle *= PI/180.0;
 if(type == 0){
   roty(Tx,angle);
   Mx[0]=(double)Xmax+mr*(double)(Xmax*0.95-Xmax);
   My[1]=(double)Ymax+mr*(double)(Ymax*0.9-Ymax);
   Mp[0]=mr*(double)Xmax*0.025;
   Mp[1]=mr*(double)Ymax*0.05;
   VECCOPY(Mx,Mxx)
   m4by1(Tx,Mxx,Mx);
   VECCOPY(My,Mxx)
   m4by1(Tx,Mxx,My);
   VECCOPY(Mn,Mxx)
   m4by1(Tx,Mxx,Mn);
 }
 else if(type == 1){
   rotx(Tx,-angle);
   Mx[0]=(double)Xmax+mr*(double)(Xmax*0.95-Xmax);
   My[1]=(double)Ymax+mr*(double)(Ymax*0.9-Ymax);
   Mp[0]=mr*(double)Xmax*0.025;
   Mp[1]=Ymax-fabs((double)Ymax*cos(angle));
   Mp[2]=fabs((double)Ymax*sin(angle));
   VECCOPY(Mx,Mxx)
   m4by1(Tx,Mxx,Mx);
   VECCOPY(My,Mxx)
   m4by1(Tx,Mxx,My);
   VECCOPY(Mn,Mxx)
   m4by1(Tx,Mxx,Mn);
 }
 else if(type == 2){
   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);
   rotz(Tx,angle);
   m4by4(Tx,Ta,Tb);
   tram(Tx,(double)Xmax*0.5,(double)Ymax*0.5,0.0);
   m4by4(Tx,Tb,Ta);
   m4by1(Ta,Mx,x);
   m4by1(Ta,My,y);
   VECCOPY(Mp,Mxx)
   m4by1(Ta,Mxx,Mp);
   VECSUB(x,Mp,Mx)
   VECSUB(y,Mp,My)
//   VECCOPY(Mn,Mxx)
//   m4by1(Tx,Mxx,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);
}

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;
#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;
 }
 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 && type != 1 && type != 2 && type != 3 && type != 8 &&
    type != 9 && type != 11 && type != 12 && type != 13){
   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)FadeTo(mr,Screen,Xmax,Ymax,cR,cG,cB,BackBuffer);
 if(type ==  1)Desaturate(mr,Screen,Xmax,Ymax,cR,cG,cB);
 if(type ==  2)Monochrome(mr,Screen,Xmax,Ymax,cR,cG,cB);
 if(type ==  3)Negative(mr,Screen,Xmax,Ymax,cR,cG,cB);
 if(type ==  4)WipeLR(mr,Screen,Xmax,Ymax,cR,cG,cB,BackBuffer);
 if(type ==  5)WipeRL(mr,Screen,Xmax,Ymax,cR,cG,cB,BackBuffer);
 if(type ==  6)WipeUD(mr,Screen,Xmax,Ymax,cR,cG,cB,BackBuffer);
 if(type ==  7)WipeDU(mr,Screen,Xmax,Ymax,cR,cG,cB,BackBuffer);
 if(type ==  8)Colourise(mr,Screen,Xmax,Ymax,nx);
 if(type ==  9)Pixelate(mr,Screen,Xmax,Ymax,nx,ny);
 if(type == 10)WipeBlocks(mr,Screen,Xmax,Ymax,nx,ny,cR,cG,cB,BackBuffer);
 if(type == 11)ChangeHue(mr,Screen,Xmax,Ymax,nx);
 if(type == 12)InvertLR(mr,Screen,Xmax,Ymax,cR,cG,cB);
 if(type == 13)InvertUD(mr,Screen,Xmax,Ymax,cR,cG,cB);
 if(type == 14)WipeSquareIO(mr,Screen,Xmax,Ymax,cR,cG,cB,BackBuffer);
 if(type == 15)WipeSquareOI(mr,Screen,Xmax,Ymax,cR,cG,cB,BackBuffer);
 if(type == 16)PiP(mr,Screen,Xmax,Ymax,nx,ny,cR,cG,cB,0,NULL);
 if(type == 17)PiP(mr,Screen,Xmax,Ymax,nx,ny,cR,cG,cB,1,BackBuffer);
 if(type == 18)PiP(mr,Screen,Xmax,Ymax,nx,ny,cR,cG,cB,2,BackBuffer);
 if(type == 19)PiP(mr,Screen,Xmax,Ymax,nx,ny,cR,cG,cB,3,BackBuffer);
 if(type == 20)PiP(mr,Screen,Xmax,Ymax,nx,ny,cR,cG,cB,4,BackBuffer);
 if(type == 21)FoldPiP(mr,Screen,Xmax,Ymax,nx,ny,cR,cG,cB,0,BackBuffer);
 if(type == 22)FoldPiP(mr,Screen,Xmax,Ymax,nx,ny,cR,cG,cB,1,BackBuffer);
 if(type == 23)FoldPiP(mr,Screen,Xmax,Ymax,nx,ny,cR,cG,cB,2,BackBuffer);
 if(BackBuffer != NULL)X__Free(BackBuffer);
 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 24

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);
 }
}


/*************** Function that renders anyof the OpenGL Functionality ************/

long _RenderGLexternal(char *PrmList, XIMAGE *lpXimage){
MessageBox(NULL,"Fog OpenGL function called","OK",MB_OK);
 return 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
 };
 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
 };
 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-2;i++){
     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);
     return TRUE;
   case WM_PAINT:
     PaintBackground(hwnd);
     break;
   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);
//          for(i=0;i<NVIDEO;i++)
//            if(SendDlgItemMessage(hwnd,type_list[i],BM_GETCHECK,0,0))type=i;
          EndDialog(hwnd,TRUE);
          return(TRUE);
        default:
          break;
      }
      break;
    default: break;
 }
 return FALSE;
}

#include "video2.c"