Monster Media 1994 #1/monster.zip/monster/PROG_C/VGAGRAPH.ZIP/GRAPHX.C

C/C++ Source or Header | 1993-03-25 | 21KB | 1,226 lines

#include <dos.h>
#include <string.h>
#include <mem.h>
#include <stdio.h>
#include <io.h>
#include <fcntl.h>
#include <dir.h>
#include <stdlib.h>
#include <alloc.h>
#include "low.h"

extern char byte_tabXL[4];
extern char byte_tabXR[4];
extern char char_tab[16];
extern char byte_tab[8];
extern char pln_tab[4];

extern unsigned int BytesPerLine,FastPlace;

typedef
     struct {
       unsigned int dx,dy,type;
       unsigned int p[4];
       } Image;

void setscrlinex(unsigned int w)
{
    w=w*BytesPerLine;
    outportb(0x3D4,0x0C);outportb(0x3D5,w>>8);
    outportb(0x3D4,0x0D);outportb(0x3D5,w);
}
void putpixelx(int x,int y,char color)
{
    asm{
    mov     cx,x
    and     cl,3
    mov     ah,1
    shl     ah,cl
    mov     dx,3C4h
    mov     al,02h
    out     dx,ax
    mov     ax,0A000h
    mov     es,ax
    mov     ax,y
    mul     BytesPerLine
    mov     cx,x
    shr     cx,2
        add     ax,cx
    mov     si,ax
    mov     cl,color
    mov     es:[si],cl
    mov     dx,03C4h
    mov     ax,0F02h
    out     dx,ax
    }
}
char getpixelx(int x,int y)
{
char b;

    asm{
    mov    ah,byte ptr x
    and     ah,011b
    mov    al,04h
    mov    dx,03CEh
    out    dx,ax
    mov     ax,0A000h
        mov     es,ax
    mov     ax,y
        mul     BytesPerLine
        mov     di,x
        shr     di,2
    add     di,ax
    mov     al,es:[di]
    mov     b,al
    mov     ax,0004h
    mov     dx,03CEh
    out     dx,ax
    }
    return(b);
}
void clearscrx(char color)
{
    asm{
      cld
      mov   ax,0A000h
      mov   es,ax
      mov   di,0
      mov   dx,03C4h
      mov   ax,0F02h
      out   dx,ax
      mov   cx,0FFFFh
      mov   al,color
      rep   stosb
    }
}
void linex(int x1,int y1,int x2,int y2,char color)
{
int delta_x,delta_y,distance,add1,add2;

      asm{
     cld
     mov   ax,0A000h
     mov   es,ax
     mov   cx,x2
     cmp   cx,x1
     jg    cont1
     mov   cx,x2
     xchg  cx,x1
     mov   x2,cx
     mov   cx,y2
     xchg  cx,y1
     mov   y2,cx
     }
cont1:
     asm{
     mov   cx,y2
     sub   cx,y1
     mov   ax,y1
     mul   BytesPerLine
     mov   si,x1
     shr   si,2
     add   si,ax
     mov   cl,byte ptr x1
     and   cl,011b
     mov   ah,01h
     shl   ah,cl
     mov   al,02h
     mov   dx,03C4h
     out   dx,al
     inc   dx
     mov   cx,y2
     sub   cx,y1
     js   UPLine
     mov   delta_y,cx
     mov   bx,cx
     mov   cx,x2
     sub   cx,x1
     mov   delta_x,cx
     cmp   bx,cx
     jg    dy_g
     mov   distance,cx
     jmp   cont2
     }
dy_g:
     asm{
     mov   distance,bx
     }
cont2:
     asm{
     mov   cx,0
     mov   bx,0
     mov   di,distance
     mov   al,ah
     mov   ah,color
     }
L1:
     asm{
     out   dx,al
     mov   es:[si],ah
     add   cx,delta_y
     add   bx,delta_x

     cmp   bx,di
     jl    cont4
     sub   bx,di
     rol   al,1
     and   al,00001111b
     jnz   cont4
     inc   si
     mov   al,01h
     }
cont4:
     asm{
     cmp   cx,di
     jl    cont5
     sub   cx,di
     add   si,word ptr BytesPerLine
     }
cont5:
     asm{
     dec   distance
     jns   L1
     jmp   LineEnd
     }
UPLine:
     asm{
     neg   cx
     mov   delta_y,cx
     mov   bx,cx
     mov   cx,x2
     sub   cx,x1
     mov   delta_x,cx
     cmp   bx,cx
     jg    dy_g_
     mov   distance,cx
     jmp   cont2_
     }
dy_g_:
     asm{
     mov   distance,bx
     }
cont2_:
     asm{
     mov   cx,0
     mov   bx,0
     mov   di,distance
     mov   al,ah
     mov   ah,color
     }
L1_:
     asm{
     out   dx,al
     mov   es:[si],ah
     add   cx,delta_y
     add   bx,delta_x

     cmp   bx,di
     jl    cont4_
     sub   bx,di
     rol   al,1
     and   al,00001111b
     jnz   cont4_
     inc   si
     mov   al,01h
     }
cont4_:
     asm{
     cmp   cx,di
     jl    cont5_
     sub   cx,di
     sub   si,word ptr BytesPerLine
     }
cont5_:
     asm{
     dec   distance
     jns   L1_
     jmp   LineEnd
     }
cont5__:
     asm{
     neg   bx
     inc   bx
     mov   ax,y2
     }
cont6:
     asm{
     mul   BytesPerLine
     mov   si,x1
     shr   si,2
     add   si,ax
     mov   cl,byte ptr x1
     and   cl,011b
     mov   ah,01h
     shl   ah,cl
     mov   al,02h
     mov   dx,03C4h
     out   dx,ax
     mov   al,color
     }
L2:
     asm{
     mov   es:[si],al
     add   si,word ptr BytesPerLine
     dec   bx
     jnz   L2
     jmp   LineEnd
     }
NotMixMask:
     asm{
     mov   ah,color
     mov   al,02h
     mov   dx,03C4h
     out   dx,al
     inc   dx
     mov   al,bh
     out   dx,al
     mov   es:[di],ah
     inc   di
     dec   cx
     js    LineEnd
     jz    RightEdge
     mov   al,0Fh
     out   dx,al
     mov   al,ah
     rep   stosb
     }
RightEdge:
     asm{
     mov   al,bl
     out   dx,al
     mov   es:[di],ah
     }
LineEnd:;

}

void barx(int x,int y,int dx,int dy,int colorb)
{
char l=dx;

       asm{
     cld
     mov   ax,0A000h
     mov   es,ax
     mov   ax,y
     mul   BytesPerLine
     mov   di,x
     shr   di,2
     add   di,ax
     mov   ax,0F02h
     mov   dx,03C4h
     out   dx,ax
     mov   si,word ptr l
     shr   si,2
     mov   bx,dy
     inc   bx
     mov   al,byte ptr colorb
     mov   dx,word ptr BytesPerLine
     sub   dx,si
     }
L1:
     asm{
     mov   cx,si
     rep   stosb
     add   di,dx
     dec   bx
     jnz   L1
     }
}
void barsx(int x,int y,int dx,int dy,char colorb)
{
int  x2,add1,add2;
char Mask_bl;

       x2=x+dx;
       asm{
     cld
     inc   dy
     mov   ax,y
     mul   BytesPerLine
     mov   di,x
     shr   di,2
     add   di,ax
     mov   add1,di
     mov   di,x2
     inc   di
     shr   di,2
     add   di,ax
     mov   add2,di
     mov   si,x
     and   si,03h
     mov   bh,byte ptr byte_tabXL[si]
     mov   si,x2
     inc   si
     and   si,03h
     }
     Mask_bl=byte_tabXR[_SI];
     asm{
     mov   dx,03C4h
     mov   al,02h
     out   dx,ax
     inc   dx
     mov   ax,0A000h
     mov   es,ax
     sub   di,word ptr add1
     jnz   Not_Set_Mask
     jmp   Not_Set_Mask1
     }
Not_Set_Mask:
     asm{
     cmp   bh,0Fh
     jne   Not_Set_Mask1
     dec   add1
     jmp   Middle_Part
     }
Not_Set_Mask1:
     asm{
     mov   cx,dy
     mov   di,add1
     mov   al,bh
     out   dx,al
     mov   al,colorb
     }
L1:
     asm{
     stosb
     dec   di
     add   di,word ptr BytesPerLine
     dec   cx
     jnz   L1
     }
Middle_Part:
     asm{
     mov   si,add2
     dec   si
     sub   si,word ptr add1
     js    Fill_Done
     jz    RightEdge
     mov   al,0FFh
     out   dx,al
     mov   cx,si

     mov   bx,dy
     mov   di,add1
     inc   di
     mov   al,colorb
     push  bp
     mov   bp,word ptr BytesPerLine
     sub   bp,cx
     }
L2:
     asm{
     rep   stosb
     add   di,bp
     mov   cx,si
     dec   bx
     jnz   L2
     pop   bp
     }

RightEdge:
     asm{
     mov   bl,Mask_bl
     cmp   bl,00h
     je    Fill_Done
     mov   al,bl
     out   dx,al
     mov   di,add2
     mov   cx,dy
     mov   al,colorb
     }
L3:
     asm{
     stosb
     dec   di
     add   di,word ptr BytesPerLine
     dec   cx
     jnz   L3
     }
Fill_Done:;
}
void barpatx(int x,int y,int dx,int dy,char colorb1,char colorb2)
{
int l=dx;
unsigned int count,add1,add2;

       asm{
     cld
     mov   ax,0A000h
     mov   es,ax
         mov   di,x
         shr   di,2
         mov   ax,y
     mul   BytesPerLine
     add   di,ax
         mov   add1,di
     add   di,word ptr BytesPerLine
     mov   add2,di
     mov   di,add1
     mov   dx,03C4h
     mov   al,02h
     out   dx,al
     inc   dx
     mov   ah,colorb1
     mov   al,10
     out   dx,al
     mov   es:[di],ah
     mov   al,5
     out   dx,al
     mov   ah,colorb2
     mov   es:[di],ah
         mov   ah,colorb1
         mov   al,5
     out   dx,al
     mov   di,add2
         mov   es:[di],ah
     mov   al,10
         out   dx,al
         mov   ah,colorb2
         mov   es:[di],ah
         mov   al,0Fh
         out   dx,al
     mov   dx,03CEh
         mov   ax,0008h
     out   dx,ax
     mov   bx,dy
     inc   bx
     mov   dx,l
     shr   dx,2
     mov   si,word ptr BytesPerLine
     sub   si,dx
     mov   count,si
     mov   si,add1
     mov   di,si
     }
L1:
     asm{
     mov   al,es:[si]
     mov   cx,dx
     rep   stosb
     xchg  si,add2
     add   di,count
     dec   bx
     jnz   L1
       }
       outport(0x03CE,0xFF08);
}
void displaycharx(int x,int y,char s,char colorf,char colorb,char flag)
{
char char_tab1[16];
unsigned int Bytes,yoff,CellOff,dssave;
char Shift_C,Left_Mask,Right_Mask,ScanLine,BM,SM1,SM,bb,bb1,b,ln;

       memmove(char_tab1,char_tab,16);
       ln=1;
     asm{
     cld
     mov    dssave,ds
     mov    ax,BytesPerLine
     mov    Bytes,ax
     mov    ax,40h
     mov    ds,ax
     mov    al,ds:[85h]
     mov    ScanLine,al
     mul    Bytes
     dec    ax
     mov    CellOff,ax
     xor    ax,ax
     mov    ds,ax
     mov    bx,010Ch
     lds    si,ds:[bx]
     mov    ax,0A000h
     mov    es,ax
     mov    ax,Bytes
     mul    y
     mov    yoff,ax
     mov    ax,x
     shr    ax,2
     add    yoff,ax
     mov    bx,01h
     mov    dx,03C4h
     mov    al,02h
     out    dx,al
     inc    dx
     mov    di,x
     and    di,03h
     jz     Byte_A
     jmp    NByte_A
     }
Byte_A:
     asm{
     xor    cx,cx
     mov    cl,ln
     mov    di,yoff
     }
     if (flag==1) goto L__1;
     asm{
     dec    Bytes
     dec    CellOff
     }
L1:
     asm{
     push   cx
     push   si
     xchg   di,bx
     mov    al,s
     mul    byte  ptr  ScanLine
     add    si,ax
     xchg   di,bx
     inc    bx
     mov    cl,ScanLine
     }
L11:
     asm{
     lodsb
     push   si
     mov    BM,al
     shr    al,4
     xor    ah,ah
     mov    si,ax
     mov    al,byte ptr char_tab1[si]
     out    dx,al
     mov    ah,colorf
     mov    es:[di],ah
     inc    di
     mov    al,BM
     and    al,00001111b
     xor    ah,ah
     mov    si,ax
     mov    al,byte ptr char_tab1[si]
     out    dx,al
     mov    ah,colorf
     mov    es:[di],ah
     add    di,Bytes
     pop    si
     loop   L11
     sub    di,CellOff
     pop    si
     pop    cx
     loop   L1
     jmp    STR_OUT
     }
L__1:
     asm{
     dec    Bytes
     dec    CellOff
     }
L_1:
     asm{
     push   cx
     push   si
         xchg   di,bx
     mov    al,s
     mul    byte  ptr  ScanLine
     add    si,ax
     xchg   di,bx
     inc    bx
     mov    cl,ScanLine
     }
L_11:
     asm{
     lodsb
     xor    ah,ah
     mov    BM,al
     push   si
     not    al
     shr    al,4
     mov    si,ax
     mov    al,byte ptr char_tab1[si]
     out    dx,al
     mov    al,colorb
     mov    es:[di],al
     mov    al,BM
     not    al
         and    al,00001111b
         mov    si,ax
     mov    al,byte ptr char_tab1[si]
     out    dx,al
         mov    al,colorb
         mov    es:[di+1],al
     mov    al,BM
         shr    al,4
         mov    si,ax
         mov    al,byte ptr char_tab1[si]
         out    dx,al
         mov    ah,colorf
     mov    es:[di],ah
         inc    di
         mov    al,BM
         and    al,00001111b
     xor    ah,ah
         mov    si,ax
         mov    al,byte ptr char_tab1[si]
     out    dx,al
         mov    ah,colorf
         mov    es:[di],ah
     add    di,Bytes
     pop    si
         loop   L_11
         sub    di,CellOff
     pop    si
     pop    cx
     loop   L_1
     jmp    STR_OUT
     }
NByte_A:
     asm{
     mov   cx,x
         mov   di,x
         shr   di,2
     shl   di,2
         sub   cx,di
         mov   SM,cl
     mov   ax,4
     sub   ax,cx
     mov   SM1,al
     xor   cx,cx
     mov   cl,ln
     mov   bb,cl
     mov   di,yoff
     }
     if (flag==1) goto L__2;
     asm{
     dec   CellOff
     }
L2:
     asm{
     push  cx
     push  si
     xchg  di,bx
     mov   al,s
     mul   ScanLine
     add   si,ax
     xchg  di,bx
     inc   bx
     mov   cl,ScanLine
     }
L22:
     asm{
     push  cx
     push  si
         mov   al,ds:[si]
         mov   BM,al
         shr   al,4
         mov   cl,SM
         shr   al,cl
     xor   ah,ah
         mov   si,ax
         mov   al,byte ptr char_tab1[si]
         out   dx,al
     mov   ah,colorf
         mov   es:[di],ah

         mov   al,BM
         shr   al,4
         mov   cl,SM1
         shl   al,cl
     and   al,00001111b
     mov   ah,BM
     and   ah,00001111b
         mov   cl,SM
         shr   ah,cl
         or    al,ah
         xor   ah,ah
         mov   si,ax
         mov   al,byte ptr char_tab1[si]
     out   dx,al
         mov   ah,colorf
         mov   es:[di+1],ah

     mov   al,BM
         and   al,00001111b
         mov   cl,SM1
         shl   al,cl
         and   al,00001111b
         xor   ah,ah
         mov   si,ax
     mov   al,byte ptr char_tab1[si]
     out   dx,al
     mov   ah,colorf
     mov   es:[di+2],ah
     pop   si
     inc   si
     add   di,Bytes
     pop   cx
     loop  L22
     sub   di,CellOff
     pop   si
     pop   cx
     dec   bb
     }
     if (bb!=0) goto L2;
     asm{
     jmp   STR_OUT
     }
L__2:
     asm{
     dec   CellOff
     }
L_2:
     asm{
     push  cx
     push  si
     xchg  di,bx
     mov   al,s
     mul   ScanLine
     add   si,ax
     xchg  di,bx
     inc   bx
     mov   al,ScanLine
     mov   bb1,al
     }
L_22:
     asm{
     mov   al,ds:[si]
     mov   BM,al
     push  si
     xor   ah,ah
         not   al
     mov   cl,SM
         shr   al,4
         shr   al,cl
         mov   si,ax
         mov   al,byte ptr char_tab1[si]
     out   dx,al
         mov   al,colorb
         mov   es:[di],al
         mov   al,BM
     shr   al,4
         mov   cl,SM
         shr   al,cl
         mov   si,ax
     mov   al,byte ptr char_tab1[si]
     out   dx,al
         mov   ah,colorf
         mov   es:[di],ah

         mov   al,BM
         not   al
     shr   al,4
         mov   cl,SM1
         shl   al,cl
         and   al,00001111b
         mov   ah,BM
     not   ah
         and   ah,00001111b
         mov   cl,SM
         shr   ah,cl
     or    al,ah
         xor   ah,ah
         mov   si,ax
         mov   al,byte ptr char_tab1[si]
     out   dx,al
     mov   al,colorb
         mov   es:[di+1],al
         mov   al,BM
         shr   al,4
         mov   cl,SM1
         shl   al,cl
     and   al,00001111b
         mov   ah,BM
         and   ah,00001111b
         mov   cl,SM
         shr   ah,cl
     or    al,ah
         xor   ah,ah
         mov   si,ax
         mov   al,byte ptr char_tab1[si]
     out   dx,al
         mov   ah,colorf
         mov   es:[di+1],ah

     xor   ah,ah
     mov   al,BM
         mov   cl,SM1
         not   al
         and   al,00001111b
         shl   al,cl
         and   al,00001111b
     mov   si,ax
         mov   al,byte ptr char_tab1[si]
         out   dx,al
         mov   al,colorb
         mov   es:[di+2],al
     mov   al,BM
         and   al,00001111b
         mov   cl,SM1
         shl   al,cl
     and   al,00001111b
         mov   si,ax
         mov   al,byte ptr char_tab1[si]
         out   dx,al
     mov   ah,colorf
     mov   es:[di+2],ah
     pop   si
     inc   si
     add   di,Bytes
     dec   bb1
     }
     if (bb1!=0) goto L_22;
     asm{
     sub   di,CellOff
     pop   si
     pop   cx
     dec   bb
     }
     if (bb!=0) goto L_2;
STR_OUT:
     asm{
     mov   al,0Fh
     out   dx,al
     mov   ds,dssave
     }
}
void setcolx(char colorf,char colorb,unsigned int place)
{
char BM;
char char_tab1[16];

      FastPlace=place;
      memmove(char_tab1,char_tab,16);
      asm{
    cld
    push    ds
    mov     ax,FastPlace
    push    ax
    mov     ax,40h
        mov     ds,ax
    mov     cx,ds:[85h]
        xor     ax,ax
        mov     ds,ax
        mov     bx,43h*4
        lds     si,ds:[bx]
        mov     ax,0A000h
        mov     es,ax
        pop     ax
    mov     di,ax
    mov     al,0h
        mov     ah,1h
        mul     cx
        mov     cx,ax
        mov     bl,colorf
        mov     bh,colorb
        mov     dx,03C4h
    mov     al,02h
    out     dx,al
    inc     dx
    }
L1:
    asm{
    mov     al,ds:[si]
    mov     BM,al
    push    si
    xor     ah,ah
    shr     al,4
    mov     si,ax
    mov     al,byte ptr char_tab1[si]
    out     dx,al
    mov     es:[di],bl
    mov     al,BM
    not     al
    shr     al,4
    mov     si,ax
    mov     al,byte ptr char_tab1[si]
    out     dx,al
    mov     es:[di],bh
    inc     di
    mov     al,BM
    and     al,00001111b
    mov     si,ax
    mov     al,byte ptr char_tab1[si]
    out     dx,al
    mov     es:[di],bl
    mov     al,BM
    not     al
    and     al,00001111b
    mov     si,ax
    mov     al,byte ptr char_tab1[si]
        out     dx,al
        mov     es:[di],bh
        pop     si
        inc     di
        inc     si
        loop    L1
        mov     al,0Fh
        out     dx,al
        pop     ds
    }
}
void fasttextx(int x,int y,char *s)
{
char *strs;
unsigned int Bytes,ScanLine,wd,w;
char i,b;

      strcpy(strs,s);
      asm{
    cld
    push    ds
    mov     ax,FastPlace
    push    ax
    mov     ax,BytesPerLine
    mov     Bytes,ax
    mov     ax,40h
    mov     ds,ax
    mov     ax,ds:[85h]
    mov     ScanLine,ax
    mov     ax,0A000h
    mov     es,ax
    mov     ds,ax

    mov     dx,03CEh
    mov     ax,0008h
    out     dx,ax
    mov     dx,03C4h
    mov     ax,0F02h
    out     dx,ax

    mov     ax,y
    mul     Bytes
    mov     di,x
    shr     di,2
    add     di,ax
    mov     dx,di
    mov     bx,Bytes
    mov     wd,dx
    mov     w,bx
    }
    for(i=0;i<strlen(strs);i++)
      {
      b=strs[i];
      asm{
    mov     ax,0A000h
    mov     es,ax
    mov     ax,0A000h
    mov     ds,ax
    mov     dx,wd
    pop     ax
    mov     si,ax
    push    ax
    mov     al,b
    mov     cx,ScanLine
    mul     cl
    shl     ax,1
    add     si,ax
    mov     di,dx
    }
L1:
    asm{
    movsb
    movsb
    dec     di
    dec     di
    add     di,w
    loop    L1
    inc     dx
    inc     dx
    mov     wd,dx
    }
      }
      asm{
    pop     ax
    pop     ds
    mov     ax,0FF08h
    mov     dx,03CEh
    out     dx,ax
    mov     ax,0F02h
    mov     dx,03C4h
    out     dx,ax
    }
}

char getimageramx(unsigned int x,unsigned int y,unsigned int dx,
           unsigned int dy,Image *W)
{
unsigned int i,j,k,scrofs,xend;
long t,l;
char s[20];
    xend=x+dx;
    x=x >> 2;
    if (xend % 4 != 0) xend=((xend >> 2) << 2)+4;
    dx=xend-x;
    W->dx=dx >> 2;
    W->dy=dy;
    t=coreleft();

    l=(W->dy+1)*(W->dx)*(long)(4);
    t=l-t+10000;
    if (t>0) return(1);

    for (i=0;i<=3;i++)
    t=allocmem(((W->dx)*(W->dy+1))/16+1,&W->p[i]);

    outportb(0x03CE,4);
    k=y*BytesPerLine+x;

    for (i=0;i<=3;i++){
        scrofs=k;
        outportb(0x03CF,i);
    for (j=0;j<=W->dy;j++){
        move(0xA000,scrofs,W->p[i],j*W->dx,W->dx);
        scrofs=scrofs+BytesPerLine;
        }
        }
    W->type=0;
    outport(0x03CE,0x0004);
    return(0);
}
void putimageramx(unsigned int x,unsigned int y,Image W,char Restore)
{
unsigned int  i,j,scrofs;

    scrofs=y*BytesPerLine+(x >> 2);
    outportb(0x03C4,0x02);
    for (i=0;i<=W.dy;i++)
        {
    for (j=0;j<=3;j++)
        {
        outportb(0x03C5,1 << j);
        move(W.p[j],i*W.dx,0xA000,scrofs,W.dx);
        }
        scrofs=scrofs+BytesPerLine;
        }
    if (Restore==0) for (i=0;i<=3;i++) freemem(W.p[i]);

}
char getimagediskx(unsigned int x,unsigned int y,unsigned int dx,unsigned int dy,
           Image *W)
{
unsigned int  k,i,j,n,bufsize,xend,Buff,scrofs;
long t0,ll,l;
int   f;
struct dfree free;
long avail;
int drive;
char Name[12];
void far *buff;
char *buffer;

    xend=x+dx;
    x=x >> 2;
    if (xend % 4 != 0) xend=((xend >> 2) << 2)+4;
    dx=xend-x;
    W->dx=dx >> 2;
    W->dy=dy;
    l=(W->dy+1)*(W->dx)*(long)(4);


    drive = getdisk()+1;
    getdfree(drive, &free);
    if (free.df_sclus == 0xFFFF) return(1);
    avail =  (long)free.df_avail*(long)free.df_bsec*(long)free.df_sclus;

    l=avail-l;
    if (l<10000) return(1);
    randomize();
    W->p[0]=rand();

    itoa(W->p[0],Name,10);
    _fmode=O_BINARY;
    if ((f=creat(Name,0x0100 | 0x0080))==NULL) return(1);
    l=coreleft();
    if (l>0xFFF0) bufsize=0xFFF0; else bufsize=l;
    bufsize=(bufsize-(bufsize % (W->dx*4)));
    if (l>80) t0=allocmem(bufsize/16+1,&Buff); else return(1);
    if (t0!=-1) return(1);

    buff=MK_FP(Buff,0);
    scrofs=y*BytesPerLine+x;
    outportb(0x03CE,4);

    k=0;
    for (i=0;i<=W->dy;i++)
        {
    for (j=0;j<=3;j++)
        {
        outportb(0x03CF,j);
        move(0xA000,scrofs,Buff,k,W->dx);
        k=k+W->dx;
        }
        if (k==bufsize)
           {
           write(f,buff,bufsize);
           k=0;
           }
           scrofs=scrofs+BytesPerLine;
        }
        if (k!=0) write(f,buff,k);
        freemem(Buff);
        close(f);
        W->type=1;
        outport(0x03CE,0x0004);
        return(0);
}
void putimagediskx(unsigned int x,unsigned int y,Image W,char Restore)
{
unsigned int  k,i,j,bufsize,scrofs,Buff;
long t0,l;
int  f,b;
char Name[12];
void far *buff;

       itoa(W.p[0],Name,10);
       _fmode=O_BINARY;
       if ((f=open(Name,0x0100 | 0x0080))==NULL) exit(0);
       l= coreleft();
       if (l>0xFFF0) bufsize=0xFFF0; else bufsize=l;
       bufsize=(bufsize-(bufsize % (W.dx*4)));
       if (l>80) t0=allocmem(bufsize/16+1,&Buff); else exit(0);
       if (t0!=-1) exit(0);
       buff=MK_FP(Buff,0);
       scrofs=y*BytesPerLine+(x >> 2);
       read(f,buff,bufsize);
       k=0;
       outportb(0x03C4,0x02);
       for (i=0;i<=W.dy;i++)
           {
       for (j=0;j<=3;j++)
           {
           outportb(0x03C5,1 << j);
           move(Buff,k,0xA000,scrofs,W.dx);
           k=k+W.dx;
           }
           if (k==bufsize)
          {
           read(f,buff,bufsize);
           k=0;
           }
           scrofs=scrofs+BytesPerLine;
           }
         freemem(Buff);
         outportb(0x03C5,0x0F);
         close(f);
         if (Restore==0) remove(Name);
}
char getimagex(unsigned int x,unsigned int y,unsigned int dx,unsigned int dy,Image *W)
{
    if (getimageramx(x,y,dx,dy,W)==0) return(0);
    return(getimagediskx(x,y,dx,dy,W));
}
void putimagex(unsigned int x,unsigned int y,Image W,char Restore)
{
     if (W.type==0) putimageramx(x,y,W,Restore);
     if (W.type==1) putimagediskx(x,y,W,Restore);
}
void screentoscreenx(int x,int y,int dx,int dy,int x1,int y1)
{
unsigned int ofsp,ofsp1,i,j;

     outport(0x03CE,0x0008);
     outport(0x03C4,0x0f02);
     x=x >> 2;
     x1=x1 >> 2;
     dx=dx >> 2;
     ofsp=y*BytesPerLine+x;
     ofsp1=y1*BytesPerLine+x1;
     for (i=y;i<=(y+dy);i++)
     {
     move(0xA000,ofsp,0xA000,ofsp1,dx);
     ofsp=ofsp+BytesPerLine;
     ofsp1=ofsp1+BytesPerLine;
     }
    outport(0x03CE,0xff08);
}